+using InputManager = Ryujinx.Input.HLE.InputManager;

+using IRenderer = Ryujinx.Graphics.GAL.IRenderer;

+ if (!Device.LoadXci(ApplicationPath))

+ if (!Device.LoadNsp(ApplicationPath))

+using Ryujinx.Ui.App.Common;

+ (Nca updatePatchNca, _) = ApplicationLibrary.GetGameUpdateData(_virtualFileSystem, mainNca.Header.TitleId.ToString("x16"), programIndex, out _);

+using Avalonia.Threading;

+using System.Globalization;

+ ApplicationLibrary.LoadAndSaveMetaData(viewModel.SelectedApplication.TitleId, appMetadata =>

+ if (!ulong.TryParse(viewModel.SelectedApplication.TitleId, NumberStyles.HexNumber, CultureInfo.InvariantCulture, out ulong titleIdNumber))

+ {

+ Dispatcher.UIThread.InvokeAsync(async () =>

+ {

+ await ContentDialogHelper.CreateErrorDialog(LocaleManager.Instance[LocaleKeys.DialogRyujinxErrorMessage], LocaleManager.Instance[LocaleKeys.DialogInvalidTitleIdErrorMessage]);

+ });

+

+ return;

+ }

+

+ var saveDataFilter = SaveDataFilter.Make(titleIdNumber, saveDataType, userId, saveDataId: default, index: default);

+ ApplicationHelper.OpenSaveDir(in saveDataFilter, titleIdNumber, viewModel.SelectedApplication.ControlHolder, viewModel.SelectedApplication.TitleName);

+ await TitleUpdateWindow.Show(viewModel.VirtualFileSystem, ulong.Parse(viewModel.SelectedApplication.TitleId, NumberStyles.HexNumber), viewModel.SelectedApplication.TitleName);

+ await DownloadableContentManagerWindow.Show(viewModel.VirtualFileSystem, ulong.Parse(viewModel.SelectedApplication.TitleId, NumberStyles.HexNumber), viewModel.SelectedApplication.TitleName);

+ viewModel.SelectedApplication.TitleId,

+ viewModel.SelectedApplication.TitleName,

+ string titleModsPath = ModLoader.GetTitleDir(modsBasePath, viewModel.SelectedApplication.TitleId);

+ string titleModsPath = ModLoader.GetTitleDir(sdModsBasePath, viewModel.SelectedApplication.TitleId);

+ LocaleManager.Instance.UpdateAndGetDynamicValue(LocaleKeys.DialogPPTCDeletionMessage, viewModel.SelectedApplication.TitleName),

+ DirectoryInfo mainDir = new(Path.Combine(AppDataManager.GamesDirPath, viewModel.SelectedApplication.TitleId, "cache", "cpu", "0"));

+ DirectoryInfo backupDir = new(Path.Combine(AppDataManager.GamesDirPath, viewModel.SelectedApplication.TitleId, "cache", "cpu", "1"));

+ LocaleManager.Instance.UpdateAndGetDynamicValue(LocaleKeys.DialogShaderDeletionMessage, viewModel.SelectedApplication.TitleName),

+ DirectoryInfo shaderCacheDir = new(Path.Combine(AppDataManager.GamesDirPath, viewModel.SelectedApplication.TitleId, "cache", "shader"));

+ string ptcDir = Path.Combine(AppDataManager.GamesDirPath, viewModel.SelectedApplication.TitleId, "cache", "cpu");

+ string shaderCacheDir = Path.Combine(AppDataManager.GamesDirPath, viewModel.SelectedApplication.TitleId, "cache", "shader");

+ viewModel.SelectedApplication.TitleName);

+ viewModel.SelectedApplication.TitleName);

+ viewModel.SelectedApplication.TitleName);

+ ShortcutHelper.CreateAppShortcut(selectedApplication.Path, selectedApplication.TitleName, selectedApplication.TitleId, selectedApplication.Icon);

+ await viewModel.LoadApplication(viewModel.SelectedApplication.Path);

+ Text="{Binding TitleName}"

+ Text="{Binding TitleName}"

+ Text="{Binding TitleId}"

+using Ryujinx.Ava.UI.ViewModels;

+ var appData = MainWindow.MainWindowViewModel.Applications.FirstOrDefault(x => x.TitleId.ToUpper() == TitleIdString);

+ Title = appData.TitleName;

+ public string Label => LocaleManager.Instance.UpdateAndGetDynamicValue(LocaleKeys.TitleUpdateVersionLabel, Control.DisplayVersionString.ToString());

+using System.Threading.Tasks;

+ private readonly ulong _titleId;

+ public DownloadableContentManagerViewModel(VirtualFileSystem virtualFileSystem, ulong titleId)

+ _titleId = titleId;

+ _downloadableContentJsonPath = Path.Combine(AppDataManager.GamesDirPath, titleId.ToString("x16"), "dlc.json");

+ partitionFileSystem.Initialize(containerFile.AsStorage()).ThrowIfFailure();

+ await AddDownloadableContent(file.Path.LocalPath);

+ private async Task AddDownloadableContent(string path)

+ return;

+ PartitionFileSystem partitionFileSystem = new();

+ partitionFileSystem.Initialize(containerFile.AsStorage()).ThrowIfFailure();

+ bool containsDownloadableContent = false;

+ if ((nca.Header.TitleId & 0xFFFFFFFFFFFFE000) != _titleId)

+ containsDownloadableContent = true;

+ if (!containsDownloadableContent)

+ {

+ await ContentDialogHelper.CreateErrorDialog(LocaleManager.Instance[LocaleKeys.DialogDlcNoDlcErrorMessage]);

+ }

+ private string _currentEmulatedGamePath;

+ private string TitleName { get; set; }

+ ApplicationSort.Title => IsAscending ? SortExpressionComparer<ApplicationData>.Ascending(app => app.TitleName)

+ : SortExpressionComparer<ApplicationData>.Descending(app => app.TitleName),

+ return string.IsNullOrWhiteSpace(_searchText) || app.TitleName.ToLower().Contains(_searchText.ToLower());

+ LoadHeading = LocaleManager.Instance.UpdateAndGetDynamicValue(LocaleKeys.LoadingHeading, TitleName);

+ LoadHeading = LocaleManager.Instance.UpdateAndGetDynamicValue(LocaleKeys.LoadingHeading, TitleName);

+ await LoadApplication(_currentEmulatedGamePath);

+ _currentEmulatedGamePath = null;

+ await LoadApplication(result[0].Path.LocalPath);

+ await LoadApplication(result[0].Path.LocalPath);

+ public async Task LoadApplication(string path, bool startFullscreen = false, string titleName = "")

+ SelectedIcon ??= ApplicationLibrary.GetApplicationIcon(path, ConfigurationState.Instance.System.Language);

+ path,

+ LoadHeading = TitleName = titleName;

+ if (string.IsNullOrWhiteSpace(titleName))

+ TitleName = AppHost.Device.Processes.ActiveApplication.Name;

+ _currentEmulatedGamePath = path;

+using Avalonia;

+ private ulong TitleId { get; }

+ public TitleUpdateViewModel(VirtualFileSystem virtualFileSystem, ulong titleId)

+ TitleId = titleId;

+ TitleUpdateJsonPath = Path.Combine(AppDataManager.GamesDirPath, titleId.ToString("x16"), "updates.json");

+ Logger.Warning?.Print(LogClass.Application, $"Failed to deserialize title update data for {TitleId} at {TitleUpdateJsonPath}");

+ private void AddUpdate(string path)

+ var pfs = new PartitionFileSystem();

+ pfs.Initialize(file.AsStorage()).ThrowIfFailure();

+ (Nca patchNca, Nca controlNca) = ApplicationLibrary.GetGameUpdateDataFromPartition(VirtualFileSystem, pfs, TitleId.ToString("x16"), 0);

+ Dispatcher.UIThread.InvokeAsync(() => ContentDialogHelper.CreateErrorDialog(LocaleManager.Instance[LocaleKeys.DialogUpdateAddUpdateErrorMessage]));

+ await ViewModel.LoadApplication(contentPath, false, "Mii Applet");

+ Tag="Title" />

+ BuildId = ApplicationData.GetApplicationBuildId(virtualFileSystem, titlePath);

+ Text="{Binding FileName}" />

+using Button = Avalonia.Controls.Button;

+ public DownloadableContentManagerWindow(VirtualFileSystem virtualFileSystem, ulong titleId)

+ DataContext = ViewModel = new DownloadableContentManagerViewModel(virtualFileSystem, titleId);

+ public static async Task Show(VirtualFileSystem virtualFileSystem, ulong titleId, string titleName)

+ Content = new DownloadableContentManagerWindow(virtualFileSystem, titleId),

+ Title = string.Format(LocaleManager.Instance[LocaleKeys.DlcWindowTitle], titleName, titleId.ToString("X16")),

+using System.IO;

+ string path = new FileInfo(args.Application.Path).FullName;

+

+ ViewModel.LoadApplication(path).Wait();

+ ApplicationLibrary = new ApplicationLibrary(VirtualFileSystem);

+ ViewModel.LoadApplication(_launchPath, _startFullscreen).Wait();

+using Button = Avalonia.Controls.Button;

+ public TitleUpdateViewModel ViewModel;

+ public TitleUpdateWindow(VirtualFileSystem virtualFileSystem, ulong titleId)

+ DataContext = ViewModel = new TitleUpdateViewModel(virtualFileSystem, titleId);

+ public static async Task Show(VirtualFileSystem virtualFileSystem, ulong titleId, string titleName)

+ Content = new TitleUpdateWindow(virtualFileSystem, titleId),

+ Title = LocaleManager.Instance.UpdateAndGetDynamicValue(LocaleKeys.GameUpdateWindowHeading, titleName, titleId.ToString("X16")),

+ static class NcaExtensions

+ /* TODO: Rework this since it's wrong and doesn't work as it takes the DisplayVersion from a "potential" inexistant update.

+using System.Globalization;

+ private static readonly TitleUpdateMetadataJsonSerializerContext _titleSerializerContext = new(JsonHelper.GetDefaultSerializerOptions());

+ internal static (bool, ProcessResult) TryLoad<TMetaData, TFormat, THeader, TEntry>(this PartitionFileSystemCore<TMetaData, TFormat, THeader, TEntry> partitionFileSystem, Switch device, string path, out string errorMessage)

+ device.Configuration.VirtualFileSystem.ImportTickets(partitionFileSystem);

+ // TODO: To support multi-games container, this should use CNMT NCA instead.

+ foreach (DirectoryEntryEx fileEntry in partitionFileSystem.EnumerateEntries("/", "*.nca"))

+ Nca nca = partitionFileSystem.GetNca(device, fileEntry.FullPath);

+

+ if (nca.GetProgramIndex() != device.Configuration.UserChannelPersistence.Index)

+ continue;

+ }

+

+ if (nca.IsPatch())

+ {

+ patchNca = nca;

+ }

+ else if (nca.IsProgram())

+ {

+ mainNca = nca;

+ }

+ else if (nca.IsControl())

+ {

+ controlNca = nca;

+ // Load Update NCAs.

+ Nca updatePatchNca = null;

+ Nca updateControlNca = null;

+

+ if (ulong.TryParse(mainNca.Header.TitleId.ToString("x16"), NumberStyles.HexNumber, CultureInfo.InvariantCulture, out ulong titleIdBase))

+ {

+ // Clear the program index part.

+ titleIdBase &= ~0xFUL;

+

+ // Load update information if exists.

+ string titleUpdateMetadataPath = System.IO.Path.Combine(AppDataManager.GamesDirPath, titleIdBase.ToString("x16"), "updates.json");

+ if (File.Exists(titleUpdateMetadataPath))

+ {

+ string updatePath = JsonHelper.DeserializeFromFile(titleUpdateMetadataPath, _titleSerializerContext.TitleUpdateMetadata).Selected;

+ if (File.Exists(updatePath))

+ {

+ PartitionFileSystem updatePartitionFileSystem = new();

+ updatePartitionFileSystem.Initialize(new FileStream(updatePath, FileMode.Open, FileAccess.Read).AsStorage()).ThrowIfFailure();

+

+ device.Configuration.VirtualFileSystem.ImportTickets(updatePartitionFileSystem);

+

+ // TODO: This should use CNMT NCA instead.

+ foreach (DirectoryEntryEx fileEntry in updatePartitionFileSystem.EnumerateEntries("/", "*.nca"))

+ {

+ Nca nca = updatePartitionFileSystem.GetNca(device, fileEntry.FullPath);

+

+ if (nca.GetProgramIndex() != device.Configuration.UserChannelPersistence.Index)

+ {

+ continue;

+ }

+

+ if ($"{nca.Header.TitleId.ToString("x16")[..^3]}000" != titleIdBase.ToString("x16"))

+ {

+ break;

+ }

+

+ if (nca.IsProgram())

+ {

+ updatePatchNca = nca;

+ }

+ else if (nca.IsControl())

+ {

+ updateControlNca = nca;

+ }

+ }

+ }

+ }

+ }

+ errorMessage = "Unable to load: Could not find Main NCA";

+ public static Nca GetNca(this IFileSystem fileSystem, Switch device, string path)

+ return new Nca(device.Configuration.VirtualFileSystem.KeySet, ncaFile.Release().AsStorage());

+ public bool LoadXci(string path)

+ (bool success, ProcessResult processResult) = xci.OpenPartition(XciPartitionType.Secure).TryLoad(_device, path, out string errorMessage);

+ public bool LoadNsp(string path)

+ (bool success, ProcessResult processResult) = partitionFileSystem.TryLoad(_device, path, out string errorMessage);

+ Nca nca = partitionFileSystem.GetNca(device, fileEntry.FullPath);

+ if (!nca.IsProgram() && nca.IsPatch())

+ ulong currentProgramId = nca.Header.TitleId;

+ ulong currentMainProgramId = currentProgramId & ~0xFFFul;

+ hasIndex[(int)(currentProgramId & 0xF)] = true;

+ public bool LoadXci(string xciFile)

+ return Processes.LoadXci(xciFile);

+ public bool LoadNsp(string nspFile)

+ return Processes.LoadNsp(nspFile);

+ public string TitleName { get; set; }

+ public string TitleId { get; set; }

+ public string Developer { get; set; }

+ public string Version { get; set; }

+ public static string GetApplicationBuildId(VirtualFileSystem virtualFileSystem, string titleFilePath)

+ (Nca updatePatchNca, _) = ApplicationLibrary.GetGameUpdateData(virtualFileSystem, mainNca.Header.TitleId.ToString("x16"), 0, out _);

+using System.Globalization;

+ private static readonly TitleUpdateMetadataJsonSerializerContext _titleSerializerContext = new(JsonHelper.GetDefaultSerializerOptions());

+ public ApplicationLibrary(VirtualFileSystem virtualFileSystem)

+ public void CancelLoading()

+ _cancellationToken?.Cancel();

+ }

+ public static void ReadControlData(IFileSystem controlFs, Span<byte> outProperty)

+ {

+ using UniqueRef<IFile> controlFile = new();

+ controlFs.OpenFile(ref controlFile.Ref, "/control.nacp".ToU8Span(), OpenMode.Read).ThrowIfFailure();

+ controlFile.Get.Read(out _, 0, outProperty, ReadOption.None).ThrowIfFailure();

+ public void LoadApplications(List<string> appDirs, Language desiredTitleLanguage)

+ int numApplicationsFound = 0;

+ int numApplicationsLoaded = 0;

+

+ _desiredTitleLanguage = desiredTitleLanguage;

+

+ _cancellationToken = new CancellationTokenSource();

+ // Builds the applications list with paths to found applications

+ List<string> applications = new();

+ try

+ foreach (string appDir in appDirs)

+ if (_cancellationToken.Token.IsCancellationRequested)

+ {

+ return;

+ }

+ if (!Directory.Exists(appDir))

+ {

+ Logger.Warning?.Print(LogClass.Application, $"The \"game_dirs\" section in \"Config.json\" contains an invalid directory: \"{appDir}\"");

+ continue;

+ }

+ try

+ IEnumerable<string> files = Directory.EnumerateFiles(appDir, "*", SearchOption.AllDirectories).Where(file =>

+ {

+ return

+ (Path.GetExtension(file).ToLower() is ".nsp" && ConfigurationState.Instance.Ui.ShownFileTypes.NSP.Value) ||

+ (Path.GetExtension(file).ToLower() is ".pfs0" && ConfigurationState.Instance.Ui.ShownFileTypes.PFS0.Value) ||

+ (Path.GetExtension(file).ToLower() is ".xci" && ConfigurationState.Instance.Ui.ShownFileTypes.XCI.Value) ||

+ (Path.GetExtension(file).ToLower() is ".nca" && ConfigurationState.Instance.Ui.ShownFileTypes.NCA.Value) ||

+ (Path.GetExtension(file).ToLower() is ".nro" && ConfigurationState.Instance.Ui.ShownFileTypes.NRO.Value) ||

+ (Path.GetExtension(file).ToLower() is ".nso" && ConfigurationState.Instance.Ui.ShownFileTypes.NSO.Value);

+ });

+ foreach (string app in files)

+ {

+ if (_cancellationToken.Token.IsCancellationRequested)

+ {

+ return;

+ }

+

+ var fileInfo = new FileInfo(app);

+ string extension = fileInfo.Extension.ToLower();

+

+ if (!fileInfo.Attributes.HasFlag(FileAttributes.Hidden) && extension is ".nsp" or ".pfs0" or ".xci" or ".nca" or ".nro" or ".nso")

+ {

+ var fullPath = fileInfo.ResolveLinkTarget(true)?.FullName ?? fileInfo.FullName;

+ applications.Add(fullPath);

+ numApplicationsFound++;

+ }

+ }

+ }

+ catch (UnauthorizedAccessException)

+ {

+ Logger.Warning?.Print(LogClass.Application, $"Failed to get access to directory: \"{appDir}\"");

+ // Loops through applications list, creating a struct and then firing an event containing the struct for each application

+ foreach (string applicationPath in applications)

+ if (_cancellationToken.Token.IsCancellationRequested)

+ {

+ return;

+ }

+ long fileSize = new FileInfo(applicationPath).Length;

+ string titleName = "Unknown";

+ string titleId = "0000000000000000";

+ string developer = "Unknown";

+ string version = "0";

+ byte[] applicationIcon = null;

+ BlitStruct<ApplicationControlProperty> controlHolder = new(1);

+ try

+ {

+ string extension = Path.GetExtension(applicationPath).ToLower();

+ using FileStream file = new(applicationPath, FileMode.Open, FileAccess.Read);

+ if (extension == ".nsp" || extension == ".pfs0" || extension == ".xci")

+ {

+ try

+ {

+ IFileSystem pfs;

+ bool isExeFs = false;

+ if (extension == ".xci")

+ {

+ Xci xci = new(_virtualFileSystem.KeySet, file.AsStorage());

+ pfs = xci.OpenPartition(XciPartitionType.Secure);

+ }

+ else

+ {

+ var pfsTemp = new PartitionFileSystem();

+ pfsTemp.Initialize(file.AsStorage()).ThrowIfFailure();

+ pfs = pfsTemp;

+ // If the NSP doesn't have a main NCA, decrement the number of applications found and then continue to the next application.

+ bool hasMainNca = false;

+ foreach (DirectoryEntryEx fileEntry in pfs.EnumerateEntries("/", "*"))

+ {

+ if (Path.GetExtension(fileEntry.FullPath).ToLower() == ".nca")

+ {

+ using UniqueRef<IFile> ncaFile = new();

+ pfs.OpenFile(ref ncaFile.Ref, fileEntry.FullPath.ToU8Span(), OpenMode.Read).ThrowIfFailure();

+ Nca nca = new(_virtualFileSystem.KeySet, ncaFile.Get.AsStorage());

+ int dataIndex = Nca.GetSectionIndexFromType(NcaSectionType.Data, NcaContentType.Program);

+ // Some main NCAs don't have a data partition, so check if the partition exists before opening it

+ if (nca.Header.ContentType == NcaContentType.Program && !(nca.SectionExists(NcaSectionType.Data) && nca.Header.GetFsHeader(dataIndex).IsPatchSection()))

+ {

+ hasMainNca = true;

+ break;

+ }

+ }

+ else if (Path.GetFileNameWithoutExtension(fileEntry.FullPath) == "main")

+ {

+ isExeFs = true;

+ }

+ }

+ if (!hasMainNca && !isExeFs)

+ {

+ numApplicationsFound--;

+ continue;

+ }

+ }

+ if (isExeFs)

+ {

+ applicationIcon = _nspIcon;

+ using UniqueRef<IFile> npdmFile = new();

+ Result result = pfs.OpenFile(ref npdmFile.Ref, "/main.npdm".ToU8Span(), OpenMode.Read);

+ if (ResultFs.PathNotFound.Includes(result))

+ {

+ Npdm npdm = new(npdmFile.Get.AsStream());

+ titleName = npdm.TitleName;

+ titleId = npdm.Aci0.TitleId.ToString("x16");

+ }

+ }

+ else

+ {

+ GetControlFsAndTitleId(pfs, out IFileSystem controlFs, out titleId);

+ // Check if there is an update available.

+ if (IsUpdateApplied(titleId, out IFileSystem updatedControlFs))

+ {

+ // Replace the original ControlFs by the updated one.

+ controlFs = updatedControlFs;

+ }

+ ReadControlData(controlFs, controlHolder.ByteSpan);

+ GetGameInformation(ref controlHolder.Value, out titleName, out _, out developer, out version);

+ // Read the icon from the ControlFS and store it as a byte array

+ try

+ {

+ using UniqueRef<IFile> icon = new();

+ controlFs.OpenFile(ref icon.Ref, $"/icon_{_desiredTitleLanguage}.dat".ToU8Span(), OpenMode.Read).ThrowIfFailure();

+ using MemoryStream stream = new();

+ icon.Get.AsStream().CopyTo(stream);

+ applicationIcon = stream.ToArray();

+ }

+ catch (HorizonResultException)

+ {

+ foreach (DirectoryEntryEx entry in controlFs.EnumerateEntries("/", "*"))

+ {

+ if (entry.Name == "control.nacp")

+ {

+ continue;

+ }

+ using var icon = new UniqueRef<IFile>();

+ controlFs.OpenFile(ref icon.Ref, entry.FullPath.ToU8Span(), OpenMode.Read).ThrowIfFailure();

+ using MemoryStream stream = new();

+ icon.Get.AsStream().CopyTo(stream);

+ applicationIcon = stream.ToArray();

+ if (applicationIcon != null)

+ {

+ break;

+ }

+ }

+ applicationIcon ??= extension == ".xci" ? _xciIcon : _nspIcon;

+ }

+ }

+ }

+ catch (MissingKeyException exception)

+ applicationIcon = extension == ".xci" ? _xciIcon : _nspIcon;

+

+ Logger.Warning?.Print(LogClass.Application, $"Your key set is missing a key with the name: {exception.Name}");

+ catch (InvalidDataException)

+ {

+ applicationIcon = extension == ".xci" ? _xciIcon : _nspIcon;

+ Logger.Warning?.Print(LogClass.Application, $"The header key is incorrect or missing and therefore the NCA header content type check has failed. Errored File: {applicationPath}");

+ }

+ catch (Exception exception)

+ {

+ Logger.Warning?.Print(LogClass.Application, $"The file encountered was not of a valid type. File: '{applicationPath}' Error: {exception}");

+ numApplicationsFound--;

+ continue;

+ }

+ else if (extension == ".nro")

+ applicationIcon = Read(assetOffset + iconOffset, (int)iconSize);

+ applicationIcon = _nroIcon;

+ GetGameInformation(ref controlHolder.Value, out titleName, out titleId, out developer, out version);

+ applicationIcon = _nroIcon;

+ titleName = Path.GetFileNameWithoutExtension(applicationPath);

+ numApplicationsFound--;

+ continue;

+ }

+ else if (extension == ".nca")

+ int dataIndex = Nca.GetSectionIndexFromType(NcaSectionType.Data, NcaContentType.Program);

+ if (nca.Header.ContentType != NcaContentType.Program || (nca.SectionExists(NcaSectionType.Data) && nca.Header.GetFsHeader(dataIndex).IsPatchSection()))

+ numApplicationsFound--;

+ continue;

+ }

+ numApplicationsFound--;

+

+ continue;

+ applicationIcon = _ncaIcon;

+ titleName = Path.GetFileNameWithoutExtension(applicationPath);

+ // If its an NSO we just set defaults

+ else if (extension == ".nso")

+ applicationIcon = _nsoIcon;

+ titleName = Path.GetFileNameWithoutExtension(applicationPath);

+ catch (IOException exception)

+ Logger.Warning?.Print(LogClass.Application, exception.Message);

+ numApplicationsFound--;

+ ApplicationMetadata appMetadata = LoadAndSaveMetaData(titleId, appMetadata =>

+ appMetadata.Title = titleName;

+ // Only do the migration if time_played has a value and timespan_played hasn't been updated yet.

+ if (appMetadata.TimePlayedOld != default && appMetadata.TimePlayed == TimeSpan.Zero)

+ appMetadata.TimePlayed = TimeSpan.FromSeconds(appMetadata.TimePlayedOld);

+ appMetadata.TimePlayedOld = default;

+ // Only do the migration if last_played has a value and last_played_utc doesn't exist yet.

+ if (appMetadata.LastPlayedOld != default && !appMetadata.LastPlayed.HasValue)

+ // Migrate from string-based last_played to DateTime-based last_played_utc.

+ if (DateTime.TryParse(appMetadata.LastPlayedOld, out DateTime lastPlayedOldParsed))

+ appMetadata.LastPlayed = lastPlayedOldParsed;

+

+ // Migration successful: deleting last_played from the metadata file.

+ appMetadata.LastPlayedOld = default;

+ }

+ });

+ ApplicationData data = new()

+ Favorite = appMetadata.Favorite,

+ Icon = applicationIcon,

+ TitleName = titleName,

+ TitleId = titleId,

+ Developer = developer,

+ Version = version,

+ TimePlayed = appMetadata.TimePlayed,

+ LastPlayed = appMetadata.LastPlayed,

+ FileExtension = Path.GetExtension(applicationPath).TrimStart('.').ToUpper(),

+ FileSize = fileSize,

+ Path = applicationPath,

+ ControlHolder = controlHolder,

+ };

+

+ numApplicationsLoaded++;

+

+ OnApplicationAdded(new ApplicationAddedEventArgs

+ {

+ AppData = data,

+ });

+ private void GetControlFsAndTitleId(IFileSystem pfs, out IFileSystem controlFs, out string titleId)

+ {

+ (_, _, Nca controlNca) = GetGameData(_virtualFileSystem, pfs, 0);

+

+ // Return the ControlFS

+ controlFs = controlNca?.OpenFileSystem(NcaSectionType.Data, IntegrityCheckLevel.None);

+ titleId = controlNca?.Header.TitleId.ToString("x16");

+ }

+

+ public byte[] GetApplicationIcon(string applicationPath, Language desiredTitleLanguage)

+ GetControlFsAndTitleId(pfs, out IFileSystem controlFs, out _);

+ using (MemoryStream stream = new())

+ {

+ icon.Get.AsStream().CopyTo(stream);

+ applicationIcon = stream.ToArray();

+ }

+ if (applicationIcon != null)

+ {

+ break;

+ }

+ private void GetGameInformation(ref ApplicationControlProperty controlData, out string titleName, out string titleId, out string publisher, out string version)

+ titleName = controlData.Title[(int)desiredTitleLanguage].NameString.ToString();

+ publisher = controlData.Title[(int)desiredTitleLanguage].PublisherString.ToString();

+ titleName = null;

+ publisher = null;

+ if (string.IsNullOrWhiteSpace(titleName))

+ titleName = controlTitle.NameString.ToString();

+ if (string.IsNullOrWhiteSpace(publisher))

+ publisher = controlTitle.PublisherString.ToString();

+ titleId = controlData.PresenceGroupId.ToString("x16");

+ titleId = controlData.SaveDataOwnerId.ToString();

+ titleId = (controlData.AddOnContentBaseId - 0x1000).ToString("x16");

+ }

+ else

+ {

+ titleId = "0000000000000000";

+ version = controlData.DisplayVersionString.ToString();

+ private bool IsUpdateApplied(string titleId, out IFileSystem updatedControlFs)

+ (Nca patchNca, Nca controlNca) = GetGameUpdateData(_virtualFileSystem, titleId, 0, out updatePath);

+ updatedControlFs = controlNca?.OpenFileSystem(NcaSectionType.Data, IntegrityCheckLevel.None);

+

+ public static (Nca main, Nca patch, Nca control) GetGameData(VirtualFileSystem fileSystem, IFileSystem pfs, int programIndex)

+ {

+ Nca mainNca = null;

+ Nca patchNca = null;

+ Nca controlNca = null;

+

+ fileSystem.ImportTickets(pfs);

+

+ foreach (DirectoryEntryEx fileEntry in pfs.EnumerateEntries("/", "*.nca"))

+ {

+ using var ncaFile = new UniqueRef<IFile>();

+

+ pfs.OpenFile(ref ncaFile.Ref, fileEntry.FullPath.ToU8Span(), OpenMode.Read).ThrowIfFailure();

+

+ Nca nca = new(fileSystem.KeySet, ncaFile.Release().AsStorage());

+

+ int ncaProgramIndex = (int)(nca.Header.TitleId & 0xF);

+

+ if (ncaProgramIndex != programIndex)

+ {

+ continue;

+ }

+

+ if (nca.Header.ContentType == NcaContentType.Program)

+ {

+ int dataIndex = Nca.GetSectionIndexFromType(NcaSectionType.Data, NcaContentType.Program);

+

+ if (nca.SectionExists(NcaSectionType.Data) && nca.Header.GetFsHeader(dataIndex).IsPatchSection())

+ {

+ patchNca = nca;

+ }

+ else

+ {

+ mainNca = nca;

+ }

+ }

+ else if (nca.Header.ContentType == NcaContentType.Control)

+ {

+ controlNca = nca;

+ }

+ }

+

+ return (mainNca, patchNca, controlNca);

+ }

+

+ public static (Nca patch, Nca control) GetGameUpdateDataFromPartition(VirtualFileSystem fileSystem, PartitionFileSystem pfs, string titleId, int programIndex)

+ {

+ Nca patchNca = null;

+ Nca controlNca = null;

+

+ fileSystem.ImportTickets(pfs);

+

+ foreach (DirectoryEntryEx fileEntry in pfs.EnumerateEntries("/", "*.nca"))

+ {

+ using var ncaFile = new UniqueRef<IFile>();

+

+ pfs.OpenFile(ref ncaFile.Ref, fileEntry.FullPath.ToU8Span(), OpenMode.Read).ThrowIfFailure();

+

+ Nca nca = new(fileSystem.KeySet, ncaFile.Release().AsStorage());

+

+ int ncaProgramIndex = (int)(nca.Header.TitleId & 0xF);

+

+ if (ncaProgramIndex != programIndex)

+ {

+ continue;

+ }

+

+ if ($"{nca.Header.TitleId.ToString("x16")[..^3]}000" != titleId)

+ {

+ break;

+ }

+

+ if (nca.Header.ContentType == NcaContentType.Program)

+ {

+ patchNca = nca;

+ }

+ else if (nca.Header.ContentType == NcaContentType.Control)

+ {

+ controlNca = nca;

+ }

+ }

+

+ return (patchNca, controlNca);

+ }

+

+ public static (Nca patch, Nca control) GetGameUpdateData(VirtualFileSystem fileSystem, string titleId, int programIndex, out string updatePath)

+ {

+ updatePath = null;

+

+ if (ulong.TryParse(titleId, NumberStyles.HexNumber, CultureInfo.InvariantCulture, out ulong titleIdBase))

+ {

+ // Clear the program index part.

+ titleIdBase &= ~0xFUL;

+

+ // Load update information if exists.

+ string titleUpdateMetadataPath = Path.Combine(AppDataManager.GamesDirPath, titleIdBase.ToString("x16"), "updates.json");

+

+ if (File.Exists(titleUpdateMetadataPath))

+ {

+ updatePath = JsonHelper.DeserializeFromFile(titleUpdateMetadataPath, _titleSerializerContext.TitleUpdateMetadata).Selected;

+

+ if (File.Exists(updatePath))

+ {

+ FileStream file = new(updatePath, FileMode.Open, FileAccess.Read);

+ PartitionFileSystem nsp = new();

+ nsp.Initialize(file.AsStorage()).ThrowIfFailure();

+

+ return GetGameUpdateDataFromPartition(fileSystem, nsp, titleIdBase.ToString("x16"), programIndex);

+ }

+ }

+ }

+

+ return (null, null);

+ }

+ mainWindow.RunApplication(CommandLineState.LaunchPathArg, CommandLineState.StartFullscreenArg);

+ private string _currentEmulatedGamePath = null;

+ _applicationLibrary = new ApplicationLibrary(_virtualFileSystem);

+ private bool LoadApplication(string path, bool isFirmwareTitle)

+ return _emulationContext.LoadXci(path);

+ return _emulationContext.LoadNsp(path);

+ public void RunApplication(string path, bool startFullscreen = false)

+ if (path.StartsWith("@SystemContent"))

+ path = VirtualFileSystem.SwitchPathToSystemPath(path);

+ if (!LoadApplication(path, isFirmwareTitle))

+ _currentEmulatedGamePath = path;

+ $"{args.AppData.TitleName}\n{args.AppData.TitleId.ToUpper()}",

+ string path = (string)_tableStore.GetValue(treeIter, 9);

+ RunApplication(path);

+ string titleFilePath = _tableStore.GetValue(treeIter, 9).ToString();

+ string titleName = _tableStore.GetValue(treeIter, 2).ToString().Split("\n")[0];

+ string titleId = _tableStore.GetValue(treeIter, 2).ToString().Split("\n")[1].ToLower();

+

+ BlitStruct<ApplicationControlProperty> controlData = (BlitStruct<ApplicationControlProperty>)_tableStore.GetValue(treeIter, 10);

+ _ = new GameTableContextMenu(this, _virtualFileSystem, _accountManager, _libHacHorizonManager.RyujinxClient, titleFilePath, titleName, titleId, controlData);

+ RunApplication(fileChooser.Filename);

+ RunApplication(fileChooser.Filename);

+ RunApplication(contentPath);

+ RunApplication(_currentEmulatedGamePath);

+ _currentEmulatedGamePath = null;

+ _currentEmulatedGamePath);

+using System.Globalization;

+ private readonly BlitStruct<ApplicationControlProperty> _controlData;

+ private readonly string _titleFilePath;

+ private readonly string _titleName;

+ private readonly string _titleIdText;

+ private readonly ulong _titleId;

+ public GameTableContextMenu(MainWindow parent, VirtualFileSystem virtualFileSystem, AccountManager accountManager, HorizonClient horizonClient, string titleFilePath, string titleName, string titleId, BlitStruct<ApplicationControlProperty> controlData)

+ _titleFilePath = titleFilePath;

+ _titleName = titleName;

+ _titleIdText = titleId;

+ _controlData = controlData;

+ if (!ulong.TryParse(_titleIdText, NumberStyles.HexNumber, CultureInfo.InvariantCulture, out _titleId))

+ {

+ GtkDialog.CreateErrorDialog("The selected game did not have a valid Title Id");

+

+ return;

+ }

+

+ _openSaveUserDirMenuItem.Sensitive = !Utilities.IsZeros(controlData.ByteSpan) && controlData.Value.UserAccountSaveDataSize > 0;

+ _openSaveDeviceDirMenuItem.Sensitive = !Utilities.IsZeros(controlData.ByteSpan) && controlData.Value.DeviceSaveDataSize > 0;

+ _openSaveBcatDirMenuItem.Sensitive = !Utilities.IsZeros(controlData.ByteSpan) && controlData.Value.BcatDeliveryCacheStorageSize > 0;

+ string fileExt = System.IO.Path.GetExtension(_titleFilePath).ToLower();

+ if (!TryFindSaveData(_titleName, _titleId, _controlData, in saveDataFilter, out ulong saveDataId))

+ SecondaryText = $"Extracting {ncaSectionType} section from {System.IO.Path.GetFileName(_titleFilePath)}...",

+ using FileStream file = new(_titleFilePath, FileMode.Open, FileAccess.Read);

+ if ((System.IO.Path.GetExtension(_titleFilePath).ToLower() == ".nsp") ||

+ (System.IO.Path.GetExtension(_titleFilePath).ToLower() == ".pfs0") ||

+ (System.IO.Path.GetExtension(_titleFilePath).ToLower() == ".xci"))

+ if (System.IO.Path.GetExtension(_titleFilePath) == ".xci")

+ else if (System.IO.Path.GetExtension(_titleFilePath).ToLower() == ".nca")

+ (Nca updatePatchNca, _) = ApplicationLibrary.GetGameUpdateData(_virtualFileSystem, mainNca.Header.TitleId.ToString("x16"), programIndex, out _);

+ var saveDataFilter = SaveDataFilter.Make(_titleId, saveType: default, userId, saveDataId: default, index: default);

+ var saveDataFilter = SaveDataFilter.Make(_titleId, SaveDataType.Device, userId: default, saveDataId: default, index: default);

+ var saveDataFilter = SaveDataFilter.Make(_titleId, SaveDataType.Bcat, userId: default, saveDataId: default, index: default);

+ new TitleUpdateWindow(_parent, _virtualFileSystem, _titleIdText, _titleName).Show();

+ new DlcWindow(_virtualFileSystem, _titleIdText, _titleName).Show();

+ new CheatWindow(_virtualFileSystem, _titleId, _titleName, _titleFilePath).Show();

+ string titleModsPath = ModLoader.GetTitleDir(modsBasePath, _titleIdText);

+ string titleModsPath = ModLoader.GetTitleDir(sdModsBasePath, _titleIdText);

+ string ptcDir = System.IO.Path.Combine(AppDataManager.GamesDirPath, _titleIdText, "cache", "cpu");

+ string shaderCacheDir = System.IO.Path.Combine(AppDataManager.GamesDirPath, _titleIdText, "cache", "shader");

+ DirectoryInfo mainDir = new(System.IO.Path.Combine(AppDataManager.GamesDirPath, _titleIdText, "cache", "cpu", "0"));

+ DirectoryInfo backupDir = new(System.IO.Path.Combine(AppDataManager.GamesDirPath, _titleIdText, "cache", "cpu", "1"));

+ MessageDialog warningDialog = GtkDialog.CreateConfirmationDialog("Warning", $"You are about to queue a PPTC rebuild on the next boot of:\n\n<b>{_titleName}</b>\n\nAre you sure you want to proceed?");

+ DirectoryInfo shaderCacheDir = new(System.IO.Path.Combine(AppDataManager.GamesDirPath, _titleIdText, "cache", "shader"));

+ using MessageDialog warningDialog = GtkDialog.CreateConfirmationDialog("Warning", $"You are about to delete the shader cache for :\n\n<b>{_titleName}</b>\n\nAre you sure you want to proceed?");

+ byte[] appIcon = new ApplicationLibrary(_virtualFileSystem).GetApplicationIcon(_titleFilePath, ConfigurationState.Instance.System.Language);

+ ShortcutHelper.CreateAppShortcut(_titleFilePath, _titleName, _titleIdText, appIcon);

+ _buildIdTextView.Buffer.Text = $"BuildId: {ApplicationData.GetApplicationBuildId(virtualFileSystem, titlePath)}";

+ private readonly string _titleId;

+ public DlcWindow(VirtualFileSystem virtualFileSystem, string titleId, string titleName) : this(new Builder("Ryujinx.Ui.Windows.DlcWindow.glade"), virtualFileSystem, titleId, titleName) { }

+ private DlcWindow(Builder builder, VirtualFileSystem virtualFileSystem, string titleId, string titleName) : base(builder.GetRawOwnedObject("_dlcWindow"))

+ _titleId = titleId;

+ _dlcJsonPath = System.IO.Path.Combine(AppDataManager.GamesDirPath, _titleId, "dlc.json");

+ _baseTitleInfoLabel.Text = $"DLC Available for {titleName} [{titleId.ToUpper()}]";

+ _dlcTreeView.AppendColumn("TitleId", new CellRendererText(), "text", 1);

+ pfs.Initialize(containerFile.AsStorage()).ThrowIfFailure();

+ if (!File.Exists(containerPath))

+ {

+ return;

+ }

+

+ using FileStream containerFile = File.OpenRead(containerPath);

+

+ PartitionFileSystem pfs = new();

+ pfs.Initialize(containerFile.AsStorage()).ThrowIfFailure();

+ bool containsDlc = false;

+

+ _virtualFileSystem.ImportTickets(pfs);

+

+ TreeIter? parentIter = null;

+

+ foreach (DirectoryEntryEx fileEntry in pfs.EnumerateEntries("/", "*.nca"))

+ {

+ using var ncaFile = new UniqueRef<IFile>();

+

+ pfs.OpenFile(ref ncaFile.Ref, fileEntry.FullPath.ToU8Span(), OpenMode.Read).ThrowIfFailure();

+

+ Nca nca = TryCreateNca(ncaFile.Get.AsStorage(), containerPath);

+

+ if (nca == null)

+ {

+ continue;

+ }

+

+ if (nca.Header.ContentType == NcaContentType.PublicData)

+ {

+ if ((nca.Header.TitleId & 0xFFFFFFFFFFFFE000).ToString("x16") != _titleId)

+ {

+ break;

+ }

+

+ parentIter ??= ((TreeStore)_dlcTreeView.Model).AppendValues(true, "", containerPath);

+

+ ((TreeStore)_dlcTreeView.Model).AppendValues(parentIter.Value, true, nca.Header.TitleId.ToString("X16"), fileEntry.FullPath);

+ containsDlc = true;

+ }

+ }

+

+ if (!containsDlc)

+ {

+ GtkDialog.CreateErrorDialog("The specified file does not contain DLC for the selected title!");

+ }

+ private readonly string _titleId;

+ public TitleUpdateWindow(MainWindow parent, VirtualFileSystem virtualFileSystem, string titleId, string titleName) : this(new Builder("Ryujinx.Ui.Windows.TitleUpdateWindow.glade"), parent, virtualFileSystem, titleId, titleName) { }

+ private TitleUpdateWindow(Builder builder, MainWindow parent, VirtualFileSystem virtualFileSystem, string titleId, string titleName) : base(builder.GetRawOwnedObject("_titleUpdateWindow"))

+ _titleId = titleId;

+ _updateJsonPath = System.IO.Path.Combine(AppDataManager.GamesDirPath, _titleId, "updates.json");

+ _baseTitleInfoLabel.Text = $"Updates Available for {titleName} [{titleId.ToUpper()}]";

+ private void AddUpdate(string path)

+ PartitionFileSystem nsp = new();

+ nsp.Initialize(file.AsStorage()).ThrowIfFailure();

+ (Nca patchNca, Nca controlNca) = ApplicationLibrary.GetGameUpdateDataFromPartition(_virtualFileSystem, nsp, _titleId, 0);

+ RadioButton radioButton = new($"Version {controlData.DisplayVersionString.ToString()} - {path}");

+ GtkDialog.CreateErrorDialog("The specified file does not contain an update for the selected title!");