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.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;
|
2020-09-21 05:45:30 +02:00
|
|
|
using Ryujinx.HLE.HOS.Services.Am.AppletOE.ApplicationProxyService.ApplicationProxy.Types;
|
2019-11-15 01:25:22 +01:00
|
|
|
using Ryujinx.HLE.HOS.Services.Sdb.Pdm.QueryService;
|
2020-05-27 10:40:23 +02:00
|
|
|
using Ryujinx.HLE.HOS.SystemState;
|
2019-09-20 06:42:32 +02:00
|
|
|
using System;
|
2020-05-27 10:40:23 +02:00
|
|
|
using System.Numerics;
|
2018-02-05 00:08:20 +01:00
|
|
|
|
2020-01-05 12:49:44 +01:00
|
|
|
using static LibHac.Fs.ApplicationSaveDataManagement;
|
2020-11-21 23:38:34 +01:00
|
|
|
using AccountUid = Ryujinx.HLE.HOS.Services.Account.Acc.UserId;
|
2020-09-01 22:08:59 +02:00
|
|
|
using ApplicationId = LibHac.Ncm.ApplicationId;
|
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;
|
2020-05-12 16:52:27 +02:00
|
|
|
private KEvent _friendInvitationStorageChannelEvent;
|
|
|
|
private KEvent _notificationStorageChannelEvent;
|
2019-09-20 06:42:32 +02:00
|
|
|
|
|
|
|
public IApplicationFunctions(Horizon system)
|
|
|
|
{
|
2020-11-21 23:38:34 +01:00
|
|
|
_gpuErrorDetectedSystemEvent = new KEvent(system.KernelContext);
|
2020-05-12 16:52:27 +02:00
|
|
|
_friendInvitationStorageChannelEvent = new KEvent(system.KernelContext);
|
2020-11-21 23:38:34 +01:00
|
|
|
_notificationStorageChannelEvent = 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)]
|
2020-09-21 05:45:30 +02:00
|
|
|
// PopLaunchParameter(LaunchParameterKind kind) -> 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
|
|
|
{
|
2020-09-21 05:45:30 +02:00
|
|
|
LaunchParameterKind kind = (LaunchParameterKind)context.RequestData.ReadUInt32();
|
|
|
|
|
|
|
|
byte[] storageData;
|
|
|
|
|
|
|
|
switch (kind)
|
|
|
|
{
|
|
|
|
case LaunchParameterKind.UserChannel:
|
|
|
|
storageData = context.Device.UserChannelPersistence.Pop();
|
|
|
|
break;
|
|
|
|
case LaunchParameterKind.PreselectedUser:
|
|
|
|
// Only the first 0x18 bytes of the Data seems to be actually used.
|
|
|
|
storageData = StorageHelper.MakeLaunchParams(context.Device.System.State.Account.LastOpenedUser);
|
|
|
|
break;
|
2020-09-23 23:57:18 +02:00
|
|
|
case LaunchParameterKind.Unknown:
|
|
|
|
throw new NotImplementedException("Unknown LaunchParameterKind.");
|
2020-09-21 05:45:30 +02:00
|
|
|
default:
|
2020-09-23 23:57:18 +02:00
|
|
|
return ResultCode.ObjectInvalid;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (storageData == null)
|
|
|
|
{
|
|
|
|
return ResultCode.NotAvailable;
|
2020-09-21 05:45:30 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
MakeObject(context, new AppletAE.IStorage(storageData));
|
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-11-21 23:38:34 +01:00
|
|
|
Uid userId = context.RequestData.ReadStruct<AccountUid>().ToLibHacUid();
|
2020-09-01 22:08:59 +02:00
|
|
|
ApplicationId applicationId = new ApplicationId(context.Process.TitleId);
|
2018-04-17 02:24:42 +02:00
|
|
|
|
2020-05-15 08:16:46 +02:00
|
|
|
BlitStruct<ApplicationControlProperty> controlHolder = context.Device.Application.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-09-01 22:08:59 +02:00
|
|
|
if (LibHac.Utilities.IsEmpty(controlHolder.ByteSpan))
|
2020-01-05 12:49:44 +01:00
|
|
|
{
|
|
|
|
// 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.
|
2020-11-21 23:38:34 +01:00
|
|
|
control.UserAccountSaveDataSize = 0x4000;
|
2020-01-05 12:49:44 +01:00
|
|
|
control.UserAccountSaveDataJournalSize = 0x4000;
|
|
|
|
|
2020-08-04 01:32:53 +02:00
|
|
|
Logger.Warning?.Print(LogClass.ServiceAm,
|
2020-01-05 12:49:44 +01:00
|
|
|
"No control file was found for this game. Using a dummy one instead. This may cause inaccuracies in some games.");
|
|
|
|
}
|
|
|
|
|
2020-11-21 23:38:34 +01:00
|
|
|
Result result = EnsureApplicationSaveData(context.Device.FileSystem.FsClient, out long requiredSize, applicationId, 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
|
|
|
{
|
2020-05-27 10:40:23 +02:00
|
|
|
// This seems to be calling ns:am GetApplicationDesiredLanguage followed by ConvertApplicationLanguageToLanguageCode
|
|
|
|
// Calls are from a IReadOnlyApplicationControlDataInterface object
|
|
|
|
// ConvertApplicationLanguageToLanguageCode compares language code strings and returns the index
|
|
|
|
// TODO: When above calls are implemented, switch to using ns:am
|
|
|
|
|
|
|
|
long desiredLanguageCode = context.Device.System.State.DesiredLanguageCode;
|
2020-11-21 23:38:34 +01:00
|
|
|
int supportedLanguages = (int)context.Device.Application.ControlData.Value.SupportedLanguages;
|
|
|
|
int firstSupported = BitOperations.TrailingZeroCount(supportedLanguages);
|
2020-05-27 10:40:23 +02:00
|
|
|
|
|
|
|
if (firstSupported > (int)SystemState.TitleLanguage.Chinese)
|
|
|
|
{
|
2020-08-04 01:32:53 +02:00
|
|
|
Logger.Warning?.Print(LogClass.ServiceAm, "Application has zero supported languages");
|
2020-05-27 10:40:23 +02:00
|
|
|
|
|
|
|
context.ResponseData.Write(desiredLanguageCode);
|
|
|
|
|
|
|
|
return ResultCode.Success;
|
|
|
|
}
|
|
|
|
|
|
|
|
// If desired language is not supported by application, use first supported language from TitleLanguage.
|
|
|
|
// TODO: In the future, a GUI could enable user-specified search priority
|
|
|
|
if (((1 << (int)context.Device.System.State.DesiredTitleLanguage) & supportedLanguages) == 0)
|
|
|
|
{
|
|
|
|
SystemLanguage newLanguage = Enum.Parse<SystemLanguage>(Enum.GetName(typeof(SystemState.TitleLanguage), firstSupported));
|
|
|
|
desiredLanguageCode = SystemStateMgr.GetLanguageCode((int)newLanguage);
|
|
|
|
|
2020-08-04 01:32:53 +02:00
|
|
|
Logger.Info?.Print(LogClass.ServiceAm, $"Application doesn't support configured language. Using {newLanguage}");
|
2020-05-27 10:40:23 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
context.ResponseData.Write(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-08-04 01:32:53 +02:00
|
|
|
Logger.Info?.Print(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
|
|
|
{
|
2020-05-27 10:22:50 +02:00
|
|
|
// This should work as DisplayVersion U8Span always gives a 0x10 size byte array.
|
|
|
|
// If an NACP isn't found, the buffer will be all '\0' which seems to be the correct implementation.
|
|
|
|
context.ResponseData.Write(context.Device.Application.ControlData.Value.DisplayVersion);
|
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();
|
2020-11-21 23:38:34 +01:00
|
|
|
|
2020-02-02 04:24:17 +01:00
|
|
|
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);
|
|
|
|
|
2020-08-04 01:32:53 +02:00
|
|
|
Logger.Stub?.PrintStub(LogClass.ServiceAm, new { saveDataType, userId });
|
2020-02-02 04:24:17 +01:00
|
|
|
|
|
|
|
return ResultCode.Success;
|
|
|
|
}
|
|
|
|
|
2020-09-20 05:40:10 +02:00
|
|
|
[Command(30)]
|
|
|
|
// BeginBlockingHomeButtonShortAndLongPressed()
|
|
|
|
public ResultCode BeginBlockingHomeButtonShortAndLongPressed(ServiceCtx context)
|
|
|
|
{
|
|
|
|
// NOTE: This set two internal fields at offsets 0x89 and 0x8B to value 1 then it signals an internal event.
|
|
|
|
|
|
|
|
Logger.Stub?.PrintStub(LogClass.ServiceAm);
|
|
|
|
|
|
|
|
return ResultCode.Success;
|
|
|
|
}
|
|
|
|
|
|
|
|
[Command(31)]
|
|
|
|
// EndBlockingHomeButtonShortAndLongPressed()
|
|
|
|
public ResultCode EndBlockingHomeButtonShortAndLongPressed(ServiceCtx context)
|
|
|
|
{
|
|
|
|
// NOTE: This set two internal fields at offsets 0x89 and 0x8B to value 0 then it signals an internal event.
|
|
|
|
|
|
|
|
Logger.Stub?.PrintStub(LogClass.ServiceAm);
|
|
|
|
|
|
|
|
return ResultCode.Success;
|
|
|
|
}
|
|
|
|
|
|
|
|
[Command(32)] // 2.0.0+
|
|
|
|
// BeginBlockingHomeButton(u64 nano_second)
|
|
|
|
public ResultCode BeginBlockingHomeButton(ServiceCtx context)
|
|
|
|
{
|
|
|
|
ulong nanoSeconds = context.RequestData.ReadUInt64();
|
|
|
|
|
|
|
|
// NOTE: This set two internal fields at offsets 0x89 to value 1 and 0x90 to value of "nanoSeconds" then it signals an internal event.
|
|
|
|
|
|
|
|
Logger.Stub?.PrintStub(LogClass.ServiceAm, new { nanoSeconds });
|
|
|
|
|
|
|
|
return ResultCode.Success;
|
|
|
|
}
|
|
|
|
|
|
|
|
[Command(33)] // 2.0.0+
|
|
|
|
// EndBlockingHomeButton()
|
|
|
|
public ResultCode EndBlockingHomeButton(ServiceCtx context)
|
|
|
|
{
|
|
|
|
// NOTE: This set two internal fields at offsets 0x89 and 0x90 to value 0 then it signals an internal event.
|
|
|
|
|
|
|
|
Logger.Stub?.PrintStub(LogClass.ServiceAm);
|
|
|
|
|
|
|
|
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
|
|
|
{
|
2020-07-22 06:56:00 +02:00
|
|
|
context.ResponseData.Write(true);
|
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
|
|
|
|
2020-08-04 01:32:53 +02:00
|
|
|
Logger.Stub?.PrintStub(LogClass.ServiceAm);
|
2019-11-15 01:25:22 +01:00
|
|
|
|
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
|
|
|
{
|
2020-08-04 01:32:53 +02:00
|
|
|
Logger.Stub?.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
|
|
|
|
2020-08-04 01:32:53 +02:00
|
|
|
Logger.Stub?.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-07-22 06:56:00 +02:00
|
|
|
[Command(90)] // 4.0.0+
|
|
|
|
// EnableApplicationCrashReport(u8)
|
|
|
|
public ResultCode EnableApplicationCrashReport(ServiceCtx context)
|
|
|
|
{
|
|
|
|
bool applicationCrashReportEnabled = context.RequestData.ReadBoolean();
|
|
|
|
|
2020-08-04 01:32:53 +02:00
|
|
|
Logger.Stub?.PrintStub(LogClass.ServiceAm, new { applicationCrashReportEnabled });
|
2020-07-22 06:56:00 +02:00
|
|
|
|
|
|
|
return ResultCode.Success;
|
|
|
|
}
|
|
|
|
|
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)
|
|
|
|
{
|
2020-11-21 23:38:34 +01:00
|
|
|
int width = context.RequestData.ReadInt32();
|
|
|
|
int height = context.RequestData.ReadInt32();
|
|
|
|
ulong transferMemorySize = context.RequestData.ReadUInt64();
|
|
|
|
int transferMemoryHandle = context.Request.HandleDesc.ToCopy[0];
|
2020-02-12 00:07:13 +01:00
|
|
|
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)
|
|
|
|
{
|
|
|
|
if ((transferMemorySize & 0x3FFFF) != 0)
|
|
|
|
{
|
|
|
|
return ResultCode.InvalidParameters;
|
|
|
|
}
|
|
|
|
|
2020-11-21 23:38:34 +01:00
|
|
|
ResultCode resultCode;
|
|
|
|
|
2020-02-12 00:07:13 +01:00
|
|
|
// if (_copyrightBuffer == null)
|
|
|
|
{
|
|
|
|
// TODO: Initialize buffer and object.
|
|
|
|
|
2020-08-04 01:32:53 +02:00
|
|
|
Logger.Stub?.PrintStub(LogClass.ServiceAm, new { transferMemoryAddress, transferMemorySize, width, height });
|
2020-02-12 00:07:13 +01:00
|
|
|
|
|
|
|
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)
|
|
|
|
{
|
2020-11-21 23:38:34 +01:00
|
|
|
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();
|
2020-02-12 00:07:13 +01:00
|
|
|
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);
|
|
|
|
|
2020-09-01 22:08:59 +02:00
|
|
|
if (result != ResultCode.Success)
|
2020-02-12 00:07:13 +01:00
|
|
|
{
|
|
|
|
resultCode = result;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
resultCode = ResultCode.Success;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-08-04 01:32:53 +02:00
|
|
|
Logger.Stub?.PrintStub(LogClass.ServiceAm, new { frameBufferPos, frameBufferSize, x, y, width, height, windowOriginMode });
|
2020-02-12 00:07:13 +01:00
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
*/
|
|
|
|
|
2020-08-04 01:32:53 +02:00
|
|
|
Logger.Stub?.PrintStub(LogClass.ServiceAm, new { x, y, width, height, frameBufferPos, frameBufferSize, windowOriginMode });
|
2020-02-12 00:07:13 +01:00
|
|
|
|
|
|
|
return ResultCode.Success;
|
|
|
|
}
|
|
|
|
|
|
|
|
[Command(102)] // 5.0.0+
|
|
|
|
// SetApplicationCopyrightVisibility(bool visible)
|
|
|
|
public ResultCode SetApplicationCopyrightVisibility(ServiceCtx context)
|
|
|
|
{
|
|
|
|
bool visible = context.RequestData.ReadBoolean();
|
|
|
|
|
2020-08-04 01:32:53 +02:00
|
|
|
Logger.Stub?.PrintStub(LogClass.ServiceAm, new { visible });
|
2020-02-12 00:07:13 +01:00
|
|
|
|
|
|
|
// 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);
|
|
|
|
}
|
|
|
|
|
2020-09-21 05:45:30 +02:00
|
|
|
[Command(120)] // 5.0.0+
|
|
|
|
// ExecuteProgram(ProgramSpecifyKind kind, u64 value)
|
|
|
|
public ResultCode ExecuteProgram(ServiceCtx context)
|
|
|
|
{
|
|
|
|
ProgramSpecifyKind kind = (ProgramSpecifyKind)context.RequestData.ReadUInt32();
|
|
|
|
|
|
|
|
// padding
|
|
|
|
context.RequestData.ReadUInt32();
|
|
|
|
|
|
|
|
ulong value = context.RequestData.ReadUInt64();
|
|
|
|
|
|
|
|
Logger.Stub?.PrintStub(LogClass.ServiceAm, new { kind, value });
|
|
|
|
|
|
|
|
context.Device.UiHandler.ExecuteProgram(context.Device, kind, value);
|
|
|
|
|
|
|
|
return ResultCode.Success;
|
|
|
|
}
|
|
|
|
|
|
|
|
[Command(121)] // 5.0.0+
|
|
|
|
// ClearUserChannel()
|
|
|
|
public ResultCode ClearUserChannel(ServiceCtx context)
|
|
|
|
{
|
|
|
|
context.Device.UserChannelPersistence.Clear();
|
|
|
|
|
|
|
|
return ResultCode.Success;
|
|
|
|
}
|
|
|
|
|
|
|
|
[Command(122)] // 5.0.0+
|
|
|
|
// UnpopToUserChannel(object<nn::am::service::IStorage> input_storage)
|
|
|
|
public ResultCode UnpopToUserChannel(ServiceCtx context)
|
|
|
|
{
|
|
|
|
AppletAE.IStorage data = GetObject<AppletAE.IStorage>(context, 0);
|
|
|
|
|
|
|
|
context.Device.UserChannelPersistence.Push(data.Data);
|
|
|
|
|
|
|
|
return ResultCode.Success;
|
|
|
|
}
|
|
|
|
|
2020-07-22 06:56:00 +02:00
|
|
|
[Command(123)] // 5.0.0+
|
|
|
|
// GetPreviousProgramIndex() -> s32 program_index
|
|
|
|
public ResultCode GetPreviousProgramIndex(ServiceCtx context)
|
|
|
|
{
|
2020-09-21 05:45:30 +02:00
|
|
|
int previousProgramIndex = context.Device.UserChannelPersistence.PreviousIndex;
|
2020-07-22 06:56:00 +02:00
|
|
|
|
|
|
|
context.ResponseData.Write(previousProgramIndex);
|
|
|
|
|
2020-08-04 01:32:53 +02:00
|
|
|
Logger.Stub?.PrintStub(LogClass.ServiceAm, new { previousProgramIndex });
|
2020-07-22 06:56:00 +02:00
|
|
|
|
|
|
|
return ResultCode.Success;
|
|
|
|
}
|
|
|
|
|
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;
|
|
|
|
}
|
2020-05-12 16:52:27 +02:00
|
|
|
|
|
|
|
[Command(140)] // 9.0.0+
|
|
|
|
// GetFriendInvitationStorageChannelEvent() -> handle<copy>
|
|
|
|
public ResultCode GetFriendInvitationStorageChannelEvent(ServiceCtx context)
|
|
|
|
{
|
|
|
|
if (context.Process.HandleTable.GenerateHandle(_friendInvitationStorageChannelEvent.ReadableEvent, out int friendInvitationStorageChannelEventHandle) != KernelResult.Success)
|
|
|
|
{
|
|
|
|
throw new InvalidOperationException("Out of handles!");
|
|
|
|
}
|
|
|
|
|
|
|
|
context.Response.HandleDesc = IpcHandleDesc.MakeCopy(friendInvitationStorageChannelEventHandle);
|
|
|
|
|
|
|
|
return ResultCode.Success;
|
|
|
|
}
|
|
|
|
|
2020-11-21 23:38:34 +01:00
|
|
|
[Command(141)] // 9.0.0+
|
|
|
|
// TryPopFromFriendInvitationStorageChannel() -> object<nn::am::service::IStorage>
|
|
|
|
public ResultCode TryPopFromFriendInvitationStorageChannel(ServiceCtx context)
|
|
|
|
{
|
|
|
|
// NOTE: IStorage are pushed in the channel with IApplicationAccessor PushToFriendInvitationStorageChannel
|
|
|
|
// If _friendInvitationStorageChannelEvent is signaled, the event is cleared.
|
|
|
|
// If an IStorage is available, returns it with ResultCode.Success.
|
|
|
|
// If not, just returns ResultCode.NotAvailable. Since we don't support friend feature for now, it's fine to do the same.
|
|
|
|
|
|
|
|
Logger.Stub?.PrintStub(LogClass.ServiceAm);
|
|
|
|
|
|
|
|
return ResultCode.NotAvailable;
|
|
|
|
}
|
|
|
|
|
2020-05-12 16:52:27 +02:00
|
|
|
[Command(150)] // 9.0.0+
|
|
|
|
// GetNotificationStorageChannelEvent() -> handle<copy>
|
|
|
|
public ResultCode GetNotificationStorageChannelEvent(ServiceCtx context)
|
|
|
|
{
|
|
|
|
if (context.Process.HandleTable.GenerateHandle(_notificationStorageChannelEvent.ReadableEvent, out int notificationStorageChannelEventHandle) != KernelResult.Success)
|
|
|
|
{
|
|
|
|
throw new InvalidOperationException("Out of handles!");
|
|
|
|
}
|
|
|
|
|
|
|
|
context.Response.HandleDesc = IpcHandleDesc.MakeCopy(notificationStorageChannelEventHandle);
|
|
|
|
|
|
|
|
return ResultCode.Success;
|
|
|
|
}
|
2018-02-05 00:08:20 +01:00
|
|
|
}
|
2019-07-12 03:13:43 +02:00
|
|
|
}
|