Stubs

2025-01-09 20:29:11 +00:00 · 2023-10-21 10:42:04 -04:00 · 2023-10-21 10:42:04 -04:00 · b960597eeb
commit b960597eeb
parent 6ff239326f
5 changed files with 420 additions and 141 deletions
--- a/src/Ryujinx.Horizon/Am/Ipc/Controllers/AudioController.cs
+++ b/src/Ryujinx.Horizon/Am/Ipc/Controllers/AudioController.cs
@ -1,5 +1,5 @@
+using Ryujinx.Common.Logging;
 using Ryujinx.Horizon.Common;
-using Ryujinx.Horizon.Sdk.Am;
 using Ryujinx.Horizon.Sdk.Am.Controllers;
 using Ryujinx.Horizon.Sdk.Sf;

@ -38,12 +38,16 @@ namespace Ryujinx.Horizon.Am.Ipc.Controllers
        [CmifCommand(3)]
        public Result ChangeMainAppletMasterVolume(float volume, ulong value)
        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
            return Result.Success;
        }

        [CmifCommand(4)]
        public Result SetTransparentVolumeRate(float volume)
        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
            return Result.Success;
        }
    }
--- a/src/Ryujinx.Horizon/Am/Ipc/Controllers/CommonStateGetter.cs
+++ b/src/Ryujinx.Horizon/Am/Ipc/Controllers/CommonStateGetter.cs
@ -1,5 +1,5 @@
+using Ryujinx.Common.Logging;
 using Ryujinx.Horizon.Common;
-using Ryujinx.Horizon.Sdk.Am;
 using Ryujinx.Horizon.Sdk.Am.Controllers;
 using Ryujinx.Horizon.Sdk.Sf;

@ -10,319 +10,425 @@ namespace Ryujinx.Horizon.Am.Ipc.Controllers
        [CmifCommand(0)]
        public Result GetEventHandle()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(1)]
        public Result ReceiveMessage()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(2)]
        public Result GetThisAppletKind()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(3)]
        public Result AllowToEnterSleep()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(4)]
        public Result DisallowToEnterSleep()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(5)]
        public Result GetOperationMode()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(6)]
        public Result GetPerformanceMode()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(7)]
        public Result GetCradleStatus()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(8)]
        public Result GetBootMode()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(9)]
        public Result GetCurrentFocusState()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(10)]
        public Result RequestToAcquireSleepLock()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(11)]
        public Result ReleaseSleepLock()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(12)]
        public Result ReleaseSleepLockTransiently()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(13)]
        public Result GetAcquiredSleepLockEvent()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(14)]
        public Result GetWakeupCount()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(20)]
        public Result PushToGeneralChannel()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(30)]
        public Result GetHomeButtonReaderLockAccessor()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(31)]
        public Result GetReaderLockAccessorEx()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(32)]
        public Result GetWriterLockAccessorEx()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(40)]
        public Result GetCradleFwVersion()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(50)]
        public Result IsVrModeEnabled()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(51)]
        public Result SetVrModeEnabled()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(52)]
        public Result SetLcdBacklightOffEnabled()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(53)]
        public Result BeginVrModeEx()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(54)]
        public Result EndVrModeEx()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(55)]
        public Result IsInControllerFirmwareUpdateSection()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(59)]
        public Result SetVrPositionForDebug()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(60)]
        public Result GetDefaultDisplayResolution()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(61)]
        public Result GetDefaultDisplayResolutionChangeEvent()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(62)]
        public Result GetHdcpAuthenticationState()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(63)]
        public Result GetHdcpAuthenticationStateChangeEvent()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(64)]
        public Result SetTvPowerStateMatchingMode()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(65)]
        public Result GetApplicationIdByContentActionName()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(66)]
        public Result SetCpuBoostMode()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(67)]
        public Result CancelCpuBoostMode()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(68)]
        public Result GetBuiltInDisplayType()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(80)]
        public Result PerformSystemButtonPressingIfInFocus()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(90)]
        public Result SetPerformanceConfigurationChangedNotification()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(91)]
        public Result GetCurrentPerformanceConfiguration()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(100)]
        public Result SetHandlingHomeButtonShortPressedEnabled()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(110)]
        public Result OpenMyGpuErrorHandler()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(120)]
        public Result GetAppletLaunchedHistory()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(200)]
        public Result GetOperationModeSystemInfo()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(300)]
        public Result GetSettingsPlatformRegion()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(400)]
        public Result ActivateMigrationService()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(401)]
        public Result DeactivateMigrationService()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(500)]
        public Result DisableSleepTillShutdown()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(501)]
        public Result SuppressDisablingSleepTemporarily()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(502)]
        public Result IsSleepEnabled()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(503)]
        public Result IsDisablingSleepSuppressed()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(600)]
        public Result OpenNamedChannelAsChild()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(900)]
        public Result SetRequestExitToLibraryAppletAtExecuteNextProgramEnabled()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(910)]
        public Result GetLaunchRequiredTick()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }
    }
 }
--- a/src/Ryujinx.Horizon/Am/Ipc/Controllers/DisplayController.cs
+++ b/src/Ryujinx.Horizon/Am/Ipc/Controllers/DisplayController.cs
@ -1,3 +1,4 @@
+using Ryujinx.Common.Logging;
 using Ryujinx.Horizon.Common;
 using Ryujinx.Horizon.Sdk.Am.Controllers;
 using Ryujinx.Horizon.Sdk.Sf;
@ -9,169 +10,225 @@ namespace Ryujinx.Horizon.Am.Ipc.Controllers
        [CmifCommand(0)]
        public Result GetLastForegroundCaptureImage()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(1)]
        public Result UpdateLastForegroundCaptureImage()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(2)]
        public Result GetLastApplicationCaptureImage()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(3)]
        public Result GetCallerAppletCaptureImage()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(4)]
        public Result UpdateCallerAppletCaptureImage()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(5)]
        public Result GetLastForegroundCaptureImageEx()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(6)]
        public Result GetLastApplicationCaptureImageEx()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(7)]
        public Result GetCallerAppletCaptureImageEx()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(8)]
        public Result TakeScreenShotOfOwnLayer()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(9)]
        public Result CopyBetweenCaptureBuffers()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(10)]
        public Result AcquireLastApplicationCaptureBuffer()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(11)]
        public Result ReleaseLastApplicationCaptureBuffer()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(12)]
        public Result AcquireLastForegroundCaptureBuffer()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(13)]
        public Result ReleaseLastForegroundCaptureBuffer()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(14)]
        public Result AcquireCallerAppletCaptureBuffer()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(15)]
        public Result ReleaseCallerAppletCaptureBuffer()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(16)]
        public Result AcquireLastApplicationCaptureBufferEx()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(17)]
        public Result AcquireLastForegroundCaptureBufferEx()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(18)]
        public Result AcquireCallerAppletCaptureBufferEx()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(20)]
        public Result ClearCaptureBuffer()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(21)]
        public Result ClearAppletTransitionBuffer()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(22)]
        public Result AcquireLastApplicationCaptureSharedBuffer()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(23)]
        public Result ReleaseLastApplicationCaptureSharedBuffer()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(24)]
        public Result AcquireLastForegroundCaptureSharedBuffer()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(25)]
        public Result ReleaseLastForegroundCaptureSharedBuffer()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(26)]
        public Result AcquireCallerAppletCaptureSharedBuffer()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(27)]
        public Result ReleaseCallerAppletCaptureSharedBuffer()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(28)]
        public Result TakeScreenShotOfOwnLayerEx()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }
    }
 }
--- a/src/Ryujinx.Horizon/Am/Ipc/Controllers/SelfController.cs
+++ b/src/Ryujinx.Horizon/Am/Ipc/Controllers/SelfController.cs
@ -1,5 +1,5 @@
+using Ryujinx.Common.Logging;
 using Ryujinx.Horizon.Common;
-using Ryujinx.Horizon.Sdk.Am;
 using Ryujinx.Horizon.Sdk.Am.Controllers;
 using Ryujinx.Horizon.Sdk.Sf;

@ -10,289 +10,385 @@ namespace Ryujinx.Horizon.Am.Ipc.Controllers
        [CmifCommand(0)]
        public Result Exit()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(1)]
        public Result LockExit()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(2)]
        public Result UnlockExit()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(3)]
        public Result EnterFatalSection()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(4)]
        public Result LeaveFatalSection()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(9)]
        public Result GetLibraryAppletLaunchableEvent()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(10)]
        public Result SetScreenShotPermission()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(11)]
        public Result SetOperationModeChangedNotification()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(12)]
        public Result SetPerformanceModeChangedNotification()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(13)]
        public Result SetFocusHandlingMode()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(14)]
        public Result SetRestartMessageEnabled()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(15)]
        public Result SetScreenShotAppletIdentityInfo()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(16)]
        public Result SetOutOfFocusSuspendingEnabled()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(17)]
        public Result SetControllerFirmwareUpdateSection()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(18)]
        public Result SetRequiresCaptureButtonShortPressedMessage()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(19)]
        public Result SetAlbumImageOrientation()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(20)]
        public Result SetDesirableKeyboardLayout()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(21)]
        public Result GetScreenShotProgramId()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(40)]
        public Result CreateManagedDisplayLayer()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(41)]
        public Result IsSystemBufferSharingEnabled()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(42)]
        public Result GetSystemSharedLayerHandle()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(43)]
        public Result GetSystemSharedBufferHandle()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(44)]
        public Result CreateManagedDisplaySeparableLayer()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(45)]
        public Result SetManagedDisplayLayerSeparationMode()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(46)]
        public Result SetRecordingLayerCompositionEnabled()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(50)]
        public Result SetHandlesRequestToDisplay()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(51)]
        public Result ApproveToDisplay()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(60)]
        public Result OverrideAutoSleepTimeAndDimmingTime()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(61)]
        public Result SetMediaPlaybackState()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(62)]
        public Result SetIdleTimeDetectionExtension()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(63)]
        public Result GetIdleTimeDetectionExtension()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(64)]
        public Result SetInputDetectionSourceSet()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(65)]
        public Result ReportUserIsActive()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(66)]
        public Result GetCurrentIlluminance()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(67)]
        public Result IsIlluminanceAvailable()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(68)]
        public Result SetAutoSleepDisabled()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(69)]
        public Result IsAutoSleepDisabled()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(70)]
        public Result ReportMultimediaError()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(71)]
        public Result GetCurrentIlluminanceEx()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(72)]
        public Result SetInputDetectionPolicy()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(80)]
        public Result SetWirelessPriorityMode()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(90)]
        public Result GetAccumulatedSuspendedTickValue()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(91)]
        public Result GetAccumulatedSuspendedTickChangedEvent()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(100)]
        public Result SetAlbumImageTakenNotificationEnabled()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(110)]
        public Result SetApplicationAlbumUserData()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(120)]
        public Result SaveCurrentScreenshot()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(130)]
        public Result SetRecordVolumeMuted()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(1000)]
        public Result GetDebugStorageChannel()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }
    }
 }
--- a/src/Ryujinx.Horizon/Am/Ipc/Controllers/WindowController.cs
+++ b/src/Ryujinx.Horizon/Am/Ipc/Controllers/WindowController.cs
@ -1,5 +1,5 @@
+using Ryujinx.Common.Logging;
 using Ryujinx.Horizon.Common;
-using Ryujinx.Horizon.Sdk.Am;
 using Ryujinx.Horizon.Sdk.Am.Controllers;
 using Ryujinx.Horizon.Sdk.Sf;

@ -10,49 +10,65 @@ namespace Ryujinx.Horizon.Am.Ipc.Controllers
        [CmifCommand(0)]
        public Result CreateWindow()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(1)]
        public Result GetAppletResourceUserId()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(2)]
        public Result GetAppletResourceUserIdOfCallerApplet()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(10)]
        public Result AcquireForegroundRights()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(11)]
        public Result ReleaseForegroundRights()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(12)]
        public Result RejectToChangeIntoBackground()
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(20)]
        public Result SetAppletWindowVisibility(bool visibility)
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }

        [CmifCommand(21)]
        public Result SetAppletGpuTimeSlice(long gpuTime)
        {
-            throw new System.NotImplementedException();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+
+            return Result.Success;
        }
    }
 }