2020-01-05 12:49:44 +01:00
|
|
|
using LibHac;
|
|
|
|
using LibHac.Account;
|
|
|
|
using LibHac.Common;
|
2020-02-02 04:24:17 +01:00
|
|
|
using LibHac.Fs;
|
2020-01-05 12:49:44 +01:00
|
|
|
using LibHac.Ncm;
|
|
|
|
using LibHac.Ns;
|
|
|
|
using Ryujinx.Common;
|
2018-10-17 19:15:50 +02:00
|
|
|
using Ryujinx.Common.Logging;
|
2019-09-20 06:42:32 +02:00
|
|
|
using Ryujinx.HLE.HOS.Ipc;
|
|
|
|
using Ryujinx.HLE.HOS.Kernel.Common;
|
2020-02-12 00:07:13 +01:00
|
|
|
using Ryujinx.HLE.HOS.Kernel.Memory;
|
2019-09-20 06:42:32 +02:00
|
|
|
using Ryujinx.HLE.HOS.Kernel.Threading;
|
2019-09-19 02:45:11 +02:00
|
|
|
using Ryujinx.HLE.HOS.Services.Am.AppletAE.Storage;
|
2019-11-15 01:25:22 +01:00
|
|
|
using Ryujinx.HLE.HOS.Services.Sdb.Pdm.QueryService;
|
2019-09-20 06:42:32 +02:00
|
|
|
using System;
|
2018-02-05 00:08:20 +01:00
|
|
|
|
2020-01-05 12:49:44 +01:00
|
|
|
using static LibHac.Fs.ApplicationSaveDataManagement;
|
2020-02-02 04:24:17 +01:00
|
|
|
using AccountUid = Ryujinx.HLE.HOS.Services.Account.Acc.UserId;
|
2020-01-05 12:49:44 +01:00
|
|
|
|
2019-09-19 02:45:11 +02:00
|
|
|
namespace Ryujinx.HLE.HOS.Services.Am.AppletOE.ApplicationProxyService.ApplicationProxy
|
2018-02-05 00:08:20 +01:00
|
|
|
{
|
2018-03-19 19:58:46 +01:00
|
|
|
class IApplicationFunctions : IpcService
|
2018-02-05 00:08:20 +01:00
|
|
|
{
|
2019-09-20 06:42:32 +02:00
|
|
|
private KEvent _gpuErrorDetectedSystemEvent;
|
|
|
|
|
|
|
|
public IApplicationFunctions(Horizon system)
|
|
|
|
{
|
2020-05-04 05:41:29 +02:00
|
|
|
_gpuErrorDetectedSystemEvent = new KEvent(system.KernelContext);
|
2019-09-20 06:42:32 +02:00
|
|
|
}
|
2018-02-10 01:14:55 +01:00
|
|
|
|
2019-07-12 03:13:43 +02:00
|
|
|
[Command(1)]
|
|
|
|
// PopLaunchParameter(u32) -> object<nn::am::service::IStorage>
|
2019-07-14 21:04:38 +02:00
|
|
|
public ResultCode PopLaunchParameter(ServiceCtx context)
|
2018-02-05 00:08:20 +01:00
|
|
|
{
|
2019-07-02 04:39:22 +02:00
|
|
|
// Only the first 0x18 bytes of the Data seems to be actually used.
|
2020-02-02 04:24:17 +01:00
|
|
|
MakeObject(context, new AppletAE.IStorage(StorageHelper.MakeLaunchParams(context.Device.System.State.Account.LastOpenedUser)));
|
2018-02-05 00:08:20 +01:00
|
|
|
|
2019-07-14 21:04:38 +02:00
|
|
|
return ResultCode.Success;
|
2018-02-05 00:08:20 +01:00
|
|
|
}
|
|
|
|
|
2019-07-12 03:13:43 +02:00
|
|
|
[Command(20)]
|
|
|
|
// EnsureSaveData(nn::account::Uid) -> u64
|
2019-07-14 21:04:38 +02:00
|
|
|
public ResultCode EnsureSaveData(ServiceCtx context)
|
2018-02-05 00:08:20 +01:00
|
|
|
{
|
2020-02-02 04:24:17 +01:00
|
|
|
Uid userId = context.RequestData.ReadStruct<AccountUid>().ToLibHacUid();
|
2020-01-05 12:49:44 +01:00
|
|
|
TitleId titleId = new TitleId(context.Process.TitleId);
|
2018-04-17 02:24:42 +02:00
|
|
|
|
2020-01-05 12:49:44 +01:00
|
|
|
BlitStruct<ApplicationControlProperty> controlHolder = context.Device.System.ControlData;
|
2018-02-05 00:08:20 +01:00
|
|
|
|
2020-01-05 12:49:44 +01:00
|
|
|
ref ApplicationControlProperty control = ref controlHolder.Value;
|
2019-11-15 01:25:22 +01:00
|
|
|
|
2020-01-05 12:49:44 +01:00
|
|
|
if (Util.IsEmpty(controlHolder.ByteSpan))
|
|
|
|
{
|
|
|
|
// If the current application doesn't have a loaded control property, create a dummy one
|
|
|
|
// and set the savedata sizes so a user savedata will be created.
|
|
|
|
control = ref new BlitStruct<ApplicationControlProperty>(1).Value;
|
|
|
|
|
|
|
|
// The set sizes don't actually matter as long as they're non-zero because we use directory savedata.
|
|
|
|
control.UserAccountSaveDataSize = 0x4000;
|
|
|
|
control.UserAccountSaveDataJournalSize = 0x4000;
|
|
|
|
|
|
|
|
Logger.PrintWarning(LogClass.ServiceAm,
|
|
|
|
"No control file was found for this game. Using a dummy one instead. This may cause inaccuracies in some games.");
|
|
|
|
}
|
|
|
|
|
2020-01-21 23:23:11 +01:00
|
|
|
Result result = EnsureApplicationSaveData(context.Device.FileSystem.FsClient, out long requiredSize, titleId,
|
2020-02-18 12:35:47 +01:00
|
|
|
ref control, ref userId);
|
2020-01-05 12:49:44 +01:00
|
|
|
|
|
|
|
context.ResponseData.Write(requiredSize);
|
|
|
|
|
|
|
|
return (ResultCode)result.Value;
|
2018-02-05 00:08:20 +01:00
|
|
|
}
|
|
|
|
|
2019-07-12 03:13:43 +02:00
|
|
|
[Command(21)]
|
|
|
|
// GetDesiredLanguage() -> nn::settings::LanguageCode
|
2019-07-14 21:04:38 +02:00
|
|
|
public ResultCode GetDesiredLanguage(ServiceCtx context)
|
2018-02-05 00:08:20 +01:00
|
|
|
{
|
2018-12-06 12:16:24 +01:00
|
|
|
context.ResponseData.Write(context.Device.System.State.DesiredLanguageCode);
|
2018-02-05 00:08:20 +01:00
|
|
|
|
2019-07-14 21:04:38 +02:00
|
|
|
return ResultCode.Success;
|
2018-02-05 00:08:20 +01:00
|
|
|
}
|
|
|
|
|
2019-07-12 03:13:43 +02:00
|
|
|
[Command(22)]
|
|
|
|
// SetTerminateResult(u32)
|
2019-07-14 21:04:38 +02:00
|
|
|
public ResultCode SetTerminateResult(ServiceCtx context)
|
2018-02-25 19:58:16 +01:00
|
|
|
{
|
2020-04-12 14:13:23 +02:00
|
|
|
Result result = new Result(context.RequestData.ReadUInt32());
|
2018-02-25 19:58:16 +01:00
|
|
|
|
2020-04-12 14:13:23 +02:00
|
|
|
Logger.PrintInfo(LogClass.ServiceAm, $"Result = 0x{result.Value:x8} ({result.ToStringWithName()}).");
|
2018-02-25 19:58:16 +01:00
|
|
|
|
2019-07-14 21:04:38 +02:00
|
|
|
return ResultCode.Success;
|
2018-02-25 19:58:16 +01:00
|
|
|
}
|
|
|
|
|
2019-07-12 03:13:43 +02:00
|
|
|
[Command(23)]
|
|
|
|
// GetDisplayVersion() -> nn::oe::DisplayVersion
|
2019-07-14 21:04:38 +02:00
|
|
|
public ResultCode GetDisplayVersion(ServiceCtx context)
|
2018-04-22 06:21:49 +02:00
|
|
|
{
|
2019-07-02 04:39:22 +02:00
|
|
|
// FIXME: Need to check correct version on a switch.
|
2018-12-06 12:16:24 +01:00
|
|
|
context.ResponseData.Write(1L);
|
|
|
|
context.ResponseData.Write(0L);
|
2018-04-22 06:21:49 +02:00
|
|
|
|
2019-07-14 21:04:38 +02:00
|
|
|
return ResultCode.Success;
|
2018-04-22 06:21:49 +02:00
|
|
|
}
|
|
|
|
|
2020-02-02 04:24:17 +01:00
|
|
|
// GetSaveDataSize(u8, nn::account::Uid) -> (u64, u64)
|
|
|
|
[Command(26)] // 3.0.0+
|
|
|
|
public ResultCode GetSaveDataSize(ServiceCtx context)
|
|
|
|
{
|
|
|
|
SaveDataType saveDataType = (SaveDataType)context.RequestData.ReadByte();
|
|
|
|
context.RequestData.BaseStream.Seek(7, System.IO.SeekOrigin.Current);
|
|
|
|
|
|
|
|
Uid userId = context.RequestData.ReadStruct<AccountUid>().ToLibHacUid();
|
|
|
|
|
|
|
|
// TODO: We return a size of 2GB as we use a directory based save system. This should be enough for most of the games.
|
|
|
|
context.ResponseData.Write(2000000000u);
|
|
|
|
|
|
|
|
Logger.PrintStub(LogClass.ServiceAm, new { saveDataType, userId });
|
|
|
|
|
|
|
|
return ResultCode.Success;
|
|
|
|
}
|
|
|
|
|
2019-07-12 03:13:43 +02:00
|
|
|
[Command(40)]
|
|
|
|
// NotifyRunning() -> b8
|
2019-07-14 21:04:38 +02:00
|
|
|
public ResultCode NotifyRunning(ServiceCtx context)
|
2018-02-07 00:28:32 +01:00
|
|
|
{
|
2018-12-06 12:16:24 +01:00
|
|
|
context.ResponseData.Write(1);
|
2018-02-07 00:28:32 +01:00
|
|
|
|
2019-07-14 21:04:38 +02:00
|
|
|
return ResultCode.Success;
|
2018-02-07 00:28:32 +01:00
|
|
|
}
|
|
|
|
|
2019-07-12 03:13:43 +02:00
|
|
|
[Command(50)] // 2.0.0+
|
|
|
|
// GetPseudoDeviceId() -> nn::util::Uuid
|
2019-07-14 21:04:38 +02:00
|
|
|
public ResultCode GetPseudoDeviceId(ServiceCtx context)
|
2018-05-25 23:33:09 +02:00
|
|
|
{
|
2018-12-06 12:16:24 +01:00
|
|
|
context.ResponseData.Write(0L);
|
|
|
|
context.ResponseData.Write(0L);
|
2018-05-25 23:33:09 +02:00
|
|
|
|
2019-11-15 01:25:22 +01:00
|
|
|
Logger.PrintStub(LogClass.ServiceAm);
|
|
|
|
|
2019-07-14 21:04:38 +02:00
|
|
|
return ResultCode.Success;
|
2018-05-25 23:33:09 +02:00
|
|
|
}
|
|
|
|
|
2019-07-12 03:13:43 +02:00
|
|
|
[Command(66)] // 3.0.0+
|
|
|
|
// InitializeGamePlayRecording(u64, handle<copy>)
|
2019-07-14 21:04:38 +02:00
|
|
|
public ResultCode InitializeGamePlayRecording(ServiceCtx context)
|
2018-02-05 00:08:20 +01:00
|
|
|
{
|
2019-01-11 01:11:46 +01:00
|
|
|
Logger.PrintStub(LogClass.ServiceAm);
|
2018-02-05 00:08:20 +01:00
|
|
|
|
2019-07-14 21:04:38 +02:00
|
|
|
return ResultCode.Success;
|
2018-06-03 00:46:09 +02:00
|
|
|
}
|
2018-02-05 00:08:20 +01:00
|
|
|
|
2019-07-12 03:13:43 +02:00
|
|
|
[Command(67)] // 3.0.0+
|
|
|
|
// SetGamePlayRecordingState(u32)
|
2019-07-14 21:04:38 +02:00
|
|
|
public ResultCode SetGamePlayRecordingState(ServiceCtx context)
|
2018-06-03 00:46:09 +02:00
|
|
|
{
|
2018-12-06 12:16:24 +01:00
|
|
|
int state = context.RequestData.ReadInt32();
|
2018-06-03 00:46:09 +02:00
|
|
|
|
2019-11-15 01:25:22 +01:00
|
|
|
Logger.PrintStub(LogClass.ServiceAm, new { state });
|
2018-02-05 00:08:20 +01:00
|
|
|
|
2019-07-14 21:04:38 +02:00
|
|
|
return ResultCode.Success;
|
2018-02-05 00:08:20 +01:00
|
|
|
}
|
2019-09-20 06:42:32 +02:00
|
|
|
|
2020-02-12 00:07:13 +01:00
|
|
|
[Command(100)] // 5.0.0+
|
|
|
|
// InitializeApplicationCopyrightFrameBuffer(s32 width, s32 height, handle<copy, transfer_memory> transfer_memory, u64 transfer_memory_size)
|
|
|
|
public ResultCode InitializeApplicationCopyrightFrameBuffer(ServiceCtx context)
|
|
|
|
{
|
|
|
|
int width = context.RequestData.ReadInt32();
|
|
|
|
int height = context.RequestData.ReadInt32();
|
|
|
|
ulong transferMemorySize = context.RequestData.ReadUInt64();
|
|
|
|
int transferMemoryHandle = context.Request.HandleDesc.ToCopy[0];
|
|
|
|
ulong transferMemoryAddress = context.Process.HandleTable.GetObject<KTransferMemory>(transferMemoryHandle).Address;
|
|
|
|
|
|
|
|
ResultCode resultCode = ResultCode.InvalidParameters;
|
|
|
|
|
|
|
|
if (((transferMemorySize & 0x3FFFF) == 0) && width <= 1280 && height <= 720)
|
|
|
|
{
|
|
|
|
resultCode = InitializeApplicationCopyrightFrameBufferImpl(transferMemoryAddress, transferMemorySize, width, height);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
if (transferMemoryHandle)
|
|
|
|
{
|
|
|
|
svcCloseHandle(transferMemoryHandle);
|
|
|
|
}
|
|
|
|
*/
|
|
|
|
|
|
|
|
return resultCode;
|
|
|
|
}
|
|
|
|
|
|
|
|
private ResultCode InitializeApplicationCopyrightFrameBufferImpl(ulong transferMemoryAddress, ulong transferMemorySize, int width, int height)
|
|
|
|
{
|
|
|
|
ResultCode resultCode = ResultCode.ObjectInvalid;
|
|
|
|
|
|
|
|
if ((transferMemorySize & 0x3FFFF) != 0)
|
|
|
|
{
|
|
|
|
return ResultCode.InvalidParameters;
|
|
|
|
}
|
|
|
|
|
|
|
|
// if (_copyrightBuffer == null)
|
|
|
|
{
|
|
|
|
// TODO: Initialize buffer and object.
|
|
|
|
|
|
|
|
Logger.PrintStub(LogClass.ServiceAm, new { transferMemoryAddress, transferMemorySize, width, height });
|
|
|
|
|
|
|
|
resultCode = ResultCode.Success;
|
|
|
|
}
|
|
|
|
|
|
|
|
return resultCode;
|
|
|
|
}
|
|
|
|
|
|
|
|
[Command(101)] // 5.0.0+
|
|
|
|
// SetApplicationCopyrightImage(buffer<bytes, 0x45> frame_buffer, s32 x, s32 y, s32 width, s32 height, s32 window_origin_mode)
|
|
|
|
public ResultCode SetApplicationCopyrightImage(ServiceCtx context)
|
|
|
|
{
|
|
|
|
long frameBufferPos = context.Request.SendBuff[0].Position;
|
|
|
|
long frameBufferSize = context.Request.SendBuff[0].Size;
|
|
|
|
int x = context.RequestData.ReadInt32();
|
|
|
|
int y = context.RequestData.ReadInt32();
|
|
|
|
int width = context.RequestData.ReadInt32();
|
|
|
|
int height = context.RequestData.ReadInt32();
|
|
|
|
uint windowOriginMode = context.RequestData.ReadUInt32();
|
|
|
|
|
|
|
|
ResultCode resultCode = ResultCode.InvalidParameters;
|
|
|
|
|
|
|
|
if (((y | x) >= 0) && width >= 1 && height >= 1)
|
|
|
|
{
|
|
|
|
ResultCode result = SetApplicationCopyrightImageImpl(x, y, width, height, frameBufferPos, frameBufferSize, windowOriginMode);
|
|
|
|
|
|
|
|
if (resultCode != ResultCode.Success)
|
|
|
|
{
|
|
|
|
resultCode = result;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
resultCode = ResultCode.Success;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
Logger.PrintStub(LogClass.ServiceAm, new { frameBufferPos, frameBufferSize, x, y, width, height, windowOriginMode });
|
|
|
|
|
|
|
|
return resultCode;
|
|
|
|
}
|
|
|
|
|
|
|
|
private ResultCode SetApplicationCopyrightImageImpl(int x, int y, int width, int height, long frameBufferPos, long frameBufferSize, uint windowOriginMode)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
if (_copyrightBuffer == null)
|
|
|
|
{
|
|
|
|
return ResultCode.NullCopyrightObject;
|
|
|
|
}
|
|
|
|
*/
|
|
|
|
|
|
|
|
Logger.PrintStub(LogClass.ServiceAm, new { x, y, width, height, frameBufferPos, frameBufferSize, windowOriginMode });
|
|
|
|
|
|
|
|
return ResultCode.Success;
|
|
|
|
}
|
|
|
|
|
|
|
|
[Command(102)] // 5.0.0+
|
|
|
|
// SetApplicationCopyrightVisibility(bool visible)
|
|
|
|
public ResultCode SetApplicationCopyrightVisibility(ServiceCtx context)
|
|
|
|
{
|
|
|
|
bool visible = context.RequestData.ReadBoolean();
|
|
|
|
|
|
|
|
Logger.PrintStub(LogClass.ServiceAm, new { visible });
|
|
|
|
|
|
|
|
// NOTE: It sets an internal field and return ResultCode.Success in all case.
|
|
|
|
|
|
|
|
return ResultCode.Success;
|
|
|
|
}
|
|
|
|
|
2019-11-15 01:25:22 +01:00
|
|
|
[Command(110)] // 5.0.0+
|
|
|
|
// QueryApplicationPlayStatistics(buffer<bytes, 5> title_id_list) -> (buffer<bytes, 6> entries, s32 entries_count)
|
|
|
|
public ResultCode QueryApplicationPlayStatistics(ServiceCtx context)
|
|
|
|
{
|
|
|
|
// TODO: Call pdm:qry cmd 13 when IPC call between services will be implemented.
|
|
|
|
return (ResultCode)QueryPlayStatisticsManager.GetPlayStatistics(context);
|
|
|
|
}
|
|
|
|
|
|
|
|
[Command(111)] // 6.0.0+
|
|
|
|
// QueryApplicationPlayStatisticsByUid(nn::account::Uid, buffer<bytes, 5> title_id_list) -> (buffer<bytes, 6> entries, s32 entries_count)
|
|
|
|
public ResultCode QueryApplicationPlayStatisticsByUid(ServiceCtx context)
|
|
|
|
{
|
|
|
|
// TODO: Call pdm:qry cmd 16 when IPC call between services will be implemented.
|
|
|
|
return (ResultCode)QueryPlayStatisticsManager.GetPlayStatistics(context, true);
|
|
|
|
}
|
|
|
|
|
2019-09-20 06:42:32 +02:00
|
|
|
[Command(130)] // 8.0.0+
|
|
|
|
// GetGpuErrorDetectedSystemEvent() -> handle<copy>
|
|
|
|
public ResultCode GetGpuErrorDetectedSystemEvent(ServiceCtx context)
|
|
|
|
{
|
|
|
|
if (context.Process.HandleTable.GenerateHandle(_gpuErrorDetectedSystemEvent.ReadableEvent, out int gpuErrorDetectedSystemEventHandle) != KernelResult.Success)
|
|
|
|
{
|
|
|
|
throw new InvalidOperationException("Out of handles!");
|
|
|
|
}
|
|
|
|
|
|
|
|
context.Response.HandleDesc = IpcHandleDesc.MakeCopy(gpuErrorDetectedSystemEventHandle);
|
|
|
|
|
|
|
|
// NOTE: This is used by "sdk" NSO during applet-application initialization.
|
|
|
|
// A seperate thread is setup where event-waiting is handled.
|
|
|
|
// When the Event is signaled, official sw will assert.
|
|
|
|
|
|
|
|
return ResultCode.Success;
|
|
|
|
}
|
2018-02-05 00:08:20 +01:00
|
|
|
}
|
2019-07-12 03:13:43 +02:00
|
|
|
}
|