mirror of
https://github.com/Ryujinx/Ryujinx.git
synced 2024-11-18 16:36:40 +00:00
071c01c235
* Fix sorting regression + Remove unsued sort * Fix GTK * Attempt 2 to fix GTK * Whoopsie * Fix whitspace
856 lines
No EOL
37 KiB
C#
856 lines
No EOL
37 KiB
C#
using LibHac;
|
|
using LibHac.Common;
|
|
using LibHac.Common.Keys;
|
|
using LibHac.Fs;
|
|
using LibHac.Fs.Fsa;
|
|
using LibHac.FsSystem;
|
|
using LibHac.Ns;
|
|
using LibHac.Tools.Fs;
|
|
using LibHac.Tools.FsSystem;
|
|
using LibHac.Tools.FsSystem.NcaUtils;
|
|
using Ryujinx.Common.Configuration;
|
|
using Ryujinx.Common.Logging;
|
|
using Ryujinx.HLE.FileSystem;
|
|
using Ryujinx.HLE.HOS;
|
|
using Ryujinx.HLE.HOS.SystemState;
|
|
using Ryujinx.HLE.Loaders.Npdm;
|
|
using Ryujinx.Ui.Common.Configuration.System;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Reflection;
|
|
using System.Text;
|
|
using System.Text.Json;
|
|
using System.Threading;
|
|
using JsonHelper = Ryujinx.Common.Utilities.JsonHelper;
|
|
using Path = System.IO.Path;
|
|
|
|
namespace Ryujinx.Ui.App.Common
|
|
{
|
|
public class ApplicationLibrary
|
|
{
|
|
public event EventHandler<ApplicationAddedEventArgs> ApplicationAdded;
|
|
public event EventHandler<ApplicationCountUpdatedEventArgs> ApplicationCountUpdated;
|
|
|
|
private readonly byte[] _nspIcon;
|
|
private readonly byte[] _xciIcon;
|
|
private readonly byte[] _ncaIcon;
|
|
private readonly byte[] _nroIcon;
|
|
private readonly byte[] _nsoIcon;
|
|
|
|
private VirtualFileSystem _virtualFileSystem;
|
|
private Language _desiredTitleLanguage;
|
|
private CancellationTokenSource _cancellationToken;
|
|
|
|
public ApplicationLibrary(VirtualFileSystem virtualFileSystem)
|
|
{
|
|
_virtualFileSystem = virtualFileSystem;
|
|
|
|
_nspIcon = GetResourceBytes("Ryujinx.Ui.Common.Resources.Icon_NSP.png");
|
|
_xciIcon = GetResourceBytes("Ryujinx.Ui.Common.Resources.Icon_XCI.png");
|
|
_ncaIcon = GetResourceBytes("Ryujinx.Ui.Common.Resources.Icon_NCA.png");
|
|
_nroIcon = GetResourceBytes("Ryujinx.Ui.Common.Resources.Icon_NRO.png");
|
|
_nsoIcon = GetResourceBytes("Ryujinx.Ui.Common.Resources.Icon_NSO.png");
|
|
}
|
|
|
|
private byte[] GetResourceBytes(string resourceName)
|
|
{
|
|
Stream resourceStream = Assembly.GetCallingAssembly().GetManifestResourceStream(resourceName);
|
|
byte[] resourceByteArray = new byte[resourceStream.Length];
|
|
|
|
resourceStream.Read(resourceByteArray);
|
|
|
|
return resourceByteArray;
|
|
}
|
|
|
|
public void CancelLoading()
|
|
{
|
|
_cancellationToken?.Cancel();
|
|
}
|
|
|
|
public IEnumerable<string> GetFilesInDirectory(string directory)
|
|
{
|
|
Stack<string> stack = new Stack<string>();
|
|
|
|
stack.Push(directory);
|
|
|
|
while (stack.Count > 0)
|
|
{
|
|
string dir = stack.Pop();
|
|
string[] content = Array.Empty<string>();
|
|
|
|
try
|
|
{
|
|
content = Directory.GetFiles(dir, "*");
|
|
}
|
|
catch (UnauthorizedAccessException)
|
|
{
|
|
Logger.Warning?.Print(LogClass.Application, $"Failed to get access to directory: \"{dir}\"");
|
|
}
|
|
|
|
if (content.Length > 0)
|
|
{
|
|
foreach (string file in content)
|
|
{
|
|
yield return file;
|
|
}
|
|
}
|
|
|
|
try
|
|
{
|
|
content = Directory.GetDirectories(dir);
|
|
}
|
|
catch (UnauthorizedAccessException)
|
|
{
|
|
Logger.Warning?.Print(LogClass.Application, $"Failed to get access to directory: \"{dir}\"");
|
|
}
|
|
|
|
if (content.Length > 0)
|
|
{
|
|
foreach (string subdir in content)
|
|
{
|
|
stack.Push(subdir);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void ReadControlData(IFileSystem controlFs, Span<byte> outProperty)
|
|
{
|
|
using var controlFile = new UniqueRef<IFile>();
|
|
|
|
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 List<string>();
|
|
|
|
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;
|
|
}
|
|
|
|
foreach (string app in GetFilesInDirectory(appDir))
|
|
{
|
|
if (_cancellationToken.Token.IsCancellationRequested)
|
|
{
|
|
return;
|
|
}
|
|
|
|
string extension = Path.GetExtension(app).ToLower();
|
|
|
|
if ((extension == ".nsp") ||
|
|
(extension == ".pfs0") ||
|
|
(extension == ".xci") ||
|
|
(extension == ".nca") ||
|
|
(extension == ".nro") ||
|
|
(extension == ".nso"))
|
|
{
|
|
applications.Add(app);
|
|
numApplicationsFound++;
|
|
}
|
|
}
|
|
}
|
|
|
|
// 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;
|
|
}
|
|
|
|
double fileSize = new FileInfo(applicationPath).Length * 0.000000000931;
|
|
string titleName = "Unknown";
|
|
string titleId = "0000000000000000";
|
|
string developer = "Unknown";
|
|
string version = "0";
|
|
byte[] applicationIcon = null;
|
|
|
|
BlitStruct<ApplicationControlProperty> controlHolder = new BlitStruct<ApplicationControlProperty>(1);
|
|
|
|
try
|
|
{
|
|
string extension = Path.GetExtension(applicationPath).ToLower();
|
|
|
|
using (FileStream file = new FileStream(applicationPath, FileMode.Open, FileAccess.Read))
|
|
{
|
|
if (extension == ".nsp" || extension == ".pfs0" || extension == ".xci")
|
|
{
|
|
try
|
|
{
|
|
PartitionFileSystem pfs;
|
|
|
|
bool isExeFs = false;
|
|
|
|
if (extension == ".xci")
|
|
{
|
|
Xci xci = new Xci(_virtualFileSystem.KeySet, file.AsStorage());
|
|
|
|
pfs = xci.OpenPartition(XciPartitionType.Secure);
|
|
}
|
|
else
|
|
{
|
|
pfs = new PartitionFileSystem(file.AsStorage());
|
|
|
|
// 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 var ncaFile = new UniqueRef<IFile>();
|
|
|
|
pfs.OpenFile(ref ncaFile.Ref(), fileEntry.FullPath.ToU8Span(), OpenMode.Read).ThrowIfFailure();
|
|
|
|
Nca nca = new Nca(_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 var npdmFile = new UniqueRef<IFile>();
|
|
|
|
Result result = pfs.OpenFile(ref npdmFile.Ref(), "/main.npdm".ToU8Span(), OpenMode.Read);
|
|
|
|
if (ResultFs.PathNotFound.Includes(result))
|
|
{
|
|
Npdm npdm = new Npdm(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 var icon = new UniqueRef<IFile>();
|
|
|
|
controlFs.OpenFile(ref icon.Ref(), $"/icon_{_desiredTitleLanguage}.dat".ToU8Span(), OpenMode.Read).ThrowIfFailure();
|
|
|
|
using (MemoryStream stream = new MemoryStream())
|
|
{
|
|
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 MemoryStream())
|
|
{
|
|
icon.Get.AsStream().CopyTo(stream);
|
|
applicationIcon = stream.ToArray();
|
|
}
|
|
|
|
if (applicationIcon != null)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (applicationIcon == null)
|
|
{
|
|
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")
|
|
{
|
|
BinaryReader reader = new BinaryReader(file);
|
|
|
|
byte[] Read(long position, int size)
|
|
{
|
|
file.Seek(position, SeekOrigin.Begin);
|
|
|
|
return reader.ReadBytes(size);
|
|
}
|
|
|
|
try
|
|
{
|
|
file.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
|
|
applicationIcon = Read(assetOffset + iconOffset, (int)iconSize);
|
|
|
|
// Read the NACP data
|
|
Read(assetOffset + (int)nacpOffset, (int)nacpSize).AsSpan().CopyTo(controlHolder.ByteSpan);
|
|
|
|
GetGameInformation(ref controlHolder.Value, out titleName, out titleId, out developer, out version);
|
|
}
|
|
else
|
|
{
|
|
applicationIcon = _nroIcon;
|
|
titleName = Path.GetFileNameWithoutExtension(applicationPath);
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
Logger.Warning?.Print(LogClass.Application, $"The file encountered was not of a valid type. Errored File: {applicationPath}");
|
|
|
|
numApplicationsFound--;
|
|
|
|
continue;
|
|
}
|
|
}
|
|
else if (extension == ".nca")
|
|
{
|
|
try
|
|
{
|
|
Nca nca = new Nca(_virtualFileSystem.KeySet, new FileStream(applicationPath, FileMode.Open, FileAccess.Read).AsStorage());
|
|
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;
|
|
}
|
|
}
|
|
catch (InvalidDataException)
|
|
{
|
|
Logger.Warning?.Print(LogClass.Application, $"The NCA header content type check has failed. This is usually because the header key is incorrect or missing. Errored File: {applicationPath}");
|
|
}
|
|
catch
|
|
{
|
|
Logger.Warning?.Print(LogClass.Application, $"The file encountered was not of a valid type. Errored File: {applicationPath}");
|
|
|
|
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--;
|
|
|
|
continue;
|
|
}
|
|
|
|
ApplicationMetadata appMetadata = LoadAndSaveMetaData(titleId, appMetadata =>
|
|
{
|
|
appMetadata.Title = titleName;
|
|
});
|
|
|
|
if (appMetadata.LastPlayed != "Never" && !DateTime.TryParse(appMetadata.LastPlayed, out _))
|
|
{
|
|
Logger.Warning?.Print(LogClass.Application, $"Last played datetime \"{appMetadata.LastPlayed}\" is invalid for current system culture, skipping (did current culture change?)");
|
|
|
|
appMetadata.LastPlayed = "Never";
|
|
}
|
|
|
|
ApplicationData data = new ApplicationData
|
|
{
|
|
Favorite = appMetadata.Favorite,
|
|
Icon = applicationIcon,
|
|
TitleName = titleName,
|
|
TitleId = titleId,
|
|
Developer = developer,
|
|
Version = version,
|
|
TimePlayed = ConvertSecondsToReadableString(appMetadata.TimePlayed),
|
|
TimePlayedNum = appMetadata.TimePlayed,
|
|
LastPlayed = appMetadata.LastPlayed,
|
|
FileExtension = Path.GetExtension(applicationPath).ToUpper().Remove(0, 1),
|
|
FileSize = (fileSize < 1) ? (fileSize * 1024).ToString("0.##") + " MiB" : fileSize.ToString("0.##") + " GiB",
|
|
FileSizeBytes = fileSize,
|
|
Path = applicationPath,
|
|
ControlHolder = controlHolder
|
|
};
|
|
|
|
numApplicationsLoaded++;
|
|
|
|
OnApplicationAdded(new ApplicationAddedEventArgs()
|
|
{
|
|
AppData = data
|
|
});
|
|
|
|
OnApplicationCountUpdated(new ApplicationCountUpdatedEventArgs()
|
|
{
|
|
NumAppsFound = numApplicationsFound,
|
|
NumAppsLoaded = numApplicationsLoaded
|
|
});
|
|
}
|
|
|
|
OnApplicationCountUpdated(new ApplicationCountUpdatedEventArgs()
|
|
{
|
|
NumAppsFound = numApplicationsFound,
|
|
NumAppsLoaded = numApplicationsLoaded
|
|
});
|
|
}
|
|
finally
|
|
{
|
|
_cancellationToken.Dispose();
|
|
_cancellationToken = null;
|
|
}
|
|
}
|
|
|
|
protected void OnApplicationAdded(ApplicationAddedEventArgs e)
|
|
{
|
|
ApplicationAdded?.Invoke(null, e);
|
|
}
|
|
|
|
protected void OnApplicationCountUpdated(ApplicationCountUpdatedEventArgs e)
|
|
{
|
|
ApplicationCountUpdated?.Invoke(null, e);
|
|
}
|
|
|
|
private void GetControlFsAndTitleId(PartitionFileSystem pfs, out IFileSystem controlFs, out string titleId)
|
|
{
|
|
(_, _, Nca controlNca) = ApplicationLoader.GetGameData(_virtualFileSystem, pfs, 0);
|
|
|
|
// Return the ControlFS
|
|
controlFs = controlNca?.OpenFileSystem(NcaSectionType.Data, IntegrityCheckLevel.None);
|
|
titleId = controlNca?.Header.TitleId.ToString("x16");
|
|
}
|
|
|
|
public ApplicationMetadata LoadAndSaveMetaData(string titleId, Action<ApplicationMetadata> modifyFunction = null)
|
|
{
|
|
string metadataFolder = Path.Combine(AppDataManager.GamesDirPath, titleId, "gui");
|
|
string metadataFile = Path.Combine(metadataFolder, "metadata.json");
|
|
|
|
ApplicationMetadata appMetadata;
|
|
|
|
if (!File.Exists(metadataFile))
|
|
{
|
|
Directory.CreateDirectory(metadataFolder);
|
|
|
|
appMetadata = new ApplicationMetadata();
|
|
|
|
using (FileStream stream = File.Create(metadataFile, 4096, FileOptions.WriteThrough))
|
|
{
|
|
JsonHelper.Serialize(stream, appMetadata, true);
|
|
}
|
|
}
|
|
|
|
try
|
|
{
|
|
appMetadata = JsonHelper.DeserializeFromFile<ApplicationMetadata>(metadataFile);
|
|
}
|
|
catch (JsonException)
|
|
{
|
|
Logger.Warning?.Print(LogClass.Application, $"Failed to parse metadata json for {titleId}. Loading defaults.");
|
|
|
|
appMetadata = new ApplicationMetadata();
|
|
}
|
|
|
|
if (modifyFunction != null)
|
|
{
|
|
modifyFunction(appMetadata);
|
|
|
|
using (FileStream stream = File.Create(metadataFile, 4096, FileOptions.WriteThrough))
|
|
{
|
|
JsonHelper.Serialize(stream, appMetadata, true);
|
|
}
|
|
}
|
|
|
|
return appMetadata;
|
|
}
|
|
|
|
public byte[] GetApplicationIcon(string applicationPath)
|
|
{
|
|
byte[] applicationIcon = null;
|
|
|
|
try
|
|
{
|
|
// Look for icon only if applicationPath is not a directory
|
|
if (!Directory.Exists(applicationPath))
|
|
{
|
|
string extension = Path.GetExtension(applicationPath).ToLower();
|
|
|
|
using (FileStream file = new FileStream(applicationPath, FileMode.Open, FileAccess.Read))
|
|
{
|
|
if (extension == ".nsp" || extension == ".pfs0" || extension == ".xci")
|
|
{
|
|
try
|
|
{
|
|
PartitionFileSystem pfs;
|
|
|
|
bool isExeFs = false;
|
|
|
|
if (extension == ".xci")
|
|
{
|
|
Xci xci = new(_virtualFileSystem.KeySet, file.AsStorage());
|
|
|
|
pfs = xci.OpenPartition(XciPartitionType.Secure);
|
|
}
|
|
else
|
|
{
|
|
pfs = new PartitionFileSystem(file.AsStorage());
|
|
|
|
foreach (DirectoryEntryEx fileEntry in pfs.EnumerateEntries("/", "*"))
|
|
{
|
|
if (Path.GetFileNameWithoutExtension(fileEntry.FullPath) == "main")
|
|
{
|
|
isExeFs = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (isExeFs)
|
|
{
|
|
applicationIcon = _nspIcon;
|
|
}
|
|
else
|
|
{
|
|
// Store the ControlFS in variable called controlFs
|
|
GetControlFsAndTitleId(pfs, out IFileSystem controlFs, out _);
|
|
|
|
// Read the icon from the ControlFS and store it as a byte array
|
|
try
|
|
{
|
|
using var icon = new UniqueRef<IFile>();
|
|
|
|
controlFs.OpenFile(ref icon.Ref(), $"/icon_{_desiredTitleLanguage}.dat".ToU8Span(), OpenMode.Read).ThrowIfFailure();
|
|
|
|
using (MemoryStream stream = new MemoryStream())
|
|
{
|
|
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 MemoryStream())
|
|
{
|
|
icon.Get.AsStream().CopyTo(stream);
|
|
applicationIcon = stream.ToArray();
|
|
}
|
|
|
|
if (applicationIcon != null)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (applicationIcon == null)
|
|
{
|
|
applicationIcon = extension == ".xci" ? _xciIcon : _nspIcon;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
catch (MissingKeyException)
|
|
{
|
|
applicationIcon = extension == ".xci"
|
|
? _xciIcon
|
|
: _nspIcon;
|
|
}
|
|
catch (InvalidDataException)
|
|
{
|
|
applicationIcon = extension == ".xci"
|
|
? _xciIcon
|
|
: _nspIcon;
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
Logger.Warning?.Print(LogClass.Application,
|
|
$"The file encountered was not of a valid type. File: '{applicationPath}' Error: {exception}");
|
|
}
|
|
}
|
|
else if (extension == ".nro")
|
|
{
|
|
BinaryReader reader = new(file);
|
|
|
|
byte[] Read(long position, int size)
|
|
{
|
|
file.Seek(position, SeekOrigin.Begin);
|
|
|
|
return reader.ReadBytes(size);
|
|
}
|
|
|
|
try
|
|
{
|
|
file.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);
|
|
|
|
// Reads and stores game icon as byte array
|
|
applicationIcon = Read(assetOffset + iconOffset, (int)iconSize);
|
|
}
|
|
else
|
|
{
|
|
applicationIcon = _nroIcon;
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
Logger.Warning?.Print(LogClass.Application,
|
|
$"The file encountered was not of a valid type. Errored File: {applicationPath}");
|
|
}
|
|
}
|
|
else if (extension == ".nca")
|
|
{
|
|
applicationIcon = _ncaIcon;
|
|
}
|
|
// If its an NSO we just set defaults
|
|
else if (extension == ".nso")
|
|
{
|
|
applicationIcon = _nsoIcon;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
catch(Exception)
|
|
{
|
|
Logger.Warning?.Print(LogClass.Application,
|
|
$"Could not retrieve a valid icon for the app. Default icon will be used. Errored File: {applicationPath}");
|
|
}
|
|
|
|
return applicationIcon ?? _ncaIcon;
|
|
}
|
|
|
|
private string ConvertSecondsToReadableString(double seconds)
|
|
{
|
|
const int secondsPerMinute = 60;
|
|
const int secondsPerHour = secondsPerMinute * 60;
|
|
const int secondsPerDay = secondsPerHour * 24;
|
|
|
|
string readableString;
|
|
|
|
if (seconds < secondsPerMinute)
|
|
{
|
|
readableString = $"{seconds} seconds";
|
|
}
|
|
else if (seconds < secondsPerHour)
|
|
{
|
|
readableString = $"{Math.Round(seconds / secondsPerMinute, 0, MidpointRounding.AwayFromZero)} minutes";
|
|
}
|
|
else if (seconds < secondsPerDay)
|
|
{
|
|
readableString = $"{Math.Round(seconds / secondsPerHour, 1, MidpointRounding.AwayFromZero)} hours";
|
|
}
|
|
else
|
|
{
|
|
readableString = $"{Math.Round(seconds / secondsPerDay, 1, MidpointRounding.AwayFromZero)} days";
|
|
}
|
|
|
|
return readableString;
|
|
}
|
|
|
|
private void GetGameInformation(ref ApplicationControlProperty controlData, out string titleName, out string titleId, out string publisher, out string version)
|
|
{
|
|
_ = Enum.TryParse(_desiredTitleLanguage.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();
|
|
}
|
|
|
|
private bool IsUpdateApplied(string titleId, out IFileSystem updatedControlFs)
|
|
{
|
|
updatedControlFs = null;
|
|
|
|
string updatePath = "(unknown)";
|
|
|
|
try
|
|
{
|
|
(Nca patchNca, Nca controlNca) = ApplicationLoader.GetGameUpdateData(_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;
|
|
}
|
|
}
|
|
} |