forked from MeloNX/MeloNX
838 lines
32 KiB
C#
838 lines
32 KiB
C#
// State class for the library
|
|
using Ryujinx.HLE.FileSystem;
|
|
using Ryujinx.HLE.HOS.Services.Account.Acc;
|
|
using Ryujinx.HLE.HOS;
|
|
using Ryujinx.Input.HLE;
|
|
using Ryujinx.HLE;
|
|
using System;
|
|
using System.Runtime.InteropServices;
|
|
using Ryujinx.Common.Configuration;
|
|
using LibHac.Tools.FsSystem;
|
|
using Ryujinx.Graphics.GAL.Multithreading;
|
|
using Ryujinx.Audio.Backends.Dummy;
|
|
using Ryujinx.HLE.HOS.SystemState;
|
|
using Ryujinx.Ui.Common.Configuration;
|
|
using Ryujinx.Common.Logging;
|
|
using Ryujinx.Audio.Integration;
|
|
using Ryujinx.Audio.Backends.SDL2;
|
|
using System.IO;
|
|
using LibHac.Common.Keys;
|
|
using LibHac.Common;
|
|
using LibHac.Ns;
|
|
using LibHac.Tools.Fs;
|
|
using LibHac.Tools.FsSystem.NcaUtils;
|
|
using LibHac.Fs.Fsa;
|
|
using LibHac.FsSystem;
|
|
using LibHac.Fs;
|
|
using Path = System.IO.Path;
|
|
using LibHac;
|
|
using OpenTK.Audio.OpenAL;
|
|
using Ryujinx.Common.Configuration.Multiplayer;
|
|
using Ryujinx.HLE.Loaders.Npdm;
|
|
using Ryujinx.Common.Utilities;
|
|
using System.Globalization;
|
|
using Ryujinx.Ui.Common.Configuration.System;
|
|
using Ryujinx.Common.Logging.Targets;
|
|
using System.Collections.Generic;
|
|
using LibHac.Bcat;
|
|
using Ryujinx.Ui.App.Common;
|
|
using System.Text;
|
|
using Ryujinx.HLE.Ui;
|
|
using LibRyujinx.Android;
|
|
|
|
namespace LibRyujinx
|
|
{
|
|
public static partial class LibRyujinx
|
|
{
|
|
internal static IHardwareDeviceDriver AudioDriver { get; set; } = new DummyHardwareDeviceDriver();
|
|
|
|
private static readonly TitleUpdateMetadataJsonSerializerContext _titleSerializerContext = new(JsonHelper.GetDefaultSerializerOptions());
|
|
public static SwitchDevice? SwitchDevice { get; set; }
|
|
|
|
[UnmanagedCallersOnly(EntryPoint = "initialize")]
|
|
public static bool Initialize(IntPtr basePathPtr)
|
|
{
|
|
var path = Marshal.PtrToStringAnsi(basePathPtr);
|
|
|
|
var res = Initialize(path);
|
|
|
|
InitializeAudio();
|
|
|
|
return res;
|
|
}
|
|
|
|
public static bool Initialize(string? basePath)
|
|
{
|
|
if (SwitchDevice != null)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
try
|
|
{
|
|
AppDataManager.Initialize(basePath);
|
|
|
|
ConfigurationState.Initialize();
|
|
LoggerModule.Initialize();
|
|
|
|
Logger.AddTarget(new AsyncLogTargetWrapper(
|
|
new FileLogTarget(AppDataManager.BaseDirPath, "file"),
|
|
1000,
|
|
AsyncLogTargetOverflowAction.Block
|
|
));
|
|
|
|
Logger.Notice.Print(LogClass.Application, "Initializing...");
|
|
Logger.Notice.Print(LogClass.Application, $"Using base path: {AppDataManager.BaseDirPath}");
|
|
|
|
SwitchDevice = new SwitchDevice();
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Console.WriteLine(ex);
|
|
return false;
|
|
}
|
|
|
|
OpenALLibraryNameContainer.OverridePath = "libopenal.so";
|
|
|
|
Logger.Notice.Print(LogClass.Application, "RyujinxAndroid is ready!");
|
|
|
|
return true;
|
|
}
|
|
|
|
public static void InitializeAudio()
|
|
{
|
|
AudioDriver = new SDL2HardwareDeviceDriver();
|
|
}
|
|
|
|
public static GameStats GetGameStats()
|
|
{
|
|
if (SwitchDevice?.EmulationContext == null)
|
|
return new GameStats();
|
|
|
|
var context = SwitchDevice.EmulationContext;
|
|
|
|
return new GameStats
|
|
{
|
|
Fifo = context.Statistics.GetFifoPercent(),
|
|
GameFps = context.Statistics.GetGameFrameRate(),
|
|
GameTime = context.Statistics.GetGameFrameTime()
|
|
};
|
|
}
|
|
|
|
|
|
public static GameInfo? GetGameInfo(string? file)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(file))
|
|
{
|
|
return new GameInfo();
|
|
}
|
|
|
|
Logger.Info?.Print(LogClass.Application, $"Getting game info for file: {file}");
|
|
|
|
using var stream = File.Open(file, FileMode.Open);
|
|
|
|
return GetGameInfo(stream, new FileInfo(file).Extension.Remove('.'));
|
|
}
|
|
|
|
public static GameInfo? GetGameInfo(Stream gameStream, string extension)
|
|
{
|
|
if (SwitchDevice == null)
|
|
{
|
|
Logger.Error?.Print(LogClass.Application, "SwitchDevice is not initialized.");
|
|
return null;
|
|
}
|
|
|
|
var gameInfo = new GameInfo
|
|
{
|
|
FileSize = gameStream.Length * 0.000000000931,
|
|
TitleName = "Unknown",
|
|
TitleId = "0000000000000000",
|
|
Developer = "Unknown",
|
|
Version = "0",
|
|
Icon = null
|
|
};
|
|
|
|
const Language TitleLanguage = Language.AmericanEnglish;
|
|
|
|
BlitStruct<ApplicationControlProperty> controlHolder = new(1);
|
|
|
|
try
|
|
{
|
|
try
|
|
{
|
|
if (extension == "nsp" || extension == "pfs0" || extension == "xci")
|
|
{
|
|
IFileSystem pfs;
|
|
|
|
bool isExeFs = false;
|
|
|
|
if (extension == "xci")
|
|
{
|
|
Xci xci = new(SwitchDevice.VirtualFileSystem.KeySet, gameStream.AsStorage());
|
|
|
|
pfs = xci.OpenPartition(XciPartitionType.Secure);
|
|
}
|
|
else
|
|
{
|
|
var pfsTemp = new PartitionFileSystem();
|
|
pfsTemp.Initialize(gameStream.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(SwitchDevice.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)
|
|
{
|
|
return null;
|
|
}
|
|
}
|
|
|
|
if (isExeFs)
|
|
{
|
|
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());
|
|
|
|
gameInfo.TitleName = npdm.TitleName;
|
|
gameInfo.TitleId = npdm.Aci0.TitleId.ToString("x16");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
GetControlFsAndTitleId(pfs, out IFileSystem? controlFs, out string? id);
|
|
|
|
gameInfo.TitleId = id;
|
|
|
|
if (controlFs == null)
|
|
{
|
|
Logger.Error?.Print(LogClass.Application, $"No control FS was returned. Unable to process game any further: {gameInfo.TitleName}");
|
|
return null;
|
|
}
|
|
|
|
// Check if there is an update available.
|
|
if (IsUpdateApplied(gameInfo.TitleId, out IFileSystem? updatedControlFs))
|
|
{
|
|
// Replace the original ControlFs by the updated one.
|
|
controlFs = updatedControlFs;
|
|
}
|
|
|
|
ReadControlData(controlFs, controlHolder.ByteSpan);
|
|
|
|
GetGameInformation(ref controlHolder.Value, out gameInfo.TitleName, out _, out gameInfo.Developer, out gameInfo.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_{TitleLanguage}.dat".ToU8Span(), OpenMode.Read).ThrowIfFailure();
|
|
|
|
using MemoryStream stream = new();
|
|
|
|
icon.Get.AsStream().CopyTo(stream);
|
|
gameInfo.Icon = 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);
|
|
gameInfo.Icon = stream.ToArray();
|
|
|
|
if (gameInfo.Icon != null)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
else if (extension == "nro")
|
|
{
|
|
BinaryReader reader = new(gameStream);
|
|
|
|
byte[] Read(long position, int size)
|
|
{
|
|
gameStream.Seek(position, SeekOrigin.Begin);
|
|
|
|
return reader.ReadBytes(size);
|
|
}
|
|
|
|
gameStream.Seek(24, SeekOrigin.Begin);
|
|
|
|
int assetOffset = reader.ReadInt32();
|
|
|
|
if (Encoding.ASCII.GetString(Read(assetOffset, 4)) == "ASET")
|
|
{
|
|
byte[] iconSectionInfo = Read(assetOffset + 8, 0x10);
|
|
|
|
long iconOffset = BitConverter.ToInt64(iconSectionInfo, 0);
|
|
long iconSize = BitConverter.ToInt64(iconSectionInfo, 8);
|
|
|
|
ulong nacpOffset = reader.ReadUInt64();
|
|
ulong nacpSize = reader.ReadUInt64();
|
|
|
|
// Reads and stores game icon as byte array
|
|
if (iconSize > 0)
|
|
{
|
|
gameInfo.Icon = Read(assetOffset + iconOffset, (int)iconSize);
|
|
}
|
|
|
|
// Read the NACP data
|
|
Read(assetOffset + (int)nacpOffset, (int)nacpSize).AsSpan().CopyTo(controlHolder.ByteSpan);
|
|
|
|
GetGameInformation(ref controlHolder.Value, out gameInfo.TitleName, out _, out gameInfo.Developer, out gameInfo.Version);
|
|
}
|
|
}
|
|
}
|
|
catch (MissingKeyException exception)
|
|
{
|
|
Logger.Warning?.Print(LogClass.Application, $"Your key set is missing a key with the name: {exception.Name}");
|
|
}
|
|
catch (InvalidDataException exception)
|
|
{
|
|
Logger.Warning?.Print(LogClass.Application, $"The header key is incorrect or missing and therefore the NCA header content type check has failed. {exception}");
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
Logger.Warning?.Print(LogClass.Application, $"The gameStream encountered was not of a valid type. Error: {exception}");
|
|
|
|
return null;
|
|
}
|
|
}
|
|
catch (IOException exception)
|
|
{
|
|
Logger.Warning?.Print(LogClass.Application, exception.Message);
|
|
}
|
|
|
|
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();
|
|
}
|
|
|
|
void GetGameInformation(ref ApplicationControlProperty controlData, out string? titleName, out string titleId, out string? publisher, out string? version)
|
|
{
|
|
_ = Enum.TryParse(TitleLanguage.ToString(), out TitleLanguage desiredTitleLanguage);
|
|
|
|
if (controlData.Title.ItemsRo.Length > (int)desiredTitleLanguage)
|
|
{
|
|
titleName = controlData.Title[(int)desiredTitleLanguage].NameString.ToString();
|
|
publisher = controlData.Title[(int)desiredTitleLanguage].PublisherString.ToString();
|
|
}
|
|
else
|
|
{
|
|
titleName = null;
|
|
publisher = null;
|
|
}
|
|
|
|
if (string.IsNullOrWhiteSpace(titleName))
|
|
{
|
|
foreach (ref readonly var controlTitle in controlData.Title.ItemsRo)
|
|
{
|
|
if (!controlTitle.NameString.IsEmpty())
|
|
{
|
|
titleName = controlTitle.NameString.ToString();
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (string.IsNullOrWhiteSpace(publisher))
|
|
{
|
|
foreach (ref readonly var controlTitle in controlData.Title.ItemsRo)
|
|
{
|
|
if (!controlTitle.PublisherString.IsEmpty())
|
|
{
|
|
publisher = controlTitle.PublisherString.ToString();
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (controlData.PresenceGroupId != 0)
|
|
{
|
|
titleId = controlData.PresenceGroupId.ToString("x16");
|
|
}
|
|
else if (controlData.SaveDataOwnerId != 0)
|
|
{
|
|
titleId = controlData.SaveDataOwnerId.ToString();
|
|
}
|
|
else if (controlData.AddOnContentBaseId != 0)
|
|
{
|
|
titleId = (controlData.AddOnContentBaseId - 0x1000).ToString("x16");
|
|
}
|
|
else
|
|
{
|
|
titleId = "0000000000000000";
|
|
}
|
|
|
|
version = controlData.DisplayVersionString.ToString();
|
|
}
|
|
|
|
void GetControlFsAndTitleId(IFileSystem pfs, out IFileSystem? controlFs, out string? titleId)
|
|
{
|
|
if (SwitchDevice == null)
|
|
{
|
|
Logger.Error?.Print(LogClass.Application, "SwitchDevice is not initialized.");
|
|
|
|
controlFs = null;
|
|
titleId = null;
|
|
return;
|
|
}
|
|
(_, _, Nca? controlNca) = GetGameData(SwitchDevice.VirtualFileSystem, pfs, 0);
|
|
|
|
if (controlNca == null)
|
|
{
|
|
Logger.Warning?.Print(LogClass.Application, "Control NCA is null. Unable to load control FS.");
|
|
}
|
|
|
|
// Return the ControlFS
|
|
controlFs = controlNca?.OpenFileSystem(NcaSectionType.Data, IntegrityCheckLevel.None);
|
|
titleId = controlNca?.Header.TitleId.ToString("x16");
|
|
}
|
|
|
|
(Nca? mainNca, Nca? patchNca, Nca? controlNca) 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>();
|
|
|
|
Logger.Info?.Print(LogClass.Application, $"Loading file from PFS: {fileEntry.FullPath}");
|
|
|
|
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);
|
|
}
|
|
|
|
bool IsUpdateApplied(string? titleId, out IFileSystem? updatedControlFs)
|
|
{
|
|
updatedControlFs = null;
|
|
|
|
string? updatePath = "(unknown)";
|
|
|
|
if (SwitchDevice?.VirtualFileSystem == null)
|
|
{
|
|
Logger.Error?.Print(LogClass.Application, "SwitchDevice was not initialized.");
|
|
return false;
|
|
}
|
|
|
|
try
|
|
{
|
|
(Nca? patchNca, Nca? controlNca) = GetGameUpdateData(SwitchDevice.VirtualFileSystem, titleId, 0, out updatePath);
|
|
|
|
if (patchNca != null && controlNca != null)
|
|
{
|
|
updatedControlFs = controlNca.OpenFileSystem(NcaSectionType.Data, IntegrityCheckLevel.None);
|
|
|
|
return true;
|
|
}
|
|
}
|
|
catch (InvalidDataException)
|
|
{
|
|
Logger.Warning?.Print(LogClass.Application, $"The header key is incorrect or missing and therefore the NCA header content type check has failed. Errored File: {updatePath}");
|
|
}
|
|
catch (MissingKeyException exception)
|
|
{
|
|
Logger.Warning?.Print(LogClass.Application, $"Your key set is missing a key with the name: {exception.Name}. Errored File: {updatePath}");
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
(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);
|
|
}
|
|
|
|
(Nca? patchNca, Nca? controlNca) 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);
|
|
}
|
|
|
|
return gameInfo;
|
|
}
|
|
|
|
public static string GetDlcTitleId(string path, string ncaPath)
|
|
{
|
|
if (File.Exists(path))
|
|
{
|
|
using FileStream containerFile = File.OpenRead(path);
|
|
|
|
PartitionFileSystem partitionFileSystem = new();
|
|
partitionFileSystem.Initialize(containerFile.AsStorage()).ThrowIfFailure();
|
|
|
|
SwitchDevice.VirtualFileSystem.ImportTickets(partitionFileSystem);
|
|
|
|
using UniqueRef<IFile> ncaFile = new();
|
|
|
|
partitionFileSystem.OpenFile(ref ncaFile.Ref, ncaPath.ToU8Span(), OpenMode.Read).ThrowIfFailure();
|
|
|
|
Nca nca = TryOpenNca(ncaFile.Get.AsStorage(), ncaPath);
|
|
if (nca != null)
|
|
{
|
|
return nca.Header.TitleId.ToString("X16");
|
|
}
|
|
}
|
|
|
|
return string.Empty;
|
|
}
|
|
|
|
|
|
private static Nca TryOpenNca(IStorage ncaStorage, string containerPath)
|
|
{
|
|
try
|
|
{
|
|
return new Nca(SwitchDevice.VirtualFileSystem.KeySet, ncaStorage);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
public static List<string> GetDlcContentList(string path, ulong titleId)
|
|
{
|
|
if (!File.Exists(path))
|
|
return new List<string>();
|
|
|
|
using FileStream containerFile = File.OpenRead(path);
|
|
|
|
PartitionFileSystem partitionFileSystem = new();
|
|
partitionFileSystem.Initialize(containerFile.AsStorage()).ThrowIfFailure();
|
|
|
|
SwitchDevice.VirtualFileSystem.ImportTickets(partitionFileSystem);
|
|
List<string> paths = new List<string>();
|
|
|
|
foreach (DirectoryEntryEx fileEntry in partitionFileSystem.EnumerateEntries("/", "*.nca"))
|
|
{
|
|
using var ncaFile = new UniqueRef<IFile>();
|
|
|
|
partitionFileSystem.OpenFile(ref ncaFile.Ref, fileEntry.FullPath.ToU8Span(), OpenMode.Read).ThrowIfFailure();
|
|
|
|
Nca nca = TryOpenNca(ncaFile.Get.AsStorage(), path);
|
|
if (nca == null)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if (nca.Header.ContentType == NcaContentType.PublicData)
|
|
{
|
|
if ((nca.Header.TitleId & 0xFFFFFFFFFFFFE000) != titleId)
|
|
{
|
|
break;
|
|
}
|
|
|
|
paths.Add(fileEntry.FullPath);
|
|
}
|
|
}
|
|
|
|
return paths;
|
|
}
|
|
|
|
public static void SetupUiHandler()
|
|
{
|
|
if (SwitchDevice is { } switchDevice)
|
|
{
|
|
switchDevice.HostUiHandler = new AndroidUiHandler();
|
|
}
|
|
}
|
|
|
|
public static void WaitUiHandler()
|
|
{
|
|
if (SwitchDevice?.HostUiHandler is AndroidUiHandler uiHandler)
|
|
{
|
|
uiHandler.Wait();
|
|
}
|
|
}
|
|
|
|
public static void StopUiHandlerWait()
|
|
{
|
|
if (SwitchDevice?.HostUiHandler is AndroidUiHandler uiHandler)
|
|
{
|
|
uiHandler.Set();
|
|
}
|
|
}
|
|
|
|
public static void SetUiHandlerResponse(bool isOkPressed, long input)
|
|
{
|
|
if (SwitchDevice?.HostUiHandler is AndroidUiHandler uiHandler)
|
|
{
|
|
uiHandler.SetResponse(isOkPressed, input);
|
|
}
|
|
}
|
|
}
|
|
|
|
public class SwitchDevice : IDisposable
|
|
{
|
|
private readonly SystemVersion _firmwareVersion;
|
|
public VirtualFileSystem VirtualFileSystem { get; set; }
|
|
public ContentManager ContentManager { get; set; }
|
|
public AccountManager AccountManager { get; set; }
|
|
public LibHacHorizonManager LibHacHorizonManager { get; set; }
|
|
public UserChannelPersistence UserChannelPersistence { get; set; }
|
|
public InputManager? InputManager { get; set; }
|
|
public Switch? EmulationContext { get; set; }
|
|
public IHostUiHandler? HostUiHandler { get; set; }
|
|
|
|
public void Dispose()
|
|
{
|
|
GC.SuppressFinalize(this);
|
|
|
|
VirtualFileSystem.Dispose();
|
|
InputManager?.Dispose();
|
|
EmulationContext?.Dispose();
|
|
}
|
|
|
|
public SwitchDevice()
|
|
{
|
|
VirtualFileSystem = VirtualFileSystem.CreateInstance();
|
|
LibHacHorizonManager = new LibHacHorizonManager();
|
|
|
|
LibHacHorizonManager.InitializeFsServer(VirtualFileSystem);
|
|
LibHacHorizonManager.InitializeArpServer();
|
|
LibHacHorizonManager.InitializeBcatServer();
|
|
LibHacHorizonManager.InitializeSystemClients();
|
|
|
|
ContentManager = new ContentManager(VirtualFileSystem);
|
|
AccountManager = new AccountManager(LibHacHorizonManager.RyujinxClient);
|
|
UserChannelPersistence = new UserChannelPersistence();
|
|
|
|
_firmwareVersion = ContentManager.GetCurrentFirmwareVersion();
|
|
|
|
|
|
Logger.Notice.Print(LogClass.Application, $"System Firmware Version: {_firmwareVersion.VersionString}");
|
|
}
|
|
|
|
public bool InitializeContext(bool isHostMapped,
|
|
bool useNce,
|
|
SystemLanguage systemLanguage,
|
|
RegionCode regionCode,
|
|
bool enableVsync,
|
|
bool enableDockedMode,
|
|
bool enablePtc,
|
|
bool enableInternetAccess,
|
|
string? timeZone,
|
|
bool ignoreMissingServices)
|
|
{
|
|
if (LibRyujinx.Renderer == null)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
var renderer = LibRyujinx.Renderer;
|
|
BackendThreading threadingMode = LibRyujinx.GraphicsConfiguration.BackendThreading;
|
|
|
|
bool threadedGAL = threadingMode == BackendThreading.On || (threadingMode == BackendThreading.Auto && renderer.PreferThreading);
|
|
|
|
if (threadedGAL)
|
|
{
|
|
renderer = new ThreadedRenderer(renderer);
|
|
}
|
|
|
|
HLEConfiguration configuration = new HLEConfiguration(VirtualFileSystem,
|
|
LibHacHorizonManager,
|
|
ContentManager,
|
|
AccountManager,
|
|
UserChannelPersistence,
|
|
renderer,
|
|
LibRyujinx.AudioDriver, //Audio
|
|
MemoryConfiguration.MemoryConfiguration4GiB,
|
|
HostUiHandler,
|
|
systemLanguage,
|
|
regionCode,
|
|
enableVsync,
|
|
enableDockedMode,
|
|
enablePtc,
|
|
enableInternetAccess,
|
|
IntegrityCheckLevel.None,
|
|
0,
|
|
0,
|
|
timeZone,
|
|
isHostMapped ? MemoryManagerMode.HostMappedUnsafe : MemoryManagerMode.SoftwarePageTable,
|
|
ignoreMissingServices,
|
|
LibRyujinx.GraphicsConfiguration.AspectRatio,
|
|
100,
|
|
useNce,
|
|
"",
|
|
MultiplayerMode.Disabled);
|
|
|
|
EmulationContext = new Switch(configuration);
|
|
|
|
return true;
|
|
}
|
|
|
|
internal void ReloadFileSystem()
|
|
{
|
|
VirtualFileSystem.ReloadKeySet();
|
|
ContentManager = new ContentManager(VirtualFileSystem);
|
|
AccountManager = new AccountManager(LibHacHorizonManager.RyujinxClient);
|
|
}
|
|
|
|
internal void DisposeContext()
|
|
{
|
|
EmulationContext?.Dispose();
|
|
EmulationContext?.DisposeGpu();
|
|
EmulationContext = null;
|
|
LibRyujinx.Renderer = null;
|
|
}
|
|
}
|
|
|
|
public class GameInfo
|
|
{
|
|
public double FileSize;
|
|
public string? TitleName;
|
|
public string? TitleId;
|
|
public string? Developer;
|
|
public string? Version;
|
|
public byte[]? Icon;
|
|
}
|
|
|
|
public class GameStats
|
|
{
|
|
public double Fifo;
|
|
public double GameFps;
|
|
public double GameTime;
|
|
}
|
|
}
|