var ipcCommands = ipcService.Commands;

// Find the handler for the method called

var ipcCommandId = ipcHandler.Key;

var ipcMethod = ipcHandler.Value;

if (ipcMethod != null)

{

sb.AppendLine();

}

}

using Ryujinx.Common.Logging;

using Ryujinx.HLE.FileSystem;

using Ryujinx.HLE.HOS.Services.Arp;

using Ryujinx.HLE.HOS.SystemState;

using Ryujinx.HLE.Utilities;

private ApplicationLaunchProperty _applicationLaunchProperty;

// GetUserCount() -> i32

public long GetUserCount(ServiceCtx context)

{

return 0;

}

// GetUserExistence(nn::account::Uid) -> bool

public long GetUserExistence(ServiceCtx context)

{

return 0;

}

// ListAllUsers() -> array<nn::account::Uid, 0xa>

public long ListAllUsers(ServiceCtx context)

{

return WriteUserList(context, context.Device.System.State.Account.GetAllUsers());

}

// ListOpenUsers() -> array<nn::account::Uid, 0xa>

public long ListOpenUsers(ServiceCtx context)

{

return 0;

}

// GetLastOpenedUser() -> nn::account::Uid

public long GetLastOpenedUser(ServiceCtx context)

{

return 0;

}

// GetProfile(nn::account::Uid) -> object<nn::account::profile::IProfile>

public long GetProfile(ServiceCtx context)

{

return 0;

}

// IsUserRegistrationRequestPermitted(u64, pid) -> bool

public long IsUserRegistrationRequestPermitted(ServiceCtx context)

{

return 0;

}

// TrySelectUserWithoutInteraction(bool) -> nn::account::Uid

public long TrySelectUserWithoutInteraction(ServiceCtx context)

{

return 0;

}

// InitializeApplicationInfo(u64, pid)

// Both calls (100, 140) use the same submethod, maybe there's something different further along when arp:r is called?

public long InitializeApplicationInfo(ServiceCtx context)

return 0;

}

// GetBaasAccountManagerForApplication(nn::account::Uid) -> object<nn::account::baas::IManagerForApplication>

public long GetBaasAccountManagerForApplication(ServiceCtx context)

{

return 0;

}

// StoreSaveDataThumbnail(nn::account::Uid, buffer<bytes, 5>)

public long StoreSaveDataThumbnail(ServiceCtx context)

{

return 0;

}

// ClearSaveDataThumbnail(nn::account::Uid)

public long ClearSaveDataThumbnail(ServiceCtx context)

{

return 0;

}

// IsUserAccountSwitchLocked() -> bool

public long IsUserAccountSwitchLocked(ServiceCtx context)

{

using Ryujinx.Common.Logging;

using Ryujinx.HLE.HOS.Services.Arp;

using Ryujinx.HLE.Utilities;

namespace Ryujinx.HLE.HOS.Services.Acc

{

class IManagerForApplication : IpcService

{

private ApplicationLaunchProperty _applicationLaunchProperty;

public IManagerForApplication(UInt128 userId, ApplicationLaunchProperty applicationLaunchProperty)

{

_userId = userId;

_applicationLaunchProperty = applicationLaunchProperty;

}

// CheckAvailability()

public long CheckAvailability(ServiceCtx context)

{

return 0;

}

// GetAccountId() -> nn::account::NetworkServiceAccountId

public long GetAccountId(ServiceCtx context)

{

using ChocolArm64.Memory;

using Ryujinx.Common.Logging;

using Ryujinx.HLE.HOS.SystemState;

using Ryujinx.HLE.Utilities;

using System.IO;

using System.Reflection;

using System.Text;

{

class IProfile : IpcService

{

private UserProfile _profile;

public IProfile(UserProfile profile)

{

_profilePictureStream = Assembly.GetCallingAssembly().GetManifestResourceStream("Ryujinx.HLE.RyujinxProfileImage.jpg");

}

public long Get(ServiceCtx context)

{

Logger.PrintStub(LogClass.ServiceAcc);

return GetBase(context);

}

public long GetBase(ServiceCtx context)

{

_profile.UserId.Write(context.ResponseData);

return 0;

}

private long LoadImage(ServiceCtx context)

{

long bufferPosition = context.Request.ReceiveBuff[0].Position;

return 0;

}

}

} \ No newline at end of file

namespace Ryujinx.HLE.HOS.Services.Am

{

[Service("appletAE")]

class IAllSystemAppletProxiesService : IpcService

{

public long OpenSystemAppletProxy(ServiceCtx context)

{

MakeObject(context, new ISystemAppletProxy());

namespace Ryujinx.HLE.HOS.Services.Am

{

class IApplicationCreator : IpcService

{

}

} \ No newline at end of file

using Ryujinx.Common.Logging;

namespace Ryujinx.HLE.HOS.Services.Am

{

class IApplicationFunctions : IpcService

{

public long PopLaunchParameter(ServiceCtx context)

{

// Only the first 0x18 bytes of the Data seems to be actually used.

return 0;

}

public long EnsureSaveData(ServiceCtx context)

{

long uIdLow = context.RequestData.ReadInt64();

return 0;

}

public long GetDesiredLanguage(ServiceCtx context)

{

context.ResponseData.Write(context.Device.System.State.DesiredLanguageCode);

return 0;

}

public long SetTerminateResult(ServiceCtx context)

{

int errorCode = context.RequestData.ReadInt32();

return $"{(2000 + module):d4}-{description:d4}";

}

public long GetDisplayVersion(ServiceCtx context)

{

// FIXME: Need to check correct version on a switch.

return 0;

}

public long NotifyRunning(ServiceCtx context)

{

context.ResponseData.Write(1);

return 0;

}

public long GetPseudoDeviceId(ServiceCtx context)

{

Logger.PrintStub(LogClass.ServiceAm);

return 0;

}

public long InitializeGamePlayRecording(ServiceCtx context)

{

Logger.PrintStub(LogClass.ServiceAm);

return 0;

}

public long SetGamePlayRecordingState(ServiceCtx context)

{

int state = context.RequestData.ReadInt32();

return 0;

}

}

namespace Ryujinx.HLE.HOS.Services.Am

{

class IApplicationProxy : IpcService

{

public long GetCommonStateGetter(ServiceCtx context)

{

MakeObject(context, new ICommonStateGetter(context.Device.System));

return 0;

}

public long GetSelfController(ServiceCtx context)

{

MakeObject(context, new ISelfController(context.Device.System));

return 0;

}

public long GetWindowController(ServiceCtx context)

{

MakeObject(context, new IWindowController());

return 0;

}

public long GetAudioController(ServiceCtx context)

{

MakeObject(context, new IAudioController());

return 0;

}

public long GetDisplayController(ServiceCtx context)

{

MakeObject(context, new IDisplayController());

return 0;

}

public long GetLibraryAppletCreator(ServiceCtx context)

{

MakeObject(context, new ILibraryAppletCreator());

return 0;

}

public long GetApplicationFunctions(ServiceCtx context)

{

MakeObject(context, new IApplicationFunctions());

return 0;

}

public long GetDebugFunctions(ServiceCtx context)

{

MakeObject(context, new IDebugFunctions());

namespace Ryujinx.HLE.HOS.Services.Am

{

[Service("appletOE")]

class IApplicationProxyService : IpcService

{

public long OpenApplicationProxy(ServiceCtx context)

{

MakeObject(context, new IApplicationProxy());

using Ryujinx.Common.Logging;

namespace Ryujinx.HLE.HOS.Services.Am

{

class IAudioController : IpcService

{

public long SetExpectedMasterVolume(ServiceCtx context)

{

float appletVolume = context.RequestData.ReadSingle();

return 0;

}

public long GetMainAppletExpectedMasterVolume(ServiceCtx context)

{

context.ResponseData.Write(1f);

return 0;

}

public long GetLibraryAppletExpectedMasterVolume(ServiceCtx context)

{

context.ResponseData.Write(1f);

return 0;

}

public long ChangeMainAppletMasterVolume(ServiceCtx context)

{

float unknown0 = context.RequestData.ReadSingle();

return 0;

}

public long SetTransparentVolumeRate(ServiceCtx context)

{

float unknown0 = context.RequestData.ReadSingle();

return 0;

}

}

using Ryujinx.HLE.HOS.Kernel.Common;

using Ryujinx.HLE.HOS.Kernel.Threading;

using System;

using static Ryujinx.HLE.HOS.ErrorCode;

{

class ICommonStateGetter : IpcService

{

private KEvent _displayResolutionChangeEvent;

public ICommonStateGetter(Horizon system)

{

_displayResolutionChangeEvent = new KEvent(system);

}

public long GetEventHandle(ServiceCtx context)

{

KEvent Event = context.Device.System.AppletState.MessageEvent;

return 0;

}

public long ReceiveMessage(ServiceCtx context)

{

if (!context.Device.System.AppletState.TryDequeueMessage(out MessageInfo message))

return 0;

}

public long GetOperationMode(ServiceCtx context)

{

OperationMode mode = context.Device.System.State.DockedMode

return 0;

}

public long GetPerformanceMode(ServiceCtx context)

{

Apm.PerformanceMode mode = context.Device.System.State.DockedMode

return 0;

}

public long GetBootMode(ServiceCtx context)

{

context.ResponseData.Write((byte)0); //Unknown value.

return 0;

}

public long GetCurrentFocusState(ServiceCtx context)

{

context.ResponseData.Write((byte)context.Device.System.AppletState.FocusState);

return 0;

}

public long GetDefaultDisplayResolution(ServiceCtx context)

{

context.ResponseData.Write(1280);

return 0;

}

public long GetDefaultDisplayResolutionChangeEvent(ServiceCtx context)

{

if (context.Process.HandleTable.GenerateHandle(_displayResolutionChangeEvent.ReadableEvent, out int handle) != KernelResult.Success)

return 0;

}

}

namespace Ryujinx.HLE.HOS.Services.Am

{

class IDebugFunctions : IpcService

{

}

} \ No newline at end of file

namespace Ryujinx.HLE.HOS.Services.Am

{

class IDisplayController : IpcService

{

}

} \ No newline at end of file

namespace Ryujinx.HLE.HOS.Services.Am

{

class IGlobalStateController : IpcService

{

}

} \ No newline at end of file

using Ryujinx.HLE.HOS.Kernel.Common;

using Ryujinx.HLE.HOS.Kernel.Threading;

using System;

namespace Ryujinx.HLE.HOS.Services.Am

{

class IHomeMenuFunctions : IpcService

{

private KEvent _channelEvent;

public IHomeMenuFunctions(Horizon system)

{

// TODO: Signal this Event somewhere in future.

_channelEvent = new KEvent(system);

}

public long RequestToGetForeground(ServiceCtx context)

{

Logger.PrintStub(LogClass.ServiceAm);

return 0;

}

public long GetPopFromGeneralChannelEvent(ServiceCtx context)

{

if (context.Process.HandleTable.GenerateHandle(_channelEvent.ReadableEvent, out int handle) != KernelResult.Success)

return 0;

}

}

using Ryujinx.HLE.HOS.Kernel.Common;

using Ryujinx.HLE.HOS.Kernel.Threading;

using System;

namespace Ryujinx.HLE.HOS.Services.Am

{

class ILibraryAppletAccessor : IpcService

{

private KEvent _stateChangedEvent;

public ILibraryAppletAccessor(Horizon system)

{

_stateChangedEvent = new KEvent(system);

}

public long GetAppletStateChangedEvent(ServiceCtx context)

{

_stateChangedEvent.ReadableEvent.Signal();

return 0;

}

public long Start(ServiceCtx context)

{

Logger.PrintStub(LogClass.ServiceAm);

return 0;

}

public long GetResult(ServiceCtx context)

{

Logger.PrintStub(LogClass.ServiceAm);

return 0;

}

public long PushInData(ServiceCtx context)

{

Logger.PrintStub(LogClass.ServiceAm);

return 0;

}

public long PopOutData(ServiceCtx context)

{

MakeObject(context, new IStorage(StorageHelper.MakeLaunchParams()));

namespace Ryujinx.HLE.HOS.Services.Am

{

class ILibraryAppletCreator : IpcService

{

public long CreateLibraryApplet(ServiceCtx context)

{

MakeObject(context, new ILibraryAppletAccessor(context.Device.System));

return 0;

}

public long CreateStorage(ServiceCtx context)

{

long size = context.RequestData.ReadInt64();

using Ryujinx.HLE.HOS.Kernel.Common;

using Ryujinx.HLE.HOS.Kernel.Threading;

using System;

namespace Ryujinx.HLE.HOS.Services.Am

{

class ISelfController : IpcService

{

private KEvent _libraryAppletLaunchableEvent;

private KEvent _accumulatedSuspendedTickChangedEvent;

public ISelfController(Horizon system)

{

_libraryAppletLaunchableEvent = new KEvent(system);

}

public long Exit(ServiceCtx context)

{

Logger.PrintStub(LogClass.ServiceAm);

return 0;

}

public long LockExit(ServiceCtx context)

{

Logger.PrintStub(LogClass.ServiceAm);

return 0;

}

public long UnlockExit(ServiceCtx context)

{

Logger.PrintStub(LogClass.ServiceAm);

return 0;

}

public long GetLibraryAppletLaunchableEvent(ServiceCtx context)

{

_libraryAppletLaunchableEvent.ReadableEvent.Signal();

return 0;

}

public long SetScreenShotPermission(ServiceCtx context)

{

bool enable = context.RequestData.ReadByte() != 0;

return 0;

}

public long SetOperationModeChangedNotification(ServiceCtx context)

{

bool enable = context.RequestData.ReadByte() != 0;

return 0;

}

public long SetPerformanceModeChangedNotification(ServiceCtx context)

{

bool enable = context.RequestData.ReadByte() != 0;

return 0;

}

public long SetFocusHandlingMode(ServiceCtx context)

{

bool flag1 = context.RequestData.ReadByte() != 0;

return 0;

}

public long SetRestartMessageEnabled(ServiceCtx context)

{

bool enable = context.RequestData.ReadByte() != 0;

return 0;

}

public long SetOutOfFocusSuspendingEnabled(ServiceCtx context)

{

bool enable = context.RequestData.ReadByte() != 0;

return 0;

}

public long SetScreenShotImageOrientation(ServiceCtx context)

{

int orientation = context.RequestData.ReadInt32();

return 0;

}

public long SetHandlesRequestToDisplay(ServiceCtx context)

{

bool enable = context.RequestData.ReadByte() != 0;

return 0;

}

// SetIdleTimeDetectionExtension(u32)

public long SetIdleTimeDetectionExtension(ServiceCtx context)

{

return 0;

}

// GetIdleTimeDetectionExtension() -> u32

public long GetIdleTimeDetectionExtension(ServiceCtx context)

{

return 0;

}

// GetAccumulatedSuspendedTickChangedEvent() -> handle<copy>

public long GetAccumulatedSuspendedTickChangedEvent(ServiceCtx context)

{

return 0;

}

}

namespace Ryujinx.HLE.HOS.Services.Am

{

class IStorage : IpcService

{

public byte[] Data { get; private set; }

public IStorage(byte[] data)

{

Data = data;

}

public long Open(ServiceCtx context)

{

MakeObject(context, new IStorageAccessor(this));

using System;

namespace Ryujinx.HLE.HOS.Services.Am

{

class IStorageAccessor : IpcService

{

private IStorage _storage;

public IStorageAccessor(IStorage storage)

{

_storage = storage;

}

public long GetSize(ServiceCtx context)

{

context.ResponseData.Write((long)_storage.Data.Length);

return 0;

}

public long Write(ServiceCtx context)

{

// TODO: Error conditions.

return 0;

}

public long Read(ServiceCtx context)

{

// TODO: Error conditions.

namespace Ryujinx.HLE.HOS.Services.Am

{

class ISystemAppletProxy : IpcService

{

public long GetCommonStateGetter(ServiceCtx context)

{

MakeObject(context, new ICommonStateGetter(context.Device.System));

return 0;

}

public long GetSelfController(ServiceCtx context)

{

MakeObject(context, new ISelfController(context.Device.System));

return 0;

}

public long GetWindowController(ServiceCtx context)

{

MakeObject(context, new IWindowController());

return 0;

}

public long GetAudioController(ServiceCtx context)

{

MakeObject(context, new IAudioController());

return 0;

}

public long GetDisplayController(ServiceCtx context)

{

MakeObject(context, new IDisplayController());

return 0;

}

public long GetLibraryAppletCreator(ServiceCtx context)

{

MakeObject(context, new ILibraryAppletCreator());

return 0;

}

public long GetHomeMenuFunctions(ServiceCtx context)

{

MakeObject(context, new IHomeMenuFunctions(context.Device.System));

return 0;

}

public long GetGlobalStateController(ServiceCtx context)

{

MakeObject(context, new IGlobalStateController());

return 0;

}

public long GetApplicationCreator(ServiceCtx context)

{

MakeObject(context, new IApplicationCreator());

return 0;

}

public long GetDebugFunctions(ServiceCtx context)

{

MakeObject(context, new IDebugFunctions());

using Ryujinx.Common.Logging;

namespace Ryujinx.HLE.HOS.Services.Am

{

class IWindowController : IpcService

{

public long GetAppletResourceUserId(ServiceCtx context)

{

Logger.PrintStub(LogClass.ServiceAm);

return 0;

}

public long AcquireForegroundRights(ServiceCtx context)

{

Logger.PrintStub(LogClass.ServiceAm);

namespace Ryujinx.HLE.HOS.Services.Apm

{

[Service("apm")]

[Service("apm:p")]

class IManager : IpcService

{

public long OpenSession(ServiceCtx context)

{

MakeObject(context, new ISession());

using Ryujinx.Common.Logging;

namespace Ryujinx.HLE.HOS.Services.Apm

{

class ISession : IpcService

{

public long SetPerformanceConfiguration(ServiceCtx context)

{

PerformanceMode perfMode = (PerformanceMode)context.RequestData.ReadInt32();

return 0;

}

public long GetPerformanceConfiguration(ServiceCtx context)

{

PerformanceMode perfMode = (PerformanceMode)context.RequestData.ReadInt32();

using Ryujinx.HLE.HOS.Kernel.Common;

using Ryujinx.HLE.HOS.Kernel.Threading;

using System;

namespace Ryujinx.HLE.HOS.Services.Aud.AudioOut

{

class IAudioOut : IpcService, IDisposable

{

private IAalOutput _audioOut;

public IAudioOut(IAalOutput audioOut, KEvent releaseEvent, int track)

{

_audioOut = audioOut;

_releaseEvent = releaseEvent;

_track = track;

}

public long GetAudioOutState(ServiceCtx context)

{

context.ResponseData.Write((int)_audioOut.GetState(_track));

return 0;

}

public long StartAudioOut(ServiceCtx context)

{

_audioOut.Start(_track);

return 0;

}

public long StopAudioOut(ServiceCtx context)

{

_audioOut.Stop(_track);

return 0;

}

public long AppendAudioOutBuffer(ServiceCtx context)

{

return AppendAudioOutBufferImpl(context, context.Request.SendBuff[0].Position);

}

public long RegisterBufferEvent(ServiceCtx context)

{

if (context.Process.HandleTable.GenerateHandle(_releaseEvent.ReadableEvent, out int handle) != KernelResult.Success)

return 0;

}

public long GetReleasedAudioOutBuffer(ServiceCtx context)

{

long position = context.Request.ReceiveBuff[0].Position;

return GetReleasedAudioOutBufferImpl(context, position, size);

}

public long ContainsAudioOutBuffer(ServiceCtx context)

{

long tag = context.RequestData.ReadInt64();

return 0;

}

public long AppendAudioOutBufferAuto(ServiceCtx context)

{

(long position, long size) = context.Request.GetBufferType0x21();

return 0;

}

public long GetReleasedAudioOutBufferAuto(ServiceCtx context)

{

(long position, long size) = context.Request.GetBufferType0x22();

}

}

}

using Ryujinx.HLE.HOS.Kernel.Threading;

using Ryujinx.HLE.Utilities;

using System;

using System.Runtime.InteropServices;

using System.Runtime.Intrinsics;

using System.Runtime.Intrinsics.X86;

// high latency).

private const int MixBufferSamplesCount = 960;

private KEvent _updateEvent;

private MemoryManager _memory;

IAalOutput audioOut,

AudioRendererParameter Params)

{

_updateEvent = new KEvent(system);

_memory = memory;

_playState = PlayState.Stopped;

}

public long GetSampleRate(ServiceCtx context)

{

context.ResponseData.Write(_params.SampleRate);

return 0;

}

public long GetSampleCount(ServiceCtx context)

{

context.ResponseData.Write(_params.SampleCount);

return 0;

}

// GetMixBufferCount() -> u32

public long GetMixBufferCount(ServiceCtx context)

{

return 0;

}

// GetState() -> u32

private long GetState(ServiceCtx context)

{

_audioOut.Start(_track);

}

public long RequestUpdateAudioRenderer(ServiceCtx context)

{

long outputPosition = context.Request.ReceiveBuff[0].Position;

return 0;

}

public long StartAudioRenderer(ServiceCtx context)

{

Logger.PrintStub(LogClass.ServiceAudio);

return 0;

}

public long StopAudioRenderer(ServiceCtx context)

{

Logger.PrintStub(LogClass.ServiceAudio);

return 0;

}

public long QuerySystemEvent(ServiceCtx context)

{

if (context.Process.HandleTable.GenerateHandle(_updateEvent.ReadableEvent, out int handle) != KernelResult.Success)

}

}

}

using Ryujinx.HLE.HOS.Kernel.Threading;

using Ryujinx.HLE.HOS.SystemState;

using System;

using System.Text;

namespace Ryujinx.HLE.HOS.Services.Aud

{

class IAudioDevice : IpcService

{

private KEvent _systemEvent;

public IAudioDevice(Horizon system)

{

_systemEvent = new KEvent(system);

// TODO: We shouldn't be signaling this here.

_systemEvent.ReadableEvent.Signal();

}

public long ListAudioDeviceName(ServiceCtx context)

{

string[] deviceNames = SystemStateMgr.AudioOutputs;

return 0;

}

public long SetAudioDeviceOutputVolume(ServiceCtx context)

{

float volume = context.RequestData.ReadSingle();

return 0;

}

public long GetActiveAudioDeviceName(ServiceCtx context)

{

string name = context.Device.System.State.ActiveAudioOutput;

return 0;

}

public long QueryAudioDeviceSystemEvent(ServiceCtx context)

{

if (context.Process.HandleTable.GenerateHandle(_systemEvent.ReadableEvent, out int handle) != KernelResult.Success)

return 0;

}

public long GetActiveChannelCount(ServiceCtx context)

{

context.ResponseData.Write(2);

return 0;

}

public long ListAudioDeviceNameAuto(ServiceCtx context)

{

string[] deviceNames = SystemStateMgr.AudioOutputs;

return 0;

}

public long SetAudioDeviceOutputVolumeAuto(ServiceCtx context)

{

float volume = context.RequestData.ReadSingle();

return 0;

}

public long GetAudioDeviceOutputVolumeAuto(ServiceCtx context)

{

context.ResponseData.Write(1f);

return 0;

}

public long GetActiveAudioDeviceNameAuto(ServiceCtx context)

{

string name = context.Device.System.State.ActiveAudioOutput;

return 0;

}

public long QueryAudioDeviceInputEvent(ServiceCtx context)

{

if (context.Process.HandleTable.GenerateHandle(_systemEvent.ReadableEvent, out int handle) != KernelResult.Success)

return 0;

}

public long QueryAudioDeviceOutputEvent(ServiceCtx context)

{

if (context.Process.HandleTable.GenerateHandle(_systemEvent.ReadableEvent, out int handle) != KernelResult.Success)

return 0;

}

}

using ChocolArm64.Memory;

using Ryujinx.Audio;

using Ryujinx.Common.Logging;

using Ryujinx.HLE.HOS.Kernel.Threading;

using Ryujinx.HLE.HOS.Services.Aud.AudioOut;

using System.Text;

using static Ryujinx.HLE.HOS.ErrorCode;

[Service("audout:u")]

class IAudioOutManager : IpcService

{

public long ListAudioOuts(ServiceCtx context)

{

return ListAudioOutsImpl(

context.Request.ReceiveBuff[0].Size);

}

public long OpenAudioOut(ServiceCtx context)

{

return OpenAudioOutImpl(

context.Request.ReceiveBuff[0].Size);

}

public long ListAudioOutsAuto(ServiceCtx context)

{

(long recvPosition, long recvSize) = context.Request.GetBufferType0x22();

return ListAudioOutsImpl(context, recvPosition, recvSize);

}

public long OpenAudioOutAuto(ServiceCtx context)

{

(long sendPosition, long sendSize) = context.Request.GetBufferType0x21();

return 0;

}

}

using Ryujinx.Audio;

using Ryujinx.Common.Logging;

using Ryujinx.HLE.HOS.Services.Aud.AudioRenderer;

using Ryujinx.HLE.Utilities;

using static Ryujinx.HLE.HOS.ErrorCode;

public const int RevMagic = Rev0Magic + (Rev << 24);

public long OpenAudioRenderer(ServiceCtx context)

{

IAalOutput audioOut = context.Device.AudioOut;

return 0;

}

public long GetAudioRendererWorkBufferSize(ServiceCtx context)

{

AudioRendererParameter Params = GetAudioRendererParameter(context);

return result / 8;

}

// GetAudioDeviceService(nn::applet::AppletResourceUserId) -> object<nn::audio::detail::IAudioDevice>

public long GetAudioDeviceService(ServiceCtx context)

{

return 0;

}

// GetAudioDeviceServiceWithRevisionInfo(nn::applet::AppletResourceUserId, u32) -> object<nn::audio::detail::IAudioDevice>

private long GetAudioDeviceServiceWithRevisionInfo(ServiceCtx context)

{

using Concentus.Structs;

using static Ryujinx.HLE.HOS.ErrorCode;

{

private const int FixedSampleRate = 48000;

private int _sampleRate;

private int _channelsCount;

public IHardwareOpusDecoder(int sampleRate, int channelsCount)

{

_sampleRate = sampleRate;

_channelsCount = channelsCount;

_decoder = new OpusDecoder(FixedSampleRate, channelsCount);

}

public long DecodeInterleaved(ServiceCtx context)

{

long inPosition = context.Request.SendBuff[0].Position;

return 0;

}

}

namespace Ryujinx.HLE.HOS.Services.Aud

{

[Service("hwopus")]

class IHardwareOpusDecoderManager : IpcService

{

public long Initialize(ServiceCtx context)

{

int sampleRate = context.RequestData.ReadInt32();

return 0;

}

public long GetWorkBufferSize(ServiceCtx context)

{

// Note: The sample rate is ignored because it is fixed to 48KHz.

celtSigSize;

}

}

namespace Ryujinx.HLE.HOS.Services.Bcat

{

class IBcatService : IpcService

{

}

namespace Ryujinx.HLE.HOS.Services.Bcat

{

class IDeliveryCacheStorageService : IpcService

{

}

namespace Ryujinx.HLE.HOS.Services.Bcat

{

[Service("bcat:a")]

[Service("bcat:s")]

class IServiceCreator : IpcService

{

public long CreateBcatService(ServiceCtx context)

{

long id = context.RequestData.ReadInt64();

return 0;

}

public long CreateDeliveryCacheStorageService(ServiceCtx context)

{

long id = context.RequestData.ReadInt64();

using Ryujinx.Common.Logging;

using Ryujinx.HLE.Utilities;

using System.Collections.Generic;

using System.Net;

private List<BsdSocket> _sockets = new List<BsdSocket>();

public IClient(ServiceCtx context, bool isPrivileged)

{

_isPrivileged = isPrivileged;

}

private LinuxError ConvertError(WsaError errorCode)

{

{

errno = (LinuxError)errorCode;

}

WriteSockAddr(context, bufferPosition, endPoint);

}

// Initialize(nn::socket::BsdBufferConfig config, u64 pid, u64 transferMemorySize, KObject<copy, transfer_memory>, pid) -> u32 bsd_errno

public long RegisterClient(ServiceCtx context)

{

return 0;

}

// StartMonitoring(u64, pid)

public long StartMonitoring(ServiceCtx context)

{

return 0;

}

// Socket(u32 domain, u32 type, u32 protocol) -> (i32 ret, u32 bsd_errno)

public long Socket(ServiceCtx context)

{

return SocketInternal(context, false);

}

// SocketExempt(u32 domain, u32 type, u32 protocol) -> (i32 ret, u32 bsd_errno)

public long SocketExempt(ServiceCtx context)

{

return SocketInternal(context, true);

}

// Open(u32 flags, array<unknown, 0x21> path) -> (i32 ret, u32 bsd_errno)

public long Open(ServiceCtx context)

{

return 0;

}

// Select(u32 nfds, nn::socket::timeout timeout, buffer<nn::socket::fd_set, 0x21, 0> readfds_in, buffer<nn::socket::fd_set, 0x21, 0> writefds_in, buffer<nn::socket::fd_set, 0x21, 0> errorfds_in) -> (i32 ret, u32 bsd_errno, buffer<nn::socket::fd_set, 0x22, 0> readfds_out, buffer<nn::socket::fd_set, 0x22, 0> writefds_out, buffer<nn::socket::fd_set, 0x22, 0> errorfds_out)

public long Select(ServiceCtx context)

{

return 0;

}

// Poll(u32 nfds, u32 timeout, buffer<unknown, 0x21, 0> fds) -> (i32 ret, u32 bsd_errno, buffer<unknown, 0x22, 0>)

public long Poll(ServiceCtx context)

{

return WriteBsdResult(context, readEvents.Count + writeEvents.Count + errorEvents.Count, LinuxError.SUCCESS);

}

// Sysctl(buffer<unknown, 0x21, 0>, buffer<unknown, 0x21, 0>) -> (i32 ret, u32 bsd_errno, u32, buffer<unknown, 0x22, 0>)

public long Sysctl(ServiceCtx context)

{

return 0;

}

// Recv(u32 socket, u32 flags) -> (i32 ret, u32 bsd_errno, array<i8, 0x22> message)

public long Recv(ServiceCtx context)

{

return WriteBsdResult(context, result, errno);

}

// RecvFrom(u32 sock, u32 flags) -> (i32 ret, u32 bsd_errno, u32 addrlen, buffer<i8, 0x22, 0> message, buffer<nn::socket::sockaddr_in, 0x22, 0x10>)

public long RecvFrom(ServiceCtx context)

{

return WriteBsdResult(context, result, errno);

}

// Send(u32 socket, u32 flags, buffer<i8, 0x21, 0>) -> (i32 ret, u32 bsd_errno)

public long Send(ServiceCtx context)

{

return WriteBsdResult(context, result, errno);

}

// SendTo(u32 socket, u32 flags, buffer<i8, 0x21, 0>, buffer<nn::socket::sockaddr_in, 0x21, 0x10>) -> (i32 ret, u32 bsd_errno)

public long SendTo(ServiceCtx context)

{

return WriteBsdResult(context, result, errno);

}

// Accept(u32 socket) -> (i32 ret, u32 bsd_errno, u32 addrlen, buffer<nn::socket::sockaddr_in, 0x22, 0x10> addr)

public long Accept(ServiceCtx context)

{

return WriteBsdResult(context, -1, errno);

}

// Bind(u32 socket, buffer<nn::socket::sockaddr_in, 0x21, 0x10> addr) -> (i32 ret, u32 bsd_errno)

public long Bind(ServiceCtx context)

{

return WriteBsdResult(context, 0, errno);

}

// Connect(u32 socket, buffer<nn::socket::sockaddr_in, 0x21, 0x10>) -> (i32 ret, u32 bsd_errno)

public long Connect(ServiceCtx context)

{

return WriteBsdResult(context, 0, errno);

}

// GetPeerName(u32 socket) -> (i32 ret, u32 bsd_errno, u32 addrlen, buffer<nn::socket::sockaddr_in, 0x22, 0x10> addr)

public long GetPeerName(ServiceCtx context)

{

return WriteBsdResult(context, 0, errno);

}

// GetSockName(u32 socket) -> (i32 ret, u32 bsd_errno, u32 addrlen, buffer<nn::socket::sockaddr_in, 0x22, 0x10> addr)

public long GetSockName(ServiceCtx context)

{

return WriteBsdResult(context, 0, errno);

}

// GetSockOpt(u32 socket, u32 level, u32 option_name) -> (i32 ret, u32 bsd_errno, u32, buffer<unknown, 0x22, 0>)

public long GetSockOpt(ServiceCtx context)

{

return WriteBsdResult(context, 0, errno);

}

// Listen(u32 socket, u32 backlog) -> (i32 ret, u32 bsd_errno)

public long Listen(ServiceCtx context)

{

return WriteBsdResult(context, 0, errno);

}

// Ioctl(u32 fd, u32 request, u32 bufcount, buffer<unknown, 0x21, 0>, buffer<unknown, 0x21, 0>, buffer<unknown, 0x21, 0>, buffer<unknown, 0x21, 0>) -> (i32 ret, u32 bsd_errno, buffer<unknown, 0x22, 0>, buffer<unknown, 0x22, 0>, buffer<unknown, 0x22, 0>, buffer<unknown, 0x22, 0>)

public long Ioctl(ServiceCtx context)

{

return WriteBsdResult(context, 0, errno);

}

// Fcntl(u32 socket, u32 cmd, u32 arg) -> (i32 ret, u32 bsd_errno)

public long Fcntl(ServiceCtx context)

{

}

}

// SetSockOpt(u32 socket, u32 level, u32 option_name, buffer<unknown, 0x21, 0> option_value) -> (i32 ret, u32 bsd_errno)

public long SetSockOpt(ServiceCtx context)

{

return WriteBsdResult(context, 0, errno);

}

// Shutdown(u32 socket, u32 how) -> (i32 ret, u32 bsd_errno)

public long Shutdown(ServiceCtx context)

{

return WriteBsdResult(context, 0, errno);

}

// ShutdownAllSockets(u32 how) -> (i32 ret, u32 bsd_errno)

public long ShutdownAllSockets(ServiceCtx context)

{

return WriteBsdResult(context, 0, errno);

}

// Write(u32 socket, buffer<i8, 0x21, 0> message) -> (i32 ret, u32 bsd_errno)

public long Write(ServiceCtx context)

{

return WriteBsdResult(context, result, errno);

}

// Read(u32 socket) -> (i32 ret, u32 bsd_errno, buffer<i8, 0x22, 0> message)

public long Read(ServiceCtx context)

{

return WriteBsdResult(context, result, errno);

}

// Close(u32 socket) -> (i32 ret, u32 bsd_errno)

public long Close(ServiceCtx context)

{

return WriteBsdResult(context, 0, errno);

}

// DuplicateSocket(u32 socket, u64 reserved) -> (i32 ret, u32 bsd_errno)

public long DuplicateSocket(ServiceCtx context)

{

return WriteBsdResult(context, newSockFd, errno);

}

}

namespace Ryujinx.HLE.HOS.Services.Caps

{

[Service("caps:a")]

class IAlbumAccessorService : IpcService

{

}

} \ No newline at end of file

namespace Ryujinx.HLE.HOS.Services.Caps

{

[Service("caps:ss")]

class IScreenshotService : IpcService

{

}

} \ No newline at end of file

{

class DummyService : IpcService

{

public string ServiceName { get; set; }

public DummyService(string serviceName)

{

ServiceName = serviceName;

}

}

{

[Service("es")]

class IeTicketService : IpcService

{

}

} \ No newline at end of file

namespace Ryujinx.HLE.HOS.Services.Friend

{

class IDaemonSuspendSessionService : IpcService

{

private FriendServicePermissionLevel PermissionLevel;

public IDaemonSuspendSessionService(FriendServicePermissionLevel permissionLevel)

{

PermissionLevel = permissionLevel;

}

}

using Ryujinx.Common;

using Ryujinx.Common.Logging;

using Ryujinx.HLE.HOS.SystemState;

using Ryujinx.HLE.Utilities;

using System.IO;

using System.Runtime.InteropServices;

{

class IFriendService : IpcService

{

private FriendServicePermissionLevel _permissionLevel;

public IFriendService(FriendServicePermissionLevel permissionLevel)

{

_permissionLevel = permissionLevel;

}

public long GetFriendListIds(ServiceCtx context)

{

int offset = context.RequestData.ReadInt32();

return 0;

}

public long GetFriendList(ServiceCtx context)

{

int offset = context.RequestData.ReadInt32();

return 0;

}

// nn::friends::DeclareOpenOnlinePlaySession(nn::account::Uid)

public long DeclareOpenOnlinePlaySession(ServiceCtx context)

{

return 0;

}

// nn::friends::DeclareCloseOnlinePlaySession(nn::account::Uid)

public long DeclareCloseOnlinePlaySession(ServiceCtx context)

{

return 0;

}

// nn::friends::UpdateUserPresence(nn::account::Uid, u64, pid, buffer<nn::friends::detail::UserPresenceImpl, 0x19>)

public long UpdateUserPresence(ServiceCtx context)

{

return 0;

}

}

private KEvent _notificationEvent;

private int _notificationEventHandle = 0;

private LinkedList<NotificationInfo> _notifications;

private bool _hasNewFriendRequest;

private bool _hasFriendListUpdate;

public INotificationService(ServiceCtx context, UInt128 userId, FriendServicePermissionLevel permissionLevel)

{

_userId = userId;

_permissionLevel = permissionLevel;

_notifications = new LinkedList<NotificationInfo>();

NotificationEventHandler.Instance.RegisterNotificationService(this);

}

// nn::friends::detail::ipc::INotificationService::GetEvent() -> handle<copy>

public long GetEvent(ServiceCtx context)

{

return 0;

}

// nn::friends::detail::ipc::INotificationService::Clear()

public long Clear(ServiceCtx context)

{

return 0;

}

// nn::friends::detail::ipc::INotificationService::Pop() -> nn::friends::detail::ipc::SizedNotificationInfo

public long Pop(ServiceCtx context)

{

using Ryujinx.Common;

using Ryujinx.HLE.Utilities;

using static Ryujinx.HLE.HOS.ErrorCode;

{

private FriendServicePermissionLevel _permissionLevel;

public IServiceCreator(ServiceCtx context, FriendServicePermissionLevel permissionLevel)

{

_permissionLevel = permissionLevel;

}

// CreateFriendService() -> object<nn::friends::detail::ipc::IFriendService>

public long CreateFriendService(ServiceCtx context)

{

return 0;

}

// CreateNotificationService(nn::account::Uid) -> object<nn::friends::detail::ipc::INotificationService>

public long CreateNotificationService(ServiceCtx context)

{

return 0;

}

// CreateDaemonSuspendSessionService() -> object<nn::friends::detail::ipc::IDaemonSuspendSessionService>

public long CreateDaemonSuspendSessionService(ServiceCtx context)

{

return 0;

}

}

using LibHac;

using System.Collections.Generic;

using System.Text;

{

private const int DirectoryEntrySize = 0x310;

private IEnumerator<LibHac.Fs.DirectoryEntry> _enumerator;

private LibHac.Fs.IDirectory _baseDirectory;

public IDirectory(LibHac.Fs.IDirectory directory)

{

_baseDirectory = directory;

}

// Read() -> (u64 count, buffer<nn::fssrv::sf::IDirectoryEntry, 6, 0> entries)

public long Read(ServiceCtx context)

{

context.Memory.WriteInt64(position + 0x308, entry.Size);

}

// GetEntryCount() -> u64

public long GetEntryCount(ServiceCtx context)

{

using LibHac;

using LibHac.Fs;

using System;

namespace Ryujinx.HLE.HOS.Services.FspSrv

{

class IFile : IpcService, IDisposable

{

private LibHac.Fs.IFile _baseFile;

public IFile(LibHac.Fs.IFile baseFile)

{

_baseFile = baseFile;

}

// Read(u32 readOption, u64 offset, u64 size) -> (u64 out_size, buffer<u8, 0x46, 0> out_buf)

public long Read(ServiceCtx context)

{

return 0;

}

// Write(u32 writeOption, u64 offset, u64 size, buffer<u8, 0x45, 0>)

public long Write(ServiceCtx context)

{

return 0;

}

// Flush()

public long Flush(ServiceCtx context)

{

return 0;

}

// SetSize(u64 size)

public long SetSize(ServiceCtx context)

{

return 0;

}

// GetSize() -> u64 fileSize

public long GetSize(ServiceCtx context)

{

using LibHac;

using LibHac.Fs;

using static Ryujinx.HLE.HOS.ErrorCode;

using static Ryujinx.HLE.Utilities.StringUtils;

{

class IFileSystem : IpcService

{

private LibHac.Fs.IFileSystem _fileSystem;

public IFileSystem(LibHac.Fs.IFileSystem provider)

{

_fileSystem = provider;

}

// CreateFile(u32 createOption, u64 size, buffer<bytes<0x301>, 0x19, 0x301> path)

public long CreateFile(ServiceCtx context)

{

return 0;

}

// DeleteFile(buffer<bytes<0x301>, 0x19, 0x301> path)

public long DeleteFile(ServiceCtx context)

{

return 0;

}

// CreateDirectory(buffer<bytes<0x301>, 0x19, 0x301> path)

public long CreateDirectory(ServiceCtx context)

{

return 0;

}

// DeleteDirectory(buffer<bytes<0x301>, 0x19, 0x301> path)

public long DeleteDirectory(ServiceCtx context)

{

return 0;

}

// DeleteDirectoryRecursively(buffer<bytes<0x301>, 0x19, 0x301> path)

public long DeleteDirectoryRecursively(ServiceCtx context)

{

return 0;

}

// RenameFile(buffer<bytes<0x301>, 0x19, 0x301> oldPath, buffer<bytes<0x301>, 0x19, 0x301> newPath)

public long RenameFile(ServiceCtx context)

{

return 0;

}

// RenameDirectory(buffer<bytes<0x301>, 0x19, 0x301> oldPath, buffer<bytes<0x301>, 0x19, 0x301> newPath)

public long RenameDirectory(ServiceCtx context)

{

return 0;

}

// GetEntryType(buffer<bytes<0x301>, 0x19, 0x301> path) -> nn::fssrv::sf::DirectoryEntryType

public long GetEntryType(ServiceCtx context)

{

return 0;

}

// OpenFile(u32 mode, buffer<bytes<0x301>, 0x19, 0x301> path) -> object<nn::fssrv::sf::IFile> file

public long OpenFile(ServiceCtx context)

{

return 0;

}

// OpenDirectory(u32 filter_flags, buffer<bytes<0x301>, 0x19, 0x301> path) -> object<nn::fssrv::sf::IDirectory> directory

public long OpenDirectory(ServiceCtx context)

{

return 0;

}

// Commit()

public long Commit(ServiceCtx context)

{

return 0;

}

// GetFreeSpaceSize(buffer<bytes<0x301>, 0x19, 0x301> path) -> u64 totalFreeSpace

public long GetFreeSpaceSize(ServiceCtx context)

{

return 0;

}

// GetTotalSpaceSize(buffer<bytes<0x301>, 0x19, 0x301> path) -> u64 totalSize

public long GetTotalSpaceSize(ServiceCtx context)

{

return 0;

}

// CleanDirectoryRecursively(buffer<bytes<0x301>, 0x19, 0x301> path)

public long CleanDirectoryRecursively(ServiceCtx context)

{

return 0;

}

// GetFileTimeStampRaw(buffer<bytes<0x301>, 0x19, 0x301> path) -> bytes<0x20> timestamp

public long GetFileTimeStampRaw(ServiceCtx context)

{

using Ryujinx.Common;

using Ryujinx.Common.Logging;

using Ryujinx.HLE.FileSystem;

using Ryujinx.HLE.Utilities;

using System.IO;

using static Ryujinx.HLE.FileSystem.VirtualFileSystem;

[Service("fsp-srv")]

class IFileSystemProxy : IpcService

{

// Initialize(u64, pid)

public long Initialize(ServiceCtx context)

{

return 0;

}

// OpenFileSystemWithId(nn::fssrv::sf::FileSystemType filesystem_type, nn::ApplicationId tid, buffer<bytes<0x301>, 0x19, 0x301> path)

// -> object<nn::fssrv::sf::IFileSystem> contentFs

public long OpenFileSystemWithId(ServiceCtx context)

return MakeError(ErrorModule.Fs, FsErr.InvalidInput);

}

// OpenBisFileSystem(nn::fssrv::sf::Partition partitionID, buffer<bytes<0x301>, 0x19, 0x301>) -> object<nn::fssrv::sf::IFileSystem> Bis

public long OpenBisFileSystem(ServiceCtx context)

{

return 0;

}

// OpenSdCardFileSystem() -> object<nn::fssrv::sf::IFileSystem>

public long OpenSdCardFileSystem(ServiceCtx context)

{

return 0;

}

// OpenSaveDataFileSystem(u8 save_data_space_id, nn::fssrv::sf::SaveStruct saveStruct) -> object<nn::fssrv::sf::IFileSystem> saveDataFs

public long OpenSaveDataFileSystem(ServiceCtx context)

{

return LoadSaveDataFileSystem(context);

}

// OpenSaveDataFileSystemBySystemSaveDataId(u8 save_data_space_id, nn::fssrv::sf::SaveStruct saveStruct) -> object<nn::fssrv::sf::IFileSystem> systemSaveDataFs

public long OpenSaveDataFileSystemBySystemSaveDataId(ServiceCtx context)

{

return LoadSaveDataFileSystem(context);

}

// OpenDataStorageByCurrentProcess() -> object<nn::fssrv::sf::IStorage> dataStorage

public long OpenDataStorageByCurrentProcess(ServiceCtx context)

{

return 0;

}

// OpenDataStorageByDataId(u8 storageId, nn::ApplicationId tid) -> object<nn::fssrv::sf::IStorage> dataStorage

public long OpenDataStorageByDataId(ServiceCtx context)

{

throw new FileNotFoundException($"System archive with titleid {titleId:x16} was not found on Storage {storageId}. Found in {installedStorage}.");

}

// OpenPatchDataStorageByCurrentProcess() -> object<nn::fssrv::sf::IStorage>

public long OpenPatchDataStorageByCurrentProcess(ServiceCtx context)

{

return 0;

}

// GetGlobalAccessLogMode() -> u32 logMode

public long GetGlobalAccessLogMode(ServiceCtx context)

{

return 0;

}

// OutputAccessLogToSdCard(buffer<bytes, 5> log_text)

public long OutputAccessLogToSdCard(ServiceCtx context)

{

using LibHac;

using Ryujinx.HLE.HOS.Ipc;

namespace Ryujinx.HLE.HOS.Services.FspSrv

{

class IStorage : IpcService

{

private LibHac.Fs.IStorage _baseStorage;

public IStorage(LibHac.Fs.IStorage baseStorage)

{

_baseStorage = baseStorage;

}

// Read(u64 offset, u64 length) -> buffer<u8, 0x46, 0> buffer

public long Read(ServiceCtx context)

{

return 0;

}

// GetSize() -> u64 size

public long GetSize(ServiceCtx context)

{

return 0;

}

}

namespace Ryujinx.HLE.HOS.Services.Hid

{

class IActiveApplicationDeviceList : IpcService

{

public long ActivateVibrationDevice(ServiceCtx context)

{

int vibrationDeviceHandle = context.RequestData.ReadInt32();

using Ryujinx.HLE.HOS.Kernel.Common;

using Ryujinx.HLE.HOS.Kernel.Memory;

using System;

namespace Ryujinx.HLE.HOS.Services.Hid

{

class IAppletResource : IpcService

{

private KSharedMemory _hidSharedMem;

public IAppletResource(KSharedMemory hidSharedMem)

{

_hidSharedMem = hidSharedMem;

}

public long GetSharedMemoryHandle(ServiceCtx context)

{

if (context.Process.HandleTable.GenerateHandle(_hidSharedMem, out int handle) != KernelResult.Success)

using Ryujinx.HLE.HOS.Kernel.Threading;

using Ryujinx.HLE.Input;

using System;

namespace Ryujinx.HLE.HOS.Services.Hid

{

[Service("hid")]

class IHidServer : IpcService

{

private KEvent _npadStyleSetUpdateEvent;

private KEvent _xpadIdEvent;

private KEvent _palmaOperationCompleteEvent;

private HidAccelerometerParameters _accelerometerParams;

private HidVibrationValue _vibrationValue;

public IHidServer(ServiceCtx context)

{

_npadStyleSetUpdateEvent = new KEvent(context.Device.System);

_xpadIdEvent = new KEvent(context.Device.System);

_palmaOperationCompleteEvent = new KEvent(context.Device.System);

_xpadIdEvent.ReadableEvent.Signal();

}

// CreateAppletResource(nn::applet::AppletResourceUserId) -> object<nn::hid::IAppletResource>

public long CreateAppletResource(ServiceCtx context)

{

return 0;

}

// ActivateDebugPad(nn::applet::AppletResourceUserId)

public long ActivateDebugPad(ServiceCtx context)

{

return 0;

}

// ActivateTouchScreen(nn::applet::AppletResourceUserId)

public long ActivateTouchScreen(ServiceCtx context)

{

return 0;

}

// ActivateMouse(nn::applet::AppletResourceUserId)

public long ActivateMouse(ServiceCtx context)

{

return 0;

}

// ActivateKeyboard(nn::applet::AppletResourceUserId)

public long ActivateKeyboard(ServiceCtx context)

{

return 0;

}

// AcquireXpadIdEventHandle(ulong XpadId) -> nn::sf::NativeHandle

public long AcquireXpadIdEventHandle(ServiceCtx context)

{

return 0;

}

// ReleaseXpadIdEventHandle(ulong XpadId)

public long ReleaseXpadIdEventHandle(ServiceCtx context)

{

return 0;

}

// ActivateXpad(nn::hid::BasicXpadId, nn::applet::AppletResourceUserId)

public long ActivateXpad(ServiceCtx context)

{

return 0;

}

// GetXpadIds() -> long IdsCount, buffer<array<nn::hid::BasicXpadId>, type: 0xa>

public long GetXpadIds(ServiceCtx context)

{

return 0;

}

// ActivateJoyXpad(nn::hid::JoyXpadId)

public long ActivateJoyXpad(ServiceCtx context)

{

return 0;

}

// GetJoyXpadLifoHandle(nn::hid::JoyXpadId) -> nn::sf::NativeHandle

public long GetJoyXpadLifoHandle(ServiceCtx context)

{

return 0;

}

// GetJoyXpadIds() -> long IdsCount, buffer<array<nn::hid::JoyXpadId>, type: 0xa>

public long GetJoyXpadIds(ServiceCtx context)

{

return 0;

}

// ActivateSixAxisSensor(nn::hid::BasicXpadId)

public long ActivateSixAxisSensor(ServiceCtx context)

{

return 0;

}

// DeactivateSixAxisSensor(nn::hid::BasicXpadId)

public long DeactivateSixAxisSensor(ServiceCtx context)

{

return 0;

}

// GetSixAxisSensorLifoHandle(nn::hid::BasicXpadId) -> nn::sf::NativeHandle

public long GetSixAxisSensorLifoHandle(ServiceCtx context)

{

return 0;

}

// ActivateJoySixAxisSensor(nn::hid::JoyXpadId)

public long ActivateJoySixAxisSensor(ServiceCtx context)

{

return 0;

}

// DeactivateJoySixAxisSensor(nn::hid::JoyXpadId)

public long DeactivateJoySixAxisSensor(ServiceCtx context)

{

return 0;

}

// GetJoySixAxisSensorLifoHandle(nn::hid::JoyXpadId) -> nn::sf::NativeHandle

public long GetJoySixAxisSensorLifoHandle(ServiceCtx context)

{

return 0;

}

// StartSixAxisSensor(nn::hid::SixAxisSensorHandle, nn::applet::AppletResourceUserId)

public long StartSixAxisSensor(ServiceCtx context)

{

return 0;

}

// StopSixAxisSensor(nn::hid::SixAxisSensorHandle, nn::applet::AppletResourceUserId)

public long StopSixAxisSensor(ServiceCtx context)

{

return 0;

}

// IsSixAxisSensorFusionEnabled(nn::hid::SixAxisSensorHandle, nn::applet::AppletResourceUserId) -> bool IsEnabled

public long IsSixAxisSensorFusionEnabled(ServiceCtx context)

{

return 0;

}

// EnableSixAxisSensorFusion(bool Enabled, nn::hid::SixAxisSensorHandle, nn::applet::AppletResourceUserId)

public long EnableSixAxisSensorFusion(ServiceCtx context)

{

return 0;

}

// SetSixAxisSensorFusionParameters(nn::hid::SixAxisSensorHandle, float RevisePower, float ReviseRange, nn::applet::AppletResourceUserId)

public long SetSixAxisSensorFusionParameters(ServiceCtx context)

{

return 0;

}

// GetSixAxisSensorFusionParameters(nn::hid::SixAxisSensorHandle, nn::applet::AppletResourceUserId) -> float RevisePower, float ReviseRange)

public long GetSixAxisSensorFusionParameters(ServiceCtx context)

{

return 0;

}

// ResetSixAxisSensorFusionParameters(nn::hid::SixAxisSensorHandle, nn::applet::AppletResourceUserId)

public long ResetSixAxisSensorFusionParameters(ServiceCtx context)

{

return 0;

}

// SetAccelerometerParameters(nn::hid::SixAxisSensorHandle, float X, float Y, nn::applet::AppletResourceUserId)

public long SetAccelerometerParameters(ServiceCtx context)

{

return 0;

}

// GetAccelerometerParameters(nn::hid::SixAxisSensorHandle, nn::applet::AppletResourceUserId) -> float X, float Y

public long GetAccelerometerParameters(ServiceCtx context)

{

return 0;

}

// ResetAccelerometerParameters(nn::hid::SixAxisSensorHandle, nn::applet::AppletResourceUserId)

public long ResetAccelerometerParameters(ServiceCtx context)

{

return 0;

}

// SetAccelerometerPlayMode(nn::hid::SixAxisSensorHandle, uint PlayMode, nn::applet::AppletResourceUserId)

public long SetAccelerometerPlayMode(ServiceCtx context)

{

return 0;

}

// GetAccelerometerPlayMode(nn::hid::SixAxisSensorHandle, nn::applet::AppletResourceUserId) -> uint PlayMode

public long GetAccelerometerPlayMode(ServiceCtx context)

{

return 0;

}

// ResetAccelerometerPlayMode(nn::hid::SixAxisSensorHandle, nn::applet::AppletResourceUserId)

public long ResetAccelerometerPlayMode(ServiceCtx context)

{

return 0;

}

// SetGyroscopeZeroDriftMode(nn::hid::SixAxisSensorHandle, uint GyroscopeZeroDriftMode, nn::applet::AppletResourceUserId)

public long SetGyroscopeZeroDriftMode(ServiceCtx context)

{

return 0;

}

// GetGyroscopeZeroDriftMode(nn::applet::AppletResourceUserId, nn::hid::SixAxisSensorHandle) -> int GyroscopeZeroDriftMode

public long GetGyroscopeZeroDriftMode(ServiceCtx context)

{

return 0;

}

// ResetGyroscopeZeroDriftMode(nn::hid::SixAxisSensorHandle, nn::applet::AppletResourceUserId)

public long ResetGyroscopeZeroDriftMode(ServiceCtx context)

{

return 0;

}

// IsSixAxisSensorAtRest(nn::hid::SixAxisSensorHandle, nn::applet::AppletResourceUserId) -> bool IsAsRest

public long IsSixAxisSensorAtRest(ServiceCtx context)

{

return 0;

}

// ActivateGesture(nn::applet::AppletResourceUserId, int Unknown0)

public long ActivateGesture(ServiceCtx context)

{

return 0;

}

// SetSupportedNpadStyleSet(nn::applet::AppletResourceUserId, nn::hid::NpadStyleTag)

public long SetSupportedNpadStyleSet(ServiceCtx context)

{

return 0;

}

// GetSupportedNpadStyleSet(nn::applet::AppletResourceUserId) -> uint nn::hid::NpadStyleTag

public long GetSupportedNpadStyleSet(ServiceCtx context)

{

return 0;

}

// SetSupportedNpadIdType(nn::applet::AppletResourceUserId, array<NpadIdType, 9>)

public long SetSupportedNpadIdType(ServiceCtx context)

{

return 0;

}

// ActivateNpad(nn::applet::AppletResourceUserId)

public long ActivateNpad(ServiceCtx context)

{

return 0;

}

// DeactivateNpad(nn::applet::AppletResourceUserId)

public long DeactivateNpad(ServiceCtx context)

{

return 0;

}

// AcquireNpadStyleSetUpdateEventHandle(nn::applet::AppletResourceUserId, uint, ulong) -> nn::sf::NativeHandle

public long AcquireNpadStyleSetUpdateEventHandle(ServiceCtx context)

{

return 0;

}

// DisconnectNpad(nn::applet::AppletResourceUserId, uint NpadIdType)

public long DisconnectNpad(ServiceCtx context)

{

return 0;

}

// GetPlayerLedPattern(uint NpadId) -> ulong LedPattern

public long GetPlayerLedPattern(ServiceCtx context)

{

return 0;

}

// ActivateNpadWithRevision(nn::applet::AppletResourceUserId, int Unknown)

public long ActivateNpadWithRevision(ServiceCtx context)

{

return 0;

}

// SetNpadJoyHoldType(nn::applet::AppletResourceUserId, long NpadJoyHoldType)

public long SetNpadJoyHoldType(ServiceCtx context)

{

return 0;

}

// GetNpadJoyHoldType(nn::applet::AppletResourceUserId) -> long NpadJoyHoldType

public long GetNpadJoyHoldType(ServiceCtx context)

{

return 0;

}

// SetNpadJoyAssignmentModeSingleByDefault(uint HidControllerId, nn::applet::AppletResourceUserId)

public long SetNpadJoyAssignmentModeSingleByDefault(ServiceCtx context)

{

return 0;

}

// SetNpadJoyAssignmentModeSingle(uint HidControllerId, nn::applet::AppletResourceUserId, long HidNpadJoyDeviceType)

public long SetNpadJoyAssignmentModeSingle(ServiceCtx context)

{

return 0;

}

// SetNpadJoyAssignmentModeDual(uint HidControllerId, nn::applet::AppletResourceUserId)

public long SetNpadJoyAssignmentModeDual(ServiceCtx context)

{

return 0;

}

// MergeSingleJoyAsDualJoy(uint SingleJoyId0, uint SingleJoyId1, nn::applet::AppletResourceUserId)

public long MergeSingleJoyAsDualJoy(ServiceCtx context)

{

return 0;

}

// StartLrAssignmentMode(nn::applet::AppletResourceUserId)

public long StartLrAssignmentMode(ServiceCtx context)

{

return 0;

}

// StopLrAssignmentMode(nn::applet::AppletResourceUserId)

public long StopLrAssignmentMode(ServiceCtx context)

{

return 0;

}

// SetNpadHandheldActivationMode(nn::applet::AppletResourceUserId, long HidNpadHandheldActivationMode)

public long SetNpadHandheldActivationMode(ServiceCtx context)

{

return 0;

}

// GetNpadHandheldActivationMode(nn::applet::AppletResourceUserId) -> long HidNpadHandheldActivationMode

public long GetNpadHandheldActivationMode(ServiceCtx context)

{

return 0;

}

// SwapNpadAssignment(uint OldNpadAssignment, uint NewNpadAssignment, nn::applet::AppletResourceUserId)

public long SwapNpadAssignment(ServiceCtx context)

{

return 0;

}

// IsUnintendedHomeButtonInputProtectionEnabled(uint Unknown0, nn::applet::AppletResourceUserId) -> bool IsEnabled

public long IsUnintendedHomeButtonInputProtectionEnabled(ServiceCtx context)

{

return 0;

}

// EnableUnintendedHomeButtonInputProtection(bool Enable, uint Unknown0, nn::applet::AppletResourceUserId)

public long EnableUnintendedHomeButtonInputProtection(ServiceCtx context)

{

return 0;

}

// SetNpadJoyAssignmentModeSingleWithDestination(uint HidControllerId, long HidNpadJoyDeviceType, nn::applet::AppletResourceUserId) -> bool Unknown0, uint Unknown1

public long SetNpadJoyAssignmentModeSingleWithDestination(ServiceCtx context)

{

return 0;

}

// GetVibrationDeviceInfo(nn::hid::VibrationDeviceHandle) -> nn::hid::VibrationDeviceInfo

public long GetVibrationDeviceInfo(ServiceCtx context)

{

return 0;

}

// SendVibrationValue(nn::hid::VibrationDeviceHandle, nn::hid::VibrationValue, nn::applet::AppletResourceUserId)

public long SendVibrationValue(ServiceCtx context)

{

return 0;

}

// GetActualVibrationValue(nn::hid::VibrationDeviceHandle, nn::applet::AppletResourceUserId) -> nn::hid::VibrationValue

public long GetActualVibrationValue(ServiceCtx context)

{

return 0;

}

// CreateActiveVibrationDeviceList() -> object<nn::hid::IActiveVibrationDeviceList>

public long CreateActiveVibrationDeviceList(ServiceCtx context)

{

return 0;

}

// PermitVibration(bool Enable)

public long PermitVibration(ServiceCtx context)

{

return 0;

}

// IsVibrationPermitted() -> bool IsEnabled

public long IsVibrationPermitted(ServiceCtx context)

{

return 0;

}

// SendVibrationValues(nn::applet::AppletResourceUserId, buffer<array<nn::hid::VibrationDeviceHandle>, type: 9>, buffer<array<nn::hid::VibrationValue>, type: 9>)

public long SendVibrationValues(ServiceCtx context)

{

return 0;

}

// SendVibrationGcErmCommand(nn::hid::VibrationDeviceHandle, nn::hid::VibrationGcErmCommand, nn::applet::AppletResourceUserId)

public long SendVibrationGcErmCommand(ServiceCtx context)

{

return 0;

}

// GetActualVibrationGcErmCommand(nn::hid::VibrationDeviceHandle, nn::applet::AppletResourceUserId) -> nn::hid::VibrationGcErmCommand

public long GetActualVibrationGcErmCommand(ServiceCtx context)

{

return 0;

}

// BeginPermitVibrationSession(nn::applet::AppletResourceUserId)

public long BeginPermitVibrationSession(ServiceCtx context)

{

return 0;

}

// EndPermitVibrationSession()

public long EndPermitVibrationSession(ServiceCtx context)

{

return 0;

}

// ActivateConsoleSixAxisSensor(nn::applet::AppletResourceUserId)

public long ActivateConsoleSixAxisSensor(ServiceCtx context)

{

return 0;

}

// StartConsoleSixAxisSensor(nn::hid::ConsoleSixAxisSensorHandle, nn::applet::AppletResourceUserId)

public long StartConsoleSixAxisSensor(ServiceCtx context)

{

return 0;

}

// StopConsoleSixAxisSensor(nn::hid::ConsoleSixAxisSensorHandle, nn::applet::AppletResourceUserId)

public long StopConsoleSixAxisSensor(ServiceCtx context)

{

return 0;

}

// ActivateSevenSixAxisSensor(nn::applet::AppletResourceUserId)

public long ActivateSevenSixAxisSensor(ServiceCtx context)

{

return 0;

}

// StartSevenSixAxisSensor(nn::applet::AppletResourceUserId)

public long StartSevenSixAxisSensor(ServiceCtx context)

{

return 0;

}

// StopSevenSixAxisSensor(nn::applet::AppletResourceUserId)

public long StopSevenSixAxisSensor(ServiceCtx context)

{

return 0;

}

// InitializeSevenSixAxisSensor(array<nn::sf::NativeHandle>, ulong Counter0, array<nn::sf::NativeHandle>, ulong Counter1, nn::applet::AppletResourceUserId)

public long InitializeSevenSixAxisSensor(ServiceCtx context)

{

return 0;

}

// FinalizeSevenSixAxisSensor(nn::applet::AppletResourceUserId)

public long FinalizeSevenSixAxisSensor(ServiceCtx context)

{

return 0;

}

// SetSevenSixAxisSensorFusionStrength(float Strength, nn::applet::AppletResourceUserId)

public long SetSevenSixAxisSensorFusionStrength(ServiceCtx context)

{

return 0;

}

// GetSevenSixAxisSensorFusionStrength(nn::applet::AppletResourceUserId) -> float Strength

public long GetSevenSixAxisSensorFusionStrength(ServiceCtx context)

{

return 0;

}

// IsUsbFullKeyControllerEnabled() -> bool IsEnabled

public long IsUsbFullKeyControllerEnabled(ServiceCtx context)

{

return 0;

}

// EnableUsbFullKeyController(bool Enable)

public long EnableUsbFullKeyController(ServiceCtx context)

{

return 0;

}

// IsUsbFullKeyControllerConnected(uint Unknown0) -> bool Connected

public long IsUsbFullKeyControllerConnected(ServiceCtx context)

{

return 0;

}

// HasBattery(uint NpadId) -> bool HasBattery

public long HasBattery(ServiceCtx context)

{

return 0;

}

// HasLeftRightBattery(uint NpadId) -> bool HasLeftBattery, bool HasRightBattery

public long HasLeftRightBattery(ServiceCtx context)

{

return 0;

}

// GetNpadInterfaceType(uint NpadId) -> uchar InterfaceType

public long GetNpadInterfaceType(ServiceCtx context)

{

return 0;

}

// GetNpadLeftRightInterfaceType(uint NpadId) -> uchar LeftInterfaceType, uchar RightInterfaceType

public long GetNpadLeftRightInterfaceType(ServiceCtx context)

{

return 0;

}

// GetPalmaConnectionHandle(uint Unknown0, nn::applet::AppletResourceUserId) -> nn::hid::PalmaConnectionHandle

public long GetPalmaConnectionHandle(ServiceCtx context)

{

return 0;

}

// InitializePalma(nn::hid::PalmaConnectionHandle)

public long InitializePalma(ServiceCtx context)

{

return 0;

}

// AcquirePalmaOperationCompleteEvent(nn::hid::PalmaConnectionHandle) -> nn::sf::NativeHandle

public long AcquirePalmaOperationCompleteEvent(ServiceCtx context)

{

return 0;

}

// GetPalmaOperationInfo(nn::hid::PalmaConnectionHandle) -> long Unknown0, buffer<Unknown>

public long GetPalmaOperationInfo(ServiceCtx context)

{

return 0;

}

// PlayPalmaActivity(nn::hid::PalmaConnectionHandle, ulong Unknown0)

public long PlayPalmaActivity(ServiceCtx context)

{

return 0;

}

// SetPalmaFrModeType(nn::hid::PalmaConnectionHandle, ulong FrModeType)

public long SetPalmaFrModeType(ServiceCtx context)

{

return 0;

}

// ReadPalmaStep(nn::hid::PalmaConnectionHandle)

public long ReadPalmaStep(ServiceCtx context)

{

return 0;

}

// EnablePalmaStep(nn::hid::PalmaConnectionHandle, bool Enable)

public long EnablePalmaStep(ServiceCtx context)

{

return 0;

}

// ResetPalmaStep(nn::hid::PalmaConnectionHandle)

public long ResetPalmaStep(ServiceCtx context)

{

return 0;

}

// ReadPalmaApplicationSection(nn::hid::PalmaConnectionHandle, ulong Unknown0, ulong Unknown1)

public long ReadPalmaApplicationSection(ServiceCtx context)

{

return 0;

}

// WritePalmaApplicationSection(nn::hid::PalmaConnectionHandle, ulong Unknown0, ulong Unknown1, nn::hid::PalmaApplicationSectionAccessBuffer)

public long WritePalmaApplicationSection(ServiceCtx context)

{

return 0;

}

// ReadPalmaUniqueCode(nn::hid::PalmaConnectionHandle)

public long ReadPalmaUniqueCode(ServiceCtx context)

{

return 0;

}

// SetPalmaUniqueCodeInvalid(nn::hid::PalmaConnectionHandle)

public long SetPalmaUniqueCodeInvalid(ServiceCtx context)

{

return 0;

}

// SetNpadCommunicationMode(long CommunicationMode, nn::applet::AppletResourceUserId)

public long SetNpadCommunicationMode(ServiceCtx context)

{

return 0;

}

// GetNpadCommunicationMode() -> long CommunicationMode

public long GetNpadCommunicationMode(ServiceCtx context)

{

using Ryujinx.HLE.HOS.Kernel.Common;

using Ryujinx.HLE.Input;

using System;

namespace Ryujinx.HLE.HOS.Services.Hid.Irs

{

{

private int _irsensorSharedMemoryHandle = 0;

// ActivateIrsensor(nn::applet::AppletResourceUserId, pid)

public long ActivateIrsensor(ServiceCtx context)

{

return 0;

}

// DeactivateIrsensor(nn::applet::AppletResourceUserId, pid)

public long DeactivateIrsensor(ServiceCtx context)

{

return 0;

}

// GetIrsensorSharedMemoryHandle(nn::applet::AppletResourceUserId, pid) -> handle<copy>

public long GetIrsensorSharedMemoryHandle(ServiceCtx context)

{

return 0;

}

// GetNpadIrCameraHandle(u32) -> nn::irsensor::IrCameraHandle

public long GetNpadIrCameraHandle(ServiceCtx context)

{

return 0;

}

// ActivateIrsensorWithFunctionLevel(nn::applet::AppletResourceUserId, nn::irsensor::PackedFunctionLevel, pid)

public long ActivateIrsensorWithFunctionLevel(ServiceCtx context)

{

using System.Collections.Generic;

namespace Ryujinx.HLE.HOS.Services

{

interface IIpcService

{

}

} \ No newline at end of file

using System.Collections.Generic;

using System.IO;

using Ryujinx.Profiler;

namespace Ryujinx.HLE.HOS.Services

{

abstract class IpcService : IIpcService

{

private IdDictionary _domainObjects;

public IpcService()

{

_domainObjects = new IdDictionary();

_selfId = -1;

long sfciMagic = context.RequestData.ReadInt64();

int commandId = (int)context.RequestData.ReadInt64();

if (ServiceConfiguration.IgnoreMissingServices || serviceExists)

{

if (serviceExists)

{

ProfileConfig profile = Profiles.ServiceCall;

Profile.Begin(profile);

Profile.End(profile);

}

else

{

string serviceName;

DummyService dummyService = service as DummyService;

serviceName = (dummyService == null) ? service.GetType().FullName : dummyService.ServiceName;

[Service("ldr:ro")]

class IRoInterface : IpcService

{

private const int MaxNrr = 0x40;

private const int MaxNro = 0x40;

public IRoInterface(ServiceCtx context)

{

_nrrInfos = new List<NrrInfo>(MaxNrr);

_nroInfos = new List<NroInfo>(MaxNro);

}

return MakeError(ErrorModule.Loader, LoaderErr.BadNroAddress);

}

// LoadNro(u64, u64, u64, u64, u64, pid) -> u64

public long LoadNro(ServiceCtx context)

{

return result;

}

// UnloadNro(u64, u64, pid)

public long UnloadNro(ServiceCtx context)

{

return result;

}

// LoadNrr(u64, u64, u64, pid)

public long LoadNrr(ServiceCtx context)

{

return result;

}

// UnloadNrr(u64, u64, pid)

public long UnloadNrr(ServiceCtx context)

{

return result;

}

// Initialize(u64, pid, KObject)

public long Initialize(ServiceCtx context)

{

return 0;

}

}

namespace Ryujinx.HLE.HOS.Services.Lm

{

[Service("lm")]

class ILogService : IpcService

{

public long Initialize(ServiceCtx context)

{

MakeObject(context, new ILogger());

using Ryujinx.Common.Logging;

using System.IO;

using System.Text;

{

class ILogger : IpcService

{

public long Log(ServiceCtx context)

{

(long bufPos, long bufSize) = context.Request.GetBufferType0x21();

byte[] logBuffer = context.Memory.ReadBytes(bufPos, bufSize);

return 0;

}

}

using LibHac.Fs.NcaUtils;

using Ryujinx.HLE.FileSystem;

using Ryujinx.HLE.FileSystem.Content;

using System.Text;

using static Ryujinx.HLE.HOS.ErrorCode;

{

class ILocationResolver : IpcService

{

private StorageId _storageId;

public ILocationResolver(StorageId storageId)

{

_storageId = storageId;

}

{

long titleId = context.RequestData.ReadInt64();

}

{

long titleId = context.RequestData.ReadInt64();

return 0;

}

{

long titleId = context.RequestData.ReadInt64();

}

{

long titleId = context.RequestData.ReadInt64();

}

{

long titleId = context.RequestData.ReadInt64();

}

// RedirectApplicationControlPath()

public long RedirectApplicationControlPath(ServiceCtx context)

{

return 0;

}

// RedirectApplicationHtmlDocumentPath()

public long RedirectApplicationHtmlDocumentPath(ServiceCtx context)

{

return 0;

}

// RedirectApplicationLegalInformationPath()

public long RedirectApplicationLegalInformationPath(ServiceCtx context)

{

return 0;

}

{

}

{

long titleId = context.RequestData.ReadInt64();

}

{

}

{

long titleId = context.RequestData.ReadInt64();

}

{

long titleId = context.RequestData.ReadInt64();

return 0;

}

{

return 0;

}

{

long titleId = context.RequestData.ReadInt64();

}

private void RedirectPath(ServiceCtx context, long titleId, int flag, ContentType contentType)

namespace Ryujinx.HLE.HOS.Services.Lr

{

[Service("lr")]

class ILocationResolverManager : IpcService

{

// OpenLocationResolver()

private long OpenLocationResolver(ServiceCtx context)

{

return 0;

}

}

using Ryujinx.Common.Logging;

namespace Ryujinx.HLE.HOS.Services.Mm

{

[Service("mm:u")]

class IRequest : IpcService

{

// InitializeOld(u32, u32, u32)

public long InitializeOld(ServiceCtx context)

{

return 0;

}

// FinalizeOld(u32)

public long FinalizeOld(ServiceCtx context)

{

return 0;

}

// SetAndWaitOld(u32, u32, u32)

public long SetAndWaitOld(ServiceCtx context)

{

return 0;

}

// GetOld(u32) -> u32

public long GetOld(ServiceCtx context)

{

return 0;

}

// Initialize()

public long Initialize(ServiceCtx context)

{

return 0;

}

// Finalize(u32)

public long Finalize(ServiceCtx context)

{

return 0;

}

// SetAndWait(u32, u32, u32)

public long SetAndWait(ServiceCtx context)

{

return 0;

}

// Get(u32) -> u32

public long Get(ServiceCtx context)

{

{

[Service("ncm")]

class IContentManager : IpcService

{

}

} \ No newline at end of file

{

class IContentStorage : IpcService

{

}

using Ryujinx.HLE.HOS.Ipc;

using Ryujinx.HLE.HOS.Kernel.Common;

using Ryujinx.HLE.HOS.Kernel.Threading;

private List<Device> _devices = new List<Device>();

// Initialize(u64, u64, pid, buffer<unknown, 5>)

public long Initialize(ServiceCtx context)

{

return 0;

}

// Finalize()

public long Finalize(ServiceCtx context)

{

return 0;

}

// ListDevices() -> (u32, buffer<unknown, 0xa>)

public long ListDevices(ServiceCtx context)

{

return 0;

}

// StartDetection(bytes<8, 4>)

public long StartDetection(ServiceCtx context)

{

throw new ServiceNotImplementedException(context);

}

// StopDetection(bytes<8, 4>)

public long StopDetection(ServiceCtx context)

{

throw new ServiceNotImplementedException(context);

}

// Mount(bytes<8, 4>, u32, u32)

public long Mount(ServiceCtx context)

{

throw new ServiceNotImplementedException(context);

}

// Unmount(bytes<8, 4>)

public long Unmount(ServiceCtx context)

{

throw new ServiceNotImplementedException(context);

}

// OpenApplicationArea(bytes<8, 4>, u32)

public long OpenApplicationArea(ServiceCtx context)

{

throw new ServiceNotImplementedException(context);

}

// GetApplicationArea(bytes<8, 4>) -> (u32, buffer<unknown, 6>)

public long GetApplicationArea(ServiceCtx context)

{

throw new ServiceNotImplementedException(context);

}

// SetApplicationArea(bytes<8, 4>, buffer<unknown, 5>)

public long SetApplicationArea(ServiceCtx context)

{

throw new ServiceNotImplementedException(context);

}

// Flush(bytes<8, 4>)

public long Flush(ServiceCtx context)

{

throw new ServiceNotImplementedException(context);

}

// Restore(bytes<8, 4>)

public long Restore(ServiceCtx context)

{

throw new ServiceNotImplementedException(context);

}

// CreateApplicationArea(bytes<8, 4>, u32, buffer<unknown, 5>)

public long CreateApplicationArea(ServiceCtx context)

{

throw new ServiceNotImplementedException(context);

}

// GetTagInfo(bytes<8, 4>) -> buffer<unknown<0x58>, 0x1a>

public long GetTagInfo(ServiceCtx context)

{

throw new ServiceNotImplementedException(context);

}

// GetRegisterInfo(bytes<8, 4>) -> buffer<unknown<0x100>, 0x1a>

public long GetRegisterInfo(ServiceCtx context)

{

throw new ServiceNotImplementedException(context);

}

// GetCommonInfo(bytes<8, 4>) -> buffer<unknown<0x40>, 0x1a>

public long GetCommonInfo(ServiceCtx context)

{

throw new ServiceNotImplementedException(context);

}

// GetModelInfo(bytes<8, 4>) -> buffer<unknown<0x40>, 0x1a>

public long GetModelInfo(ServiceCtx context)

{

throw new ServiceNotImplementedException(context);

}

// AttachActivateEvent(bytes<8, 4>) -> handle<copy>

public long AttachActivateEvent(ServiceCtx context)

{

return ErrorCode.MakeError(ErrorModule.Nfp, NfpError.DeviceNotFound);

}

// AttachDeactivateEvent(bytes<8, 4>) -> handle<copy>

public long AttachDeactivateEvent(ServiceCtx context)

{

return ErrorCode.MakeError(ErrorModule.Nfp, NfpError.DeviceNotFound);

}

// GetState() -> u32

public long GetState(ServiceCtx context)

{

return 0;

}

// GetDeviceState(bytes<8, 4>) -> u32

public long GetDeviceState(ServiceCtx context)

{

return ErrorCode.MakeError(ErrorModule.Nfp, NfpError.DeviceNotFound);

}

// GetNpadId(bytes<8, 4>) -> u32

public long GetNpadId(ServiceCtx context)

{

return ErrorCode.MakeError(ErrorModule.Nfp, NfpError.DeviceNotFound);

}

// GetApplicationAreaSize(bytes<8, 4>) -> u32

public long GetApplicationAreaSize(ServiceCtx context)

{

throw new ServiceNotImplementedException(context);

}

// AttachAvailabilityChangeEvent() -> handle<copy>

public long AttachAvailabilityChangeEvent(ServiceCtx context)

{

return 0;

}

// RecreateApplicationArea(bytes<8, 4>, u32, buffer<unknown, 5>)

public long RecreateApplicationArea(ServiceCtx context)

{

{

[Service("nfp:user")]

class IUserManager : IpcService

{

public long GetUserInterface(ServiceCtx context)

{

MakeObject(context, new IUser());

using Ryujinx.Common.Logging;

using System;

using System.Linq;

using System.Net;

using System.Net.NetworkInformation;

{

class IGeneralService : IpcService

{

public long CreateRequest(ServiceCtx context)

{

int unknown = context.RequestData.ReadInt32();

return 0;

}

public long GetCurrentIpAddress(ServiceCtx context)

{

if (!NetworkInterface.GetIsNetworkAvailable())

return 0;

}

}

using Ryujinx.HLE.HOS.Kernel.Common;

using Ryujinx.HLE.HOS.Kernel.Threading;

using System;

namespace Ryujinx.HLE.HOS.Services.Nifm

{

class IRequest : IpcService

{

private KEvent _event0;

private KEvent _event1;

public IRequest(Horizon system)

{

_event0 = new KEvent(system);

_event1 = new KEvent(system);

}

public long GetRequestState(ServiceCtx context)

{

context.ResponseData.Write(1);

return 0;

}

public long GetResult(ServiceCtx context)

{

Logger.PrintStub(LogClass.ServiceNifm);

return 0;

}

public long GetSystemEventReadableHandles(ServiceCtx context)

{

if (context.Process.HandleTable.GenerateHandle(_event0.ReadableEvent, out int handle0) != KernelResult.Success)

return 0;

}

public long Cancel(ServiceCtx context)

{

Logger.PrintStub(LogClass.ServiceNifm);

return 0;

}

public long Submit(ServiceCtx context)

{

Logger.PrintStub(LogClass.ServiceNifm);

return 0;

}

public long SetConnectionConfirmationOption(ServiceCtx context)

{

Logger.PrintStub(LogClass.ServiceNifm);

namespace Ryujinx.HLE.HOS.Services.Nifm

{

[Service("nifm:u")]

class IStaticService : IpcService

{

public long CreateGeneralServiceOld(ServiceCtx context)

{

MakeObject(context, new IGeneralService());

return 0;

}

public long CreateGeneralService(ServiceCtx context)

{

MakeObject(context, new IGeneralService());

using Ryujinx.Common.Logging;

namespace Ryujinx.HLE.HOS.Services.Ns

{

[Service("aoc:u")]

class IAddOnContentManager : IpcService

{

public static long CountAddOnContent(ServiceCtx context)

{

context.ResponseData.Write(0);

return 0;

}

public static long ListAddOnContent(ServiceCtx context)

{

Logger.PrintStub(LogClass.ServiceNs);

using LibHac;

using System;

using System.Text;

namespace Ryujinx.HLE.HOS.Services.Ns

[Service("ns:am")]

class IApplicationManagerInterface : IpcService

{

public long GetApplicationControlData(ServiceCtx context)

{

long position = context.Request.ReceiveBuff[0].Position;

return 0;

}

}

namespace Ryujinx.HLE.HOS.Services.Ns

{

[Service("ns:am2")]

[Service("ns:ec")]

class IServiceGetterInterface : IpcService

{

public long GetApplicationManagerInterface(ServiceCtx context)

{

MakeObject(context, new IApplicationManagerInterface(context));

namespace Ryujinx.HLE.HOS.Services.Ns

{

[Service("ns:su")]

class ISystemUpdateInterface : IpcService

{

}

} \ No newline at end of file

namespace Ryujinx.HLE.HOS.Services.Ns

{

[Service("ns:vm")]

class IVulnerabilityManagerInterface : IpcService

{

}

} \ No newline at end of file

{

private delegate int IoctlProcessor(ServiceCtx context, int cmd);

private static Dictionary<string, IoctlProcessor> _ioctlProcessors =

new Dictionary<string, IoctlProcessor>()

{

public INvDrvServices(ServiceCtx context)

{

_event = new KEvent(context.Device.System);

}

Fds = new GlobalStateTable();

}

public long Open(ServiceCtx context)

{

long namePtr = context.Request.SendBuff[0].Position;

return 0;

}

public long Ioctl(ServiceCtx context)

{

int fd = context.RequestData.ReadInt32();

return 0;

}

public long Close(ServiceCtx context)

{

int fd = context.RequestData.ReadInt32();

return 0;

}

public long Initialize(ServiceCtx context)

{

long transferMemSize = context.RequestData.ReadInt64();

return 0;

}

public long QueryEvent(ServiceCtx context)

{

int fd = context.RequestData.ReadInt32();

return 0;

}

public long SetClientPid(ServiceCtx context)

{

long pid = context.RequestData.ReadInt64();

return 0;

}

public long DumpGraphicsMemoryInfo(ServiceCtx context)

{

Logger.PrintStub(LogClass.ServiceNv);

return 0;

}

public long FinishInitialize(ServiceCtx context)

{

Logger.PrintStub(LogClass.ServiceNv);

NvMapIoctl.UnloadProcess(process);

}

}

using Ryujinx.Common.Logging;

namespace Ryujinx.HLE.HOS.Services.Pctl

{

class IParentalControlService : IpcService

{

private bool _initialized = false;

private bool _needInitialize;

public IParentalControlService(bool needInitialize = true)

{

_needInitialize = needInitialize;

}

public long Initialize(ServiceCtx context)

{

if (_needInitialize && !_initialized)

return 0;

}

public long CheckFreeCommunicationPermission(ServiceCtx context)

{

Logger.PrintStub(LogClass.ServicePctl);

namespace Ryujinx.HLE.HOS.Services.Pctl

{

[Service("pctl")]

[Service("pctl:s")]

class IParentalControlServiceFactory : IpcService

{

public long CreateService(ServiceCtx context)

{

MakeObject(context, new IParentalControlService());

return 0;

}

public long CreateServiceWithoutInitialize(ServiceCtx context)

{

MakeObject(context, new IParentalControlService(false));

using Ryujinx.HLE.HOS.Ipc;

using Ryujinx.HLE.HOS.Kernel.Common;

using System;

namespace Ryujinx.HLE.HOS.Services.Pl

{

[Service("pl:u")]

class ISharedFontManager : IpcService

{

public long RequestLoad(ServiceCtx context)

{

SharedFontType fontType = (SharedFontType)context.RequestData.ReadInt32();

return 0;

}

public long GetLoadState(ServiceCtx context)

{

SharedFontType fontType = (SharedFontType)context.RequestData.ReadInt32();

return 0;

}

public long GetFontSize(ServiceCtx context)

{

SharedFontType fontType = (SharedFontType)context.RequestData.ReadInt32();

return 0;

}

public long GetSharedMemoryAddressOffset(ServiceCtx context)

{

SharedFontType fontType = (SharedFontType)context.RequestData.ReadInt32();

return 0;

}

public long GetSharedMemoryNativeHandle(ServiceCtx context)

{

context.Device.System.Font.EnsureInitialized(context.Device.System.ContentManager);

return 0;

}

public long GetSharedFontInOrderOfPriority(ServiceCtx context)

{

long languageCode = context.RequestData.ReadInt64();

{

[Service("pm:shell")]

class IShellInterface : IpcService

{

// GetApplicationPid() -> u64

public long GetApplicationPid(ServiceCtx context)

{

using Ryujinx.Common.Logging;

namespace Ryujinx.HLE.HOS.Services.Prepo

{

[Service("prepo:u")]

class IPrepoService : IpcService

{

public static long SaveReportWithUser(ServiceCtx context)

{

Logger.PrintStub(LogClass.ServicePrepo);

using Ryujinx.Common.Logging;

namespace Ryujinx.HLE.HOS.Services.Psm

{

UsbC

}

// GetBatteryChargePercentage() -> u32

public static long GetBatteryChargePercentage(ServiceCtx context)

{

return 0;

}

// GetChargerType() -> u32

public static long GetChargerType(ServiceCtx context)

{

return 0;

}

// OpenSession() -> IPsmSession

public long OpenSession(ServiceCtx context)

{

using Ryujinx.HLE.HOS.Ipc;

using Ryujinx.HLE.HOS.Kernel.Common;

using Ryujinx.HLE.HOS.Kernel.Threading;

namespace Ryujinx.HLE.HOS.Services.Psm

{

class IPsmSession : IpcService

{

private KEvent _stateChangeEvent;

private int _stateChangeEventHandle;

public IPsmSession(Horizon system)

{

_stateChangeEvent = new KEvent(system);

_stateChangeEventHandle = -1;

}

// BindStateChangeEvent() -> KObject

public long BindStateChangeEvent(ServiceCtx context)

{

return 0;

}

// UnbindStateChangeEvent()

public long UnbindStateChangeEvent(ServiceCtx context)

{

return 0;

}

// SetChargerTypeChangeEventEnabled(u8)

public long SetChargerTypeChangeEventEnabled(ServiceCtx context)

{

return 0;

}

// SetPowerSupplyChangeEventEnabled(u8)

public long SetPowerSupplyChangeEventEnabled(ServiceCtx context)

{

return 0;

}

// SetBatteryVoltageStateChangeEventEnabled(u8)

public long SetBatteryVoltageStateChangeEventEnabled(ServiceCtx context)

{

using Ryujinx.Common.Logging;

using Ryujinx.HLE.HOS.SystemState;

using System;

using static Ryujinx.HLE.HOS.ErrorCode;

[Service("set")]

class ISettingsServer : IpcService

{

// GetLanguageCode() -> nn::settings::LanguageCode

public static long GetLanguageCode(ServiceCtx context)

{

return 0;

}

// GetAvailableLanguageCodes() -> (u32, buffer<nn::settings::LanguageCode, 0xa>)

public static long GetAvailableLanguageCodes(ServiceCtx context)

{

0xF);

}

// MakeLanguageCode(nn::settings::Language language_index) -> nn::settings::LanguageCode

public static long MakeLanguageCode(ServiceCtx context)

{

return 0;

}

// GetAvailableLanguageCodeCount() -> u32

public static long GetAvailableLanguageCodeCount(ServiceCtx context)

{

return 0;

}

// GetAvailableLanguageCodes2() -> (u32, buffer<nn::settings::LanguageCode, 6>)

public static long GetAvailableLanguageCodes2(ServiceCtx context)

{

SystemStateMgr.LanguageCodes.Length);

}

// GetAvailableLanguageCodeCount2() -> u32

public static long GetAvailableLanguageCodeCount2(ServiceCtx context)

{

return 0;

}

// GetQuestFlag() -> bool

public static long GetQuestFlag(ServiceCtx context)

{

return 0;

}

}