diff options
author | pineappleEA <pineaea@gmail.com> | 2024-02-14 23:38:12 +0100 |
---|---|---|
committer | pineappleEA <pineaea@gmail.com> | 2024-02-14 23:38:12 +0100 |
commit | 436a842335729861b51eb0ab3442d193c3d584a3 (patch) | |
tree | 2180fccc6118ea750f9ad98136b83acf3cd3237f | |
parent | 9cc5d38fdf3d2e8f77a7d79f937d04cdabbc3a2e (diff) |
early-access version 4140EA-4140
-rwxr-xr-x | README.md | 2 | ||||
-rwxr-xr-x | src/core/hle/service/audio/audctl.cpp | 4 | ||||
-rwxr-xr-x | src/core/hle/service/glue/time/manager.cpp | 43 | ||||
-rwxr-xr-x | src/core/hle/service/glue/time/static.cpp | 17 | ||||
-rwxr-xr-x | src/core/hle/service/glue/time/worker.cpp | 2 | ||||
-rwxr-xr-x | src/core/hle/service/mii/mii.cpp | 9 | ||||
-rwxr-xr-x | src/core/hle/service/set/setting_formats/system_settings.h | 4 | ||||
-rwxr-xr-x | src/core/hle/service/set/settings_types.h | 7 | ||||
-rwxr-xr-x | src/core/hle/service/set/system_settings_server.cpp | 1394 | ||||
-rwxr-xr-x | src/core/hle/service/set/system_settings_server.h | 208 | ||||
-rwxr-xr-x | src/hid_core/resources/hid_firmware_settings.cpp | 37 | ||||
-rwxr-xr-x | src/hid_core/resources/npad/npad_vibration.cpp | 6 | ||||
-rwxr-xr-x | src/hid_core/resources/touch_screen/touch_screen_resource.cpp | 2 |
13 files changed, 686 insertions, 1049 deletions
@@ -1,7 +1,7 @@ | |||
1 | yuzu emulator early access | 1 | yuzu emulator early access |
2 | ============= | 2 | ============= |
3 | 3 | ||
4 | This is the source code for early-access 4139. | 4 | This is the source code for early-access 4140. |
5 | 5 | ||
6 | ## Legal Notice | 6 | ## Legal Notice |
7 | 7 | ||
diff --git a/src/core/hle/service/audio/audctl.cpp b/src/core/hle/service/audio/audctl.cpp index ea8e6ca63..8649efdd5 100755 --- a/src/core/hle/service/audio/audctl.cpp +++ b/src/core/hle/service/audio/audctl.cpp | |||
@@ -106,7 +106,7 @@ void AudCtl::GetAudioOutputMode(HLERequestContext& ctx) { | |||
106 | const auto target{rp.PopEnum<Set::AudioOutputModeTarget>()}; | 106 | const auto target{rp.PopEnum<Set::AudioOutputModeTarget>()}; |
107 | 107 | ||
108 | Set::AudioOutputMode output_mode{}; | 108 | Set::AudioOutputMode output_mode{}; |
109 | const auto result = m_set_sys->GetAudioOutputMode(output_mode, target); | 109 | const auto result = m_set_sys->GetAudioOutputMode(&output_mode, target); |
110 | 110 | ||
111 | LOG_INFO(Service_SET, "called, target={}, output_mode={}", target, output_mode); | 111 | LOG_INFO(Service_SET, "called, target={}, output_mode={}", target, output_mode); |
112 | 112 | ||
@@ -188,7 +188,7 @@ void AudCtl::SetSpeakerAutoMuteEnabled(HLERequestContext& ctx) { | |||
188 | 188 | ||
189 | void AudCtl::IsSpeakerAutoMuteEnabled(HLERequestContext& ctx) { | 189 | void AudCtl::IsSpeakerAutoMuteEnabled(HLERequestContext& ctx) { |
190 | bool is_speaker_auto_mute_enabled{}; | 190 | bool is_speaker_auto_mute_enabled{}; |
191 | const auto result = m_set_sys->GetSpeakerAutoMuteFlag(is_speaker_auto_mute_enabled); | 191 | const auto result = m_set_sys->GetSpeakerAutoMuteFlag(&is_speaker_auto_mute_enabled); |
192 | 192 | ||
193 | LOG_WARNING(Audio, "(STUBBED) called, is_speaker_auto_mute_enabled={}", | 193 | LOG_WARNING(Audio, "(STUBBED) called, is_speaker_auto_mute_enabled={}", |
194 | is_speaker_auto_mute_enabled); | 194 | is_speaker_auto_mute_enabled); |
diff --git a/src/core/hle/service/glue/time/manager.cpp b/src/core/hle/service/glue/time/manager.cpp index 0c27e8029..cad755fa7 100755 --- a/src/core/hle/service/glue/time/manager.cpp +++ b/src/core/hle/service/glue/time/manager.cpp | |||
@@ -21,19 +21,6 @@ | |||
21 | 21 | ||
22 | namespace Service::Glue::Time { | 22 | namespace Service::Glue::Time { |
23 | namespace { | 23 | namespace { |
24 | |||
25 | template <typename T> | ||
26 | T GetSettingsItemValue(std::shared_ptr<Service::Set::ISystemSettingsServer>& set_sys, | ||
27 | const char* category, const char* name) { | ||
28 | std::vector<u8> interval_buf; | ||
29 | auto res = set_sys->GetSettingsItemValue(interval_buf, category, name); | ||
30 | ASSERT(res == ResultSuccess); | ||
31 | |||
32 | T v{}; | ||
33 | std::memcpy(&v, interval_buf.data(), sizeof(T)); | ||
34 | return v; | ||
35 | } | ||
36 | |||
37 | s64 CalendarTimeToEpoch(Service::PSC::Time::CalendarTime calendar) { | 24 | s64 CalendarTimeToEpoch(Service::PSC::Time::CalendarTime calendar) { |
38 | constexpr auto is_leap = [](s32 year) -> bool { | 25 | constexpr auto is_leap = [](s32 year) -> bool { |
39 | return (((year) % 4) == 0 && (((year) % 100) != 0 || ((year) % 400) == 0)); | 26 | return (((year) % 4) == 0 && (((year) % 100) != 0 || ((year) % 400) == 0)); |
@@ -65,13 +52,15 @@ s64 CalendarTimeToEpoch(Service::PSC::Time::CalendarTime calendar) { | |||
65 | 52 | ||
66 | s64 GetEpochTimeFromInitialYear(std::shared_ptr<Service::Set::ISystemSettingsServer>& set_sys) { | 53 | s64 GetEpochTimeFromInitialYear(std::shared_ptr<Service::Set::ISystemSettingsServer>& set_sys) { |
67 | Service::PSC::Time::CalendarTime calendar{ | 54 | Service::PSC::Time::CalendarTime calendar{ |
68 | .year = GetSettingsItemValue<s16>(set_sys, "time", "standard_user_clock_initial_year"), | 55 | .year = 2000, |
69 | .month = 1, | 56 | .month = 1, |
70 | .day = 1, | 57 | .day = 1, |
71 | .hour = 0, | 58 | .hour = 0, |
72 | .minute = 0, | 59 | .minute = 0, |
73 | .second = 0, | 60 | .second = 0, |
74 | }; | 61 | }; |
62 | set_sys->GetSettingsItemValueImpl<s16>(calendar.year, "time", | ||
63 | "standard_user_clock_initial_year"); | ||
75 | return CalendarTimeToEpoch(calendar); | 64 | return CalendarTimeToEpoch(calendar); |
76 | } | 65 | } |
77 | 66 | ||
@@ -124,7 +113,7 @@ TimeManager::TimeManager(Core::System& system) | |||
124 | ASSERT(res == ResultSuccess); | 113 | ASSERT(res == ResultSuccess); |
125 | 114 | ||
126 | Service::PSC::Time::SystemClockContext user_clock_context{}; | 115 | Service::PSC::Time::SystemClockContext user_clock_context{}; |
127 | res = m_set_sys->GetUserSystemClockContext(user_clock_context); | 116 | res = m_set_sys->GetUserSystemClockContext(&user_clock_context); |
128 | ASSERT(res == ResultSuccess); | 117 | ASSERT(res == ResultSuccess); |
129 | 118 | ||
130 | // TODO the local clock should initialise with this epoch time, and be updated somewhere else on | 119 | // TODO the local clock should initialise with this epoch time, and be updated somewhere else on |
@@ -140,11 +129,12 @@ TimeManager::TimeManager(Core::System& system) | |||
140 | ASSERT(res == ResultSuccess); | 129 | ASSERT(res == ResultSuccess); |
141 | 130 | ||
142 | Service::PSC::Time::SystemClockContext network_clock_context{}; | 131 | Service::PSC::Time::SystemClockContext network_clock_context{}; |
143 | res = m_set_sys->GetNetworkSystemClockContext(network_clock_context); | 132 | res = m_set_sys->GetNetworkSystemClockContext(&network_clock_context); |
144 | ASSERT(res == ResultSuccess); | 133 | ASSERT(res == ResultSuccess); |
145 | 134 | ||
146 | auto network_accuracy_m{GetSettingsItemValue<s32>( | 135 | s32 network_accuracy_m{}; |
147 | m_set_sys, "time", "standard_network_clock_sufficient_accuracy_minutes")}; | 136 | m_set_sys->GetSettingsItemValueImpl<s32>(network_accuracy_m, "time", |
137 | "standard_network_clock_sufficient_accuracy_minutes"); | ||
148 | auto one_minute_ns{ | 138 | auto one_minute_ns{ |
149 | std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::minutes(1)).count()}; | 139 | std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::minutes(1)).count()}; |
150 | s64 network_accuracy_ns{network_accuracy_m * one_minute_ns}; | 140 | s64 network_accuracy_ns{network_accuracy_m * one_minute_ns}; |
@@ -153,12 +143,12 @@ TimeManager::TimeManager(Core::System& system) | |||
153 | ASSERT(res == ResultSuccess); | 143 | ASSERT(res == ResultSuccess); |
154 | 144 | ||
155 | bool is_automatic_correction_enabled{}; | 145 | bool is_automatic_correction_enabled{}; |
156 | res = m_set_sys->IsUserSystemClockAutomaticCorrectionEnabled(is_automatic_correction_enabled); | 146 | res = m_set_sys->IsUserSystemClockAutomaticCorrectionEnabled(&is_automatic_correction_enabled); |
157 | ASSERT(res == ResultSuccess); | 147 | ASSERT(res == ResultSuccess); |
158 | 148 | ||
159 | Service::PSC::Time::SteadyClockTimePoint automatic_correction_time_point{}; | 149 | Service::PSC::Time::SteadyClockTimePoint automatic_correction_time_point{}; |
160 | res = m_set_sys->GetUserSystemClockAutomaticCorrectionUpdatedTime( | 150 | res = m_set_sys->GetUserSystemClockAutomaticCorrectionUpdatedTime( |
161 | automatic_correction_time_point); | 151 | &automatic_correction_time_point); |
162 | ASSERT(res == ResultSuccess); | 152 | ASSERT(res == ResultSuccess); |
163 | 153 | ||
164 | res = m_time_m->SetupStandardUserSystemClockCore(is_automatic_correction_enabled, | 154 | res = m_time_m->SetupStandardUserSystemClockCore(is_automatic_correction_enabled, |
@@ -198,11 +188,11 @@ TimeManager::TimeManager(Core::System& system) | |||
198 | 188 | ||
199 | Result TimeManager::SetupStandardSteadyClockCore() { | 189 | Result TimeManager::SetupStandardSteadyClockCore() { |
200 | Common::UUID external_clock_source_id{}; | 190 | Common::UUID external_clock_source_id{}; |
201 | auto res = m_set_sys->GetExternalSteadyClockSourceId(external_clock_source_id); | 191 | auto res = m_set_sys->GetExternalSteadyClockSourceId(&external_clock_source_id); |
202 | ASSERT(res == ResultSuccess); | 192 | ASSERT(res == ResultSuccess); |
203 | 193 | ||
204 | s64 external_steady_clock_internal_offset_s{}; | 194 | s64 external_steady_clock_internal_offset_s{}; |
205 | res = m_set_sys->GetExternalSteadyClockInternalOffset(external_steady_clock_internal_offset_s); | 195 | res = m_set_sys->GetExternalSteadyClockInternalOffset(&external_steady_clock_internal_offset_s); |
206 | ASSERT(res == ResultSuccess); | 196 | ASSERT(res == ResultSuccess); |
207 | 197 | ||
208 | auto one_second_ns{ | 198 | auto one_second_ns{ |
@@ -210,8 +200,9 @@ Result TimeManager::SetupStandardSteadyClockCore() { | |||
210 | s64 external_steady_clock_internal_offset_ns{external_steady_clock_internal_offset_s * | 200 | s64 external_steady_clock_internal_offset_ns{external_steady_clock_internal_offset_s * |
211 | one_second_ns}; | 201 | one_second_ns}; |
212 | 202 | ||
213 | s32 standard_steady_clock_test_offset_m{ | 203 | s32 standard_steady_clock_test_offset_m{}; |
214 | GetSettingsItemValue<s32>(m_set_sys, "time", "standard_steady_clock_test_offset_minutes")}; | 204 | m_set_sys->GetSettingsItemValueImpl<s32>(standard_steady_clock_test_offset_m, "time", |
205 | "standard_steady_clock_test_offset_minutes"); | ||
215 | auto one_minute_ns{ | 206 | auto one_minute_ns{ |
216 | std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::minutes(1)).count()}; | 207 | std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::minutes(1)).count()}; |
217 | s64 standard_steady_clock_test_offset_ns{standard_steady_clock_test_offset_m * one_minute_ns}; | 208 | s64 standard_steady_clock_test_offset_ns{standard_steady_clock_test_offset_m * one_minute_ns}; |
@@ -237,7 +228,7 @@ Result TimeManager::SetupStandardSteadyClockCore() { | |||
237 | 228 | ||
238 | Result TimeManager::SetupTimeZoneServiceCore() { | 229 | Result TimeManager::SetupTimeZoneServiceCore() { |
239 | Service::PSC::Time::LocationName name{}; | 230 | Service::PSC::Time::LocationName name{}; |
240 | auto res = m_set_sys->GetDeviceTimeZoneLocationName(name); | 231 | auto res = m_set_sys->GetDeviceTimeZoneLocationName(&name); |
241 | ASSERT(res == ResultSuccess); | 232 | ASSERT(res == ResultSuccess); |
242 | 233 | ||
243 | auto configured_zone = GetTimeZoneString(name); | 234 | auto configured_zone = GetTimeZoneString(name); |
@@ -255,7 +246,7 @@ Result TimeManager::SetupTimeZoneServiceCore() { | |||
255 | } | 246 | } |
256 | 247 | ||
257 | Service::PSC::Time::SteadyClockTimePoint time_point{}; | 248 | Service::PSC::Time::SteadyClockTimePoint time_point{}; |
258 | res = m_set_sys->GetDeviceTimeZoneLocationUpdatedTime(time_point); | 249 | res = m_set_sys->GetDeviceTimeZoneLocationUpdatedTime(&time_point); |
259 | ASSERT(res == ResultSuccess); | 250 | ASSERT(res == ResultSuccess); |
260 | 251 | ||
261 | auto location_count = GetTimeZoneCount(); | 252 | auto location_count = GetTimeZoneCount(); |
diff --git a/src/core/hle/service/glue/time/static.cpp b/src/core/hle/service/glue/time/static.cpp index f8c1218f3..ec9b0efb1 100755 --- a/src/core/hle/service/glue/time/static.cpp +++ b/src/core/hle/service/glue/time/static.cpp | |||
@@ -20,19 +20,6 @@ | |||
20 | #include "core/hle/service/sm/sm.h" | 20 | #include "core/hle/service/sm/sm.h" |
21 | 21 | ||
22 | namespace Service::Glue::Time { | 22 | namespace Service::Glue::Time { |
23 | namespace { | ||
24 | template <typename T> | ||
25 | T GetSettingsItemValue(std::shared_ptr<Service::Set::ISystemSettingsServer>& set_sys, | ||
26 | const char* category, const char* name) { | ||
27 | std::vector<u8> interval_buf; | ||
28 | auto res = set_sys->GetSettingsItemValue(interval_buf, category, name); | ||
29 | ASSERT(res == ResultSuccess); | ||
30 | |||
31 | T v{}; | ||
32 | std::memcpy(&v, interval_buf.data(), sizeof(T)); | ||
33 | return v; | ||
34 | } | ||
35 | } // namespace | ||
36 | 23 | ||
37 | StaticService::StaticService(Core::System& system_, | 24 | StaticService::StaticService(Core::System& system_, |
38 | Service::PSC::Time::StaticServiceSetupInfo setup_info, | 25 | Service::PSC::Time::StaticServiceSetupInfo setup_info, |
@@ -181,8 +168,8 @@ Result StaticService::SetStandardUserSystemClockAutomaticCorrectionEnabled( | |||
181 | Result StaticService::GetStandardUserSystemClockInitialYear(Out<s32> out_year) { | 168 | Result StaticService::GetStandardUserSystemClockInitialYear(Out<s32> out_year) { |
182 | SCOPE_EXIT({ LOG_DEBUG(Service_Time, "called. out_year={}", *out_year); }); | 169 | SCOPE_EXIT({ LOG_DEBUG(Service_Time, "called. out_year={}", *out_year); }); |
183 | 170 | ||
184 | *out_year = GetSettingsItemValue<s32>(m_set_sys, "time", "standard_user_clock_initial_year"); | 171 | R_RETURN(m_set_sys->GetSettingsItemValueImpl<s32>(*out_year, "time", |
185 | R_SUCCEED(); | 172 | "standard_user_clock_initial_year")); |
186 | } | 173 | } |
187 | 174 | ||
188 | Result StaticService::IsStandardNetworkSystemClockAccuracySufficient(Out<bool> out_is_sufficient) { | 175 | Result StaticService::IsStandardNetworkSystemClockAccuracySufficient(Out<bool> out_is_sufficient) { |
diff --git a/src/core/hle/service/glue/time/worker.cpp b/src/core/hle/service/glue/time/worker.cpp index 8787f2dcd..b28569b68 100755 --- a/src/core/hle/service/glue/time/worker.cpp +++ b/src/core/hle/service/glue/time/worker.cpp | |||
@@ -27,7 +27,7 @@ template <typename T> | |||
27 | T GetSettingsItemValue(std::shared_ptr<Service::Set::ISystemSettingsServer>& set_sys, | 27 | T GetSettingsItemValue(std::shared_ptr<Service::Set::ISystemSettingsServer>& set_sys, |
28 | const char* category, const char* name) { | 28 | const char* category, const char* name) { |
29 | std::vector<u8> interval_buf; | 29 | std::vector<u8> interval_buf; |
30 | auto res = set_sys->GetSettingsItemValue(interval_buf, category, name); | 30 | auto res = set_sys->GetSettingsItemValueImpl(interval_buf, category, name); |
31 | ASSERT(res == ResultSuccess); | 31 | ASSERT(res == ResultSuccess); |
32 | 32 | ||
33 | T v{}; | 33 | T v{}; |
diff --git a/src/core/hle/service/mii/mii.cpp b/src/core/hle/service/mii/mii.cpp index f2b3dce64..e44d7f198 100755 --- a/src/core/hle/service/mii/mii.cpp +++ b/src/core/hle/service/mii/mii.cpp | |||
@@ -207,7 +207,8 @@ private: | |||
207 | 207 | ||
208 | Result DestroyFile() { | 208 | Result DestroyFile() { |
209 | bool is_db_test_mode_enabled{}; | 209 | bool is_db_test_mode_enabled{}; |
210 | m_set_sys->GetSettingsItemValue(is_db_test_mode_enabled, "mii", "is_db_test_mode_enabled"); | 210 | m_set_sys->GetSettingsItemValueImpl(is_db_test_mode_enabled, "mii", |
211 | "is_db_test_mode_enabled"); | ||
211 | 212 | ||
212 | LOG_INFO(Service_Mii, "called is_db_test_mode_enabled={}", is_db_test_mode_enabled); | 213 | LOG_INFO(Service_Mii, "called is_db_test_mode_enabled={}", is_db_test_mode_enabled); |
213 | R_UNLESS(is_db_test_mode_enabled, ResultTestModeOnly); | 214 | R_UNLESS(is_db_test_mode_enabled, ResultTestModeOnly); |
@@ -217,7 +218,8 @@ private: | |||
217 | 218 | ||
218 | Result DeleteFile() { | 219 | Result DeleteFile() { |
219 | bool is_db_test_mode_enabled{}; | 220 | bool is_db_test_mode_enabled{}; |
220 | m_set_sys->GetSettingsItemValue(is_db_test_mode_enabled, "mii", "is_db_test_mode_enabled"); | 221 | m_set_sys->GetSettingsItemValueImpl(is_db_test_mode_enabled, "mii", |
222 | "is_db_test_mode_enabled"); | ||
221 | 223 | ||
222 | LOG_INFO(Service_Mii, "called is_db_test_mode_enabled={}", is_db_test_mode_enabled); | 224 | LOG_INFO(Service_Mii, "called is_db_test_mode_enabled={}", is_db_test_mode_enabled); |
223 | R_UNLESS(is_db_test_mode_enabled, ResultTestModeOnly); | 225 | R_UNLESS(is_db_test_mode_enabled, ResultTestModeOnly); |
@@ -227,7 +229,8 @@ private: | |||
227 | 229 | ||
228 | Result Format() { | 230 | Result Format() { |
229 | bool is_db_test_mode_enabled{}; | 231 | bool is_db_test_mode_enabled{}; |
230 | m_set_sys->GetSettingsItemValue(is_db_test_mode_enabled, "mii", "is_db_test_mode_enabled"); | 232 | m_set_sys->GetSettingsItemValueImpl(is_db_test_mode_enabled, "mii", |
233 | "is_db_test_mode_enabled"); | ||
231 | 234 | ||
232 | LOG_INFO(Service_Mii, "called is_db_test_mode_enabled={}", is_db_test_mode_enabled); | 235 | LOG_INFO(Service_Mii, "called is_db_test_mode_enabled={}", is_db_test_mode_enabled); |
233 | R_UNLESS(is_db_test_mode_enabled, ResultTestModeOnly); | 236 | R_UNLESS(is_db_test_mode_enabled, ResultTestModeOnly); |
diff --git a/src/core/hle/service/set/setting_formats/system_settings.h b/src/core/hle/service/set/setting_formats/system_settings.h index 40230182a..a5b1552a5 100755 --- a/src/core/hle/service/set/setting_formats/system_settings.h +++ b/src/core/hle/service/set/setting_formats/system_settings.h | |||
@@ -244,7 +244,7 @@ struct SystemSettings { | |||
244 | INSERT_PADDING_BYTES(0x60); // Reserved | 244 | INSERT_PADDING_BYTES(0x60); // Reserved |
245 | 245 | ||
246 | // nn::settings::system::AccountNotificationSettings | 246 | // nn::settings::system::AccountNotificationSettings |
247 | u32 account_notification_settings_count; | 247 | s32 account_notification_settings_count; |
248 | INSERT_PADDING_BYTES(0xC); // Reserved | 248 | INSERT_PADDING_BYTES(0xC); // Reserved |
249 | std::array<AccountNotificationSettings, 8> account_notification_settings; | 249 | std::array<AccountNotificationSettings, 8> account_notification_settings; |
250 | INSERT_PADDING_BYTES(0x140); // Reserved | 250 | INSERT_PADDING_BYTES(0x140); // Reserved |
@@ -308,7 +308,7 @@ struct SystemSettings { | |||
308 | INSERT_PADDING_BYTES(0x34); // Reserved | 308 | INSERT_PADDING_BYTES(0x34); // Reserved |
309 | 309 | ||
310 | // nn::settings::system::EulaVersion | 310 | // nn::settings::system::EulaVersion |
311 | u32 eula_version_count; | 311 | s32 eula_version_count; |
312 | INSERT_PADDING_BYTES(0xC); // Reserved | 312 | INSERT_PADDING_BYTES(0xC); // Reserved |
313 | std::array<EulaVersion, 32> eula_versions; | 313 | std::array<EulaVersion, 32> eula_versions; |
314 | INSERT_PADDING_BYTES(0x200); // Reserved | 314 | INSERT_PADDING_BYTES(0x200); // Reserved |
diff --git a/src/core/hle/service/set/settings_types.h b/src/core/hle/service/set/settings_types.h index 83ef6635b..29664e88c 100755 --- a/src/core/hle/service/set/settings_types.h +++ b/src/core/hle/service/set/settings_types.h | |||
@@ -12,6 +12,7 @@ | |||
12 | #include "core/hle/service/psc/time/common.h" | 12 | #include "core/hle/service/psc/time/common.h" |
13 | 13 | ||
14 | namespace Service::Set { | 14 | namespace Service::Set { |
15 | using SettingItemName = std::array<u8, 0x48>; | ||
15 | 16 | ||
16 | /// This is nn::settings::system::AudioOutputMode | 17 | /// This is nn::settings::system::AudioOutputMode |
17 | enum class AudioOutputMode : u32 { | 18 | enum class AudioOutputMode : u32 { |
@@ -413,16 +414,18 @@ struct FirmwareVersionFormat { | |||
413 | u8 major; | 414 | u8 major; |
414 | u8 minor; | 415 | u8 minor; |
415 | u8 micro; | 416 | u8 micro; |
416 | INSERT_PADDING_BYTES(1); | 417 | INSERT_PADDING_BYTES_NOINIT(1); |
417 | u8 revision_major; | 418 | u8 revision_major; |
418 | u8 revision_minor; | 419 | u8 revision_minor; |
419 | INSERT_PADDING_BYTES(2); | 420 | INSERT_PADDING_BYTES_NOINIT(2); |
420 | std::array<char, 0x20> platform; | 421 | std::array<char, 0x20> platform; |
421 | std::array<u8, 0x40> version_hash; | 422 | std::array<u8, 0x40> version_hash; |
422 | std::array<char, 0x18> display_version; | 423 | std::array<char, 0x18> display_version; |
423 | std::array<char, 0x80> display_title; | 424 | std::array<char, 0x80> display_title; |
424 | }; | 425 | }; |
425 | static_assert(sizeof(FirmwareVersionFormat) == 0x100, "FirmwareVersionFormat is an invalid size"); | 426 | static_assert(sizeof(FirmwareVersionFormat) == 0x100, "FirmwareVersionFormat is an invalid size"); |
427 | static_assert(std::is_trivial_v<FirmwareVersionFormat>, | ||
428 | "FirmwareVersionFormat type must be trivially copyable."); | ||
426 | 429 | ||
427 | /// This is nn::settings::system::HomeMenuScheme | 430 | /// This is nn::settings::system::HomeMenuScheme |
428 | struct HomeMenuScheme { | 431 | struct HomeMenuScheme { |
diff --git a/src/core/hle/service/set/system_settings_server.cpp b/src/core/hle/service/set/system_settings_server.cpp index 7ef4a0ded..93925f783 100755 --- a/src/core/hle/service/set/system_settings_server.cpp +++ b/src/core/hle/service/set/system_settings_server.cpp | |||
@@ -17,6 +17,7 @@ | |||
17 | #include "core/file_sys/registered_cache.h" | 17 | #include "core/file_sys/registered_cache.h" |
18 | #include "core/file_sys/romfs.h" | 18 | #include "core/file_sys/romfs.h" |
19 | #include "core/file_sys/system_archive/system_archive.h" | 19 | #include "core/file_sys/system_archive/system_archive.h" |
20 | #include "core/hle/service/cmif_serialization.h" | ||
20 | #include "core/hle/service/filesystem/filesystem.h" | 21 | #include "core/hle/service/filesystem/filesystem.h" |
21 | #include "core/hle/service/ipc_helpers.h" | 22 | #include "core/hle/service/ipc_helpers.h" |
22 | #include "core/hle/service/set/settings_server.h" | 23 | #include "core/hle/service/set/settings_server.h" |
@@ -91,83 +92,83 @@ ISystemSettingsServer::ISystemSettingsServer(Core::System& system_) | |||
91 | : ServiceFramework{system_, "set:sys"}, m_system{system} { | 92 | : ServiceFramework{system_, "set:sys"}, m_system{system} { |
92 | // clang-format off | 93 | // clang-format off |
93 | static const FunctionInfo functions[] = { | 94 | static const FunctionInfo functions[] = { |
94 | {0, &ISystemSettingsServer::SetLanguageCode, "SetLanguageCode"}, | 95 | {0, C<&ISystemSettingsServer::SetLanguageCode>, "SetLanguageCode"}, |
95 | {1, nullptr, "SetNetworkSettings"}, | 96 | {1, nullptr, "SetNetworkSettings"}, |
96 | {2, nullptr, "GetNetworkSettings"}, | 97 | {2, nullptr, "GetNetworkSettings"}, |
97 | {3, &ISystemSettingsServer::GetFirmwareVersion, "GetFirmwareVersion"}, | 98 | {3, C<&ISystemSettingsServer::GetFirmwareVersion>, "GetFirmwareVersion"}, |
98 | {4, &ISystemSettingsServer::GetFirmwareVersion2, "GetFirmwareVersion2"}, | 99 | {4, C<&ISystemSettingsServer::GetFirmwareVersion2>, "GetFirmwareVersion2"}, |
99 | {5, nullptr, "GetFirmwareVersionDigest"}, | 100 | {5, nullptr, "GetFirmwareVersionDigest"}, |
100 | {7, &ISystemSettingsServer::GetLockScreenFlag, "GetLockScreenFlag"}, | 101 | {7, C<&ISystemSettingsServer::GetLockScreenFlag>, "GetLockScreenFlag"}, |
101 | {8, &ISystemSettingsServer::SetLockScreenFlag, "SetLockScreenFlag"}, | 102 | {8, C<&ISystemSettingsServer::SetLockScreenFlag>, "SetLockScreenFlag"}, |
102 | {9, nullptr, "GetBacklightSettings"}, | 103 | {9, nullptr, "GetBacklightSettings"}, |
103 | {10, nullptr, "SetBacklightSettings"}, | 104 | {10, nullptr, "SetBacklightSettings"}, |
104 | {11, nullptr, "SetBluetoothDevicesSettings"}, | 105 | {11, nullptr, "SetBluetoothDevicesSettings"}, |
105 | {12, nullptr, "GetBluetoothDevicesSettings"}, | 106 | {12, nullptr, "GetBluetoothDevicesSettings"}, |
106 | {13, &ISystemSettingsServer::GetExternalSteadyClockSourceId, "GetExternalSteadyClockSourceId"}, | 107 | {13, C<&ISystemSettingsServer::GetExternalSteadyClockSourceId>, "GetExternalSteadyClockSourceId"}, |
107 | {14, &ISystemSettingsServer::SetExternalSteadyClockSourceId, "SetExternalSteadyClockSourceId"}, | 108 | {14, C<&ISystemSettingsServer::SetExternalSteadyClockSourceId>, "SetExternalSteadyClockSourceId"}, |
108 | {15, &ISystemSettingsServer::GetUserSystemClockContext, "GetUserSystemClockContext"}, | 109 | {15, C<&ISystemSettingsServer::GetUserSystemClockContext>, "GetUserSystemClockContext"}, |
109 | {16, &ISystemSettingsServer::SetUserSystemClockContext, "SetUserSystemClockContext"}, | 110 | {16, C<&ISystemSettingsServer::SetUserSystemClockContext>, "SetUserSystemClockContext"}, |
110 | {17, &ISystemSettingsServer::GetAccountSettings, "GetAccountSettings"}, | 111 | {17, C<&ISystemSettingsServer::GetAccountSettings>, "GetAccountSettings"}, |
111 | {18, &ISystemSettingsServer::SetAccountSettings, "SetAccountSettings"}, | 112 | {18, C<&ISystemSettingsServer::SetAccountSettings>, "SetAccountSettings"}, |
112 | {19, nullptr, "GetAudioVolume"}, | 113 | {19, nullptr, "GetAudioVolume"}, |
113 | {20, nullptr, "SetAudioVolume"}, | 114 | {20, nullptr, "SetAudioVolume"}, |
114 | {21, &ISystemSettingsServer::GetEulaVersions, "GetEulaVersions"}, | 115 | {21, C<&ISystemSettingsServer::GetEulaVersions>, "GetEulaVersions"}, |
115 | {22, &ISystemSettingsServer::SetEulaVersions, "SetEulaVersions"}, | 116 | {22, C<&ISystemSettingsServer::SetEulaVersions>, "SetEulaVersions"}, |
116 | {23, &ISystemSettingsServer::GetColorSetId, "GetColorSetId"}, | 117 | {23, C<&ISystemSettingsServer::GetColorSetId>, "GetColorSetId"}, |
117 | {24, &ISystemSettingsServer::SetColorSetId, "SetColorSetId"}, | 118 | {24, C<&ISystemSettingsServer::SetColorSetId>, "SetColorSetId"}, |
118 | {25, nullptr, "GetConsoleInformationUploadFlag"}, | 119 | {25, nullptr, "GetConsoleInformationUploadFlag"}, |
119 | {26, nullptr, "SetConsoleInformationUploadFlag"}, | 120 | {26, nullptr, "SetConsoleInformationUploadFlag"}, |
120 | {27, nullptr, "GetAutomaticApplicationDownloadFlag"}, | 121 | {27, nullptr, "GetAutomaticApplicationDownloadFlag"}, |
121 | {28, nullptr, "SetAutomaticApplicationDownloadFlag"}, | 122 | {28, nullptr, "SetAutomaticApplicationDownloadFlag"}, |
122 | {29, &ISystemSettingsServer::GetNotificationSettings, "GetNotificationSettings"}, | 123 | {29, C<&ISystemSettingsServer::GetNotificationSettings>, "GetNotificationSettings"}, |
123 | {30, &ISystemSettingsServer::SetNotificationSettings, "SetNotificationSettings"}, | 124 | {30, C<&ISystemSettingsServer::SetNotificationSettings>, "SetNotificationSettings"}, |
124 | {31, &ISystemSettingsServer::GetAccountNotificationSettings, "GetAccountNotificationSettings"}, | 125 | {31, C<&ISystemSettingsServer::GetAccountNotificationSettings>, "GetAccountNotificationSettings"}, |
125 | {32, &ISystemSettingsServer::SetAccountNotificationSettings, "SetAccountNotificationSettings"}, | 126 | {32, C<&ISystemSettingsServer::SetAccountNotificationSettings>, "SetAccountNotificationSettings"}, |
126 | {35, &ISystemSettingsServer::GetVibrationMasterVolume, "GetVibrationMasterVolume"}, | 127 | {35, C<&ISystemSettingsServer::GetVibrationMasterVolume>, "GetVibrationMasterVolume"}, |
127 | {36, &ISystemSettingsServer::SetVibrationMasterVolume, "SetVibrationMasterVolume"}, | 128 | {36, C<&ISystemSettingsServer::SetVibrationMasterVolume>, "SetVibrationMasterVolume"}, |
128 | {37, &ISystemSettingsServer::GetSettingsItemValueSize, "GetSettingsItemValueSize"}, | 129 | {37, C<&ISystemSettingsServer::GetSettingsItemValueSize>, "GetSettingsItemValueSize"}, |
129 | {38, &ISystemSettingsServer::GetSettingsItemValue, "GetSettingsItemValue"}, | 130 | {38, C<&ISystemSettingsServer::GetSettingsItemValue>, "GetSettingsItemValue"}, |
130 | {39, &ISystemSettingsServer::GetTvSettings, "GetTvSettings"}, | 131 | {39, C<&ISystemSettingsServer::GetTvSettings>, "GetTvSettings"}, |
131 | {40, &ISystemSettingsServer::SetTvSettings, "SetTvSettings"}, | 132 | {40, C<&ISystemSettingsServer::SetTvSettings>, "SetTvSettings"}, |
132 | {41, nullptr, "GetEdid"}, | 133 | {41, nullptr, "GetEdid"}, |
133 | {42, nullptr, "SetEdid"}, | 134 | {42, nullptr, "SetEdid"}, |
134 | {43, &ISystemSettingsServer::GetAudioOutputMode, "GetAudioOutputMode"}, | 135 | {43, C<&ISystemSettingsServer::GetAudioOutputMode>, "GetAudioOutputMode"}, |
135 | {44, &ISystemSettingsServer::SetAudioOutputMode, "SetAudioOutputMode"}, | 136 | {44, C<&ISystemSettingsServer::SetAudioOutputMode>, "SetAudioOutputMode"}, |
136 | {45, &ISystemSettingsServer::GetSpeakerAutoMuteFlag , "GetSpeakerAutoMuteFlag"}, | 137 | {45, C<&ISystemSettingsServer::GetSpeakerAutoMuteFlag> , "GetSpeakerAutoMuteFlag"}, |
137 | {46, &ISystemSettingsServer::SetSpeakerAutoMuteFlag , "SetSpeakerAutoMuteFlag"}, | 138 | {46, C<&ISystemSettingsServer::SetSpeakerAutoMuteFlag> , "SetSpeakerAutoMuteFlag"}, |
138 | {47, &ISystemSettingsServer::GetQuestFlag, "GetQuestFlag"}, | 139 | {47, C<&ISystemSettingsServer::GetQuestFlag>, "GetQuestFlag"}, |
139 | {48, &ISystemSettingsServer::SetQuestFlag, "SetQuestFlag"}, | 140 | {48, C<&ISystemSettingsServer::SetQuestFlag>, "SetQuestFlag"}, |
140 | {49, nullptr, "GetDataDeletionSettings"}, | 141 | {49, nullptr, "GetDataDeletionSettings"}, |
141 | {50, nullptr, "SetDataDeletionSettings"}, | 142 | {50, nullptr, "SetDataDeletionSettings"}, |
142 | {51, nullptr, "GetInitialSystemAppletProgramId"}, | 143 | {51, nullptr, "GetInitialSystemAppletProgramId"}, |
143 | {52, nullptr, "GetOverlayDispProgramId"}, | 144 | {52, nullptr, "GetOverlayDispProgramId"}, |
144 | {53, &ISystemSettingsServer::GetDeviceTimeZoneLocationName, "GetDeviceTimeZoneLocationName"}, | 145 | {53, C<&ISystemSettingsServer::GetDeviceTimeZoneLocationName>, "GetDeviceTimeZoneLocationName"}, |
145 | {54, &ISystemSettingsServer::SetDeviceTimeZoneLocationName, "SetDeviceTimeZoneLocationName"}, | 146 | {54, C<&ISystemSettingsServer::SetDeviceTimeZoneLocationName>, "SetDeviceTimeZoneLocationName"}, |
146 | {55, nullptr, "GetWirelessCertificationFileSize"}, | 147 | {55, nullptr, "GetWirelessCertificationFileSize"}, |
147 | {56, nullptr, "GetWirelessCertificationFile"}, | 148 | {56, nullptr, "GetWirelessCertificationFile"}, |
148 | {57, &ISystemSettingsServer::SetRegionCode, "SetRegionCode"}, | 149 | {57, C<&ISystemSettingsServer::SetRegionCode>, "SetRegionCode"}, |
149 | {58, &ISystemSettingsServer::GetNetworkSystemClockContext, "GetNetworkSystemClockContext"}, | 150 | {58, C<&ISystemSettingsServer::GetNetworkSystemClockContext>, "GetNetworkSystemClockContext"}, |
150 | {59, &ISystemSettingsServer::SetNetworkSystemClockContext, "SetNetworkSystemClockContext"}, | 151 | {59, C<&ISystemSettingsServer::SetNetworkSystemClockContext>, "SetNetworkSystemClockContext"}, |
151 | {60, &ISystemSettingsServer::IsUserSystemClockAutomaticCorrectionEnabled, "IsUserSystemClockAutomaticCorrectionEnabled"}, | 152 | {60, C<&ISystemSettingsServer::IsUserSystemClockAutomaticCorrectionEnabled>, "IsUserSystemClockAutomaticCorrectionEnabled"}, |
152 | {61, &ISystemSettingsServer::SetUserSystemClockAutomaticCorrectionEnabled, "SetUserSystemClockAutomaticCorrectionEnabled"}, | 153 | {61, C<&ISystemSettingsServer::SetUserSystemClockAutomaticCorrectionEnabled>, "SetUserSystemClockAutomaticCorrectionEnabled"}, |
153 | {62, &ISystemSettingsServer::GetDebugModeFlag, "GetDebugModeFlag"}, | 154 | {62, C<&ISystemSettingsServer::GetDebugModeFlag>, "GetDebugModeFlag"}, |
154 | {63, &ISystemSettingsServer::GetPrimaryAlbumStorage, "GetPrimaryAlbumStorage"}, | 155 | {63, C<&ISystemSettingsServer::GetPrimaryAlbumStorage>, "GetPrimaryAlbumStorage"}, |
155 | {64, &ISystemSettingsServer::SetPrimaryAlbumStorage, "SetPrimaryAlbumStorage"}, | 156 | {64, C<&ISystemSettingsServer::SetPrimaryAlbumStorage>, "SetPrimaryAlbumStorage"}, |
156 | {65, nullptr, "GetUsb30EnableFlag"}, | 157 | {65, nullptr, "GetUsb30EnableFlag"}, |
157 | {66, nullptr, "SetUsb30EnableFlag"}, | 158 | {66, nullptr, "SetUsb30EnableFlag"}, |
158 | {67, &ISystemSettingsServer::GetBatteryLot, "GetBatteryLot"}, | 159 | {67, C<&ISystemSettingsServer::GetBatteryLot>, "GetBatteryLot"}, |
159 | {68, &ISystemSettingsServer::GetSerialNumber, "GetSerialNumber"}, | 160 | {68, C<&ISystemSettingsServer::GetSerialNumber>, "GetSerialNumber"}, |
160 | {69, &ISystemSettingsServer::GetNfcEnableFlag, "GetNfcEnableFlag"}, | 161 | {69, C<&ISystemSettingsServer::GetNfcEnableFlag>, "GetNfcEnableFlag"}, |
161 | {70, &ISystemSettingsServer::SetNfcEnableFlag, "SetNfcEnableFlag"}, | 162 | {70, C<&ISystemSettingsServer::SetNfcEnableFlag>, "SetNfcEnableFlag"}, |
162 | {71, &ISystemSettingsServer::GetSleepSettings, "GetSleepSettings"}, | 163 | {71, C<&ISystemSettingsServer::GetSleepSettings>, "GetSleepSettings"}, |
163 | {72, &ISystemSettingsServer::SetSleepSettings, "SetSleepSettings"}, | 164 | {72, C<&ISystemSettingsServer::SetSleepSettings>, "SetSleepSettings"}, |
164 | {73, &ISystemSettingsServer::GetWirelessLanEnableFlag, "GetWirelessLanEnableFlag"}, | 165 | {73, C<&ISystemSettingsServer::GetWirelessLanEnableFlag>, "GetWirelessLanEnableFlag"}, |
165 | {74, &ISystemSettingsServer::SetWirelessLanEnableFlag, "SetWirelessLanEnableFlag"}, | 166 | {74, C<&ISystemSettingsServer::SetWirelessLanEnableFlag>, "SetWirelessLanEnableFlag"}, |
166 | {75, &ISystemSettingsServer::GetInitialLaunchSettings, "GetInitialLaunchSettings"}, | 167 | {75, C<&ISystemSettingsServer::GetInitialLaunchSettings>, "GetInitialLaunchSettings"}, |
167 | {76, &ISystemSettingsServer::SetInitialLaunchSettings, "SetInitialLaunchSettings"}, | 168 | {76, C<&ISystemSettingsServer::SetInitialLaunchSettings>, "SetInitialLaunchSettings"}, |
168 | {77, &ISystemSettingsServer::GetDeviceNickName, "GetDeviceNickName"}, | 169 | {77, C<&ISystemSettingsServer::GetDeviceNickName>, "GetDeviceNickName"}, |
169 | {78, &ISystemSettingsServer::SetDeviceNickName, "SetDeviceNickName"}, | 170 | {78, C<&ISystemSettingsServer::SetDeviceNickName>, "SetDeviceNickName"}, |
170 | {79, &ISystemSettingsServer::GetProductModel, "GetProductModel"}, | 171 | {79, C<&ISystemSettingsServer::GetProductModel>, "GetProductModel"}, |
171 | {80, nullptr, "GetLdnChannel"}, | 172 | {80, nullptr, "GetLdnChannel"}, |
172 | {81, nullptr, "SetLdnChannel"}, | 173 | {81, nullptr, "SetLdnChannel"}, |
173 | {82, nullptr, "AcquireTelemetryDirtyFlagEventHandle"}, | 174 | {82, nullptr, "AcquireTelemetryDirtyFlagEventHandle"}, |
@@ -176,25 +177,25 @@ ISystemSettingsServer::ISystemSettingsServer(Core::System& system_) | |||
176 | {85, nullptr, "SetPtmBatteryLot"}, | 177 | {85, nullptr, "SetPtmBatteryLot"}, |
177 | {86, nullptr, "GetPtmFuelGaugeParameter"}, | 178 | {86, nullptr, "GetPtmFuelGaugeParameter"}, |
178 | {87, nullptr, "SetPtmFuelGaugeParameter"}, | 179 | {87, nullptr, "SetPtmFuelGaugeParameter"}, |
179 | {88, &ISystemSettingsServer::GetBluetoothEnableFlag, "GetBluetoothEnableFlag"}, | 180 | {88, C<&ISystemSettingsServer::GetBluetoothEnableFlag>, "GetBluetoothEnableFlag"}, |
180 | {89, &ISystemSettingsServer::SetBluetoothEnableFlag, "SetBluetoothEnableFlag"}, | 181 | {89, C<&ISystemSettingsServer::SetBluetoothEnableFlag>, "SetBluetoothEnableFlag"}, |
181 | {90, &ISystemSettingsServer::GetMiiAuthorId, "GetMiiAuthorId"}, | 182 | {90, C<&ISystemSettingsServer::GetMiiAuthorId>, "GetMiiAuthorId"}, |
182 | {91, nullptr, "SetShutdownRtcValue"}, | 183 | {91, nullptr, "SetShutdownRtcValue"}, |
183 | {92, nullptr, "GetShutdownRtcValue"}, | 184 | {92, nullptr, "GetShutdownRtcValue"}, |
184 | {93, nullptr, "AcquireFatalDirtyFlagEventHandle"}, | 185 | {93, nullptr, "AcquireFatalDirtyFlagEventHandle"}, |
185 | {94, nullptr, "GetFatalDirtyFlags"}, | 186 | {94, nullptr, "GetFatalDirtyFlags"}, |
186 | {95, &ISystemSettingsServer::GetAutoUpdateEnableFlag, "GetAutoUpdateEnableFlag"}, | 187 | {95, C<&ISystemSettingsServer::GetAutoUpdateEnableFlag>, "GetAutoUpdateEnableFlag"}, |
187 | {96, &ISystemSettingsServer::SetAutoUpdateEnableFlag, "SetAutoUpdateEnableFlag"}, | 188 | {96, C<&ISystemSettingsServer::SetAutoUpdateEnableFlag>, "SetAutoUpdateEnableFlag"}, |
188 | {97, nullptr, "GetNxControllerSettings"}, | 189 | {97, nullptr, "GetNxControllerSettings"}, |
189 | {98, nullptr, "SetNxControllerSettings"}, | 190 | {98, nullptr, "SetNxControllerSettings"}, |
190 | {99, &ISystemSettingsServer::GetBatteryPercentageFlag, "GetBatteryPercentageFlag"}, | 191 | {99, C<&ISystemSettingsServer::GetBatteryPercentageFlag>, "GetBatteryPercentageFlag"}, |
191 | {100, &ISystemSettingsServer::SetBatteryPercentageFlag, "SetBatteryPercentageFlag"}, | 192 | {100, C<&ISystemSettingsServer::SetBatteryPercentageFlag>, "SetBatteryPercentageFlag"}, |
192 | {101, nullptr, "GetExternalRtcResetFlag"}, | 193 | {101, nullptr, "GetExternalRtcResetFlag"}, |
193 | {102, nullptr, "SetExternalRtcResetFlag"}, | 194 | {102, nullptr, "SetExternalRtcResetFlag"}, |
194 | {103, nullptr, "GetUsbFullKeyEnableFlag"}, | 195 | {103, nullptr, "GetUsbFullKeyEnableFlag"}, |
195 | {104, nullptr, "SetUsbFullKeyEnableFlag"}, | 196 | {104, nullptr, "SetUsbFullKeyEnableFlag"}, |
196 | {105, &ISystemSettingsServer::SetExternalSteadyClockInternalOffset, "SetExternalSteadyClockInternalOffset"}, | 197 | {105, C<&ISystemSettingsServer::SetExternalSteadyClockInternalOffset>, "SetExternalSteadyClockInternalOffset"}, |
197 | {106, &ISystemSettingsServer::GetExternalSteadyClockInternalOffset, "GetExternalSteadyClockInternalOffset"}, | 198 | {106, C<&ISystemSettingsServer::GetExternalSteadyClockInternalOffset>, "GetExternalSteadyClockInternalOffset"}, |
198 | {107, nullptr, "GetBacklightSettingsEx"}, | 199 | {107, nullptr, "GetBacklightSettingsEx"}, |
199 | {108, nullptr, "SetBacklightSettingsEx"}, | 200 | {108, nullptr, "SetBacklightSettingsEx"}, |
200 | {109, nullptr, "GetHeadphoneVolumeWarningCount"}, | 201 | {109, nullptr, "GetHeadphoneVolumeWarningCount"}, |
@@ -208,14 +209,14 @@ ISystemSettingsServer::ISystemSettingsServer(Core::System& system_) | |||
208 | {117, nullptr, "GetHeadphoneVolumeUpdateFlag"}, | 209 | {117, nullptr, "GetHeadphoneVolumeUpdateFlag"}, |
209 | {118, nullptr, "SetHeadphoneVolumeUpdateFlag"}, | 210 | {118, nullptr, "SetHeadphoneVolumeUpdateFlag"}, |
210 | {119, nullptr, "NeedsToUpdateHeadphoneVolume"}, | 211 | {119, nullptr, "NeedsToUpdateHeadphoneVolume"}, |
211 | {120, &ISystemSettingsServer::GetPushNotificationActivityModeOnSleep, "GetPushNotificationActivityModeOnSleep"}, | 212 | {120, C<&ISystemSettingsServer::GetPushNotificationActivityModeOnSleep>, "GetPushNotificationActivityModeOnSleep"}, |
212 | {121, &ISystemSettingsServer::SetPushNotificationActivityModeOnSleep, "SetPushNotificationActivityModeOnSleep"}, | 213 | {121, C<&ISystemSettingsServer::SetPushNotificationActivityModeOnSleep>, "SetPushNotificationActivityModeOnSleep"}, |
213 | {122, nullptr, "GetServiceDiscoveryControlSettings"}, | 214 | {122, nullptr, "GetServiceDiscoveryControlSettings"}, |
214 | {123, nullptr, "SetServiceDiscoveryControlSettings"}, | 215 | {123, nullptr, "SetServiceDiscoveryControlSettings"}, |
215 | {124, &ISystemSettingsServer::GetErrorReportSharePermission, "GetErrorReportSharePermission"}, | 216 | {124, C<&ISystemSettingsServer::GetErrorReportSharePermission>, "GetErrorReportSharePermission"}, |
216 | {125, &ISystemSettingsServer::SetErrorReportSharePermission, "SetErrorReportSharePermission"}, | 217 | {125, C<&ISystemSettingsServer::SetErrorReportSharePermission>, "SetErrorReportSharePermission"}, |
217 | {126, &ISystemSettingsServer::GetAppletLaunchFlags, "GetAppletLaunchFlags"}, | 218 | {126, C<&ISystemSettingsServer::GetAppletLaunchFlags>, "GetAppletLaunchFlags"}, |
218 | {127, &ISystemSettingsServer::SetAppletLaunchFlags, "SetAppletLaunchFlags"}, | 219 | {127, C<&ISystemSettingsServer::SetAppletLaunchFlags>, "SetAppletLaunchFlags"}, |
219 | {128, nullptr, "GetConsoleSixAxisSensorAccelerationBias"}, | 220 | {128, nullptr, "GetConsoleSixAxisSensorAccelerationBias"}, |
220 | {129, nullptr, "SetConsoleSixAxisSensorAccelerationBias"}, | 221 | {129, nullptr, "SetConsoleSixAxisSensorAccelerationBias"}, |
221 | {130, nullptr, "GetConsoleSixAxisSensorAngularVelocityBias"}, | 222 | {130, nullptr, "GetConsoleSixAxisSensorAngularVelocityBias"}, |
@@ -224,8 +225,8 @@ ISystemSettingsServer::ISystemSettingsServer(Core::System& system_) | |||
224 | {133, nullptr, "SetConsoleSixAxisSensorAccelerationGain"}, | 225 | {133, nullptr, "SetConsoleSixAxisSensorAccelerationGain"}, |
225 | {134, nullptr, "GetConsoleSixAxisSensorAngularVelocityGain"}, | 226 | {134, nullptr, "GetConsoleSixAxisSensorAngularVelocityGain"}, |
226 | {135, nullptr, "SetConsoleSixAxisSensorAngularVelocityGain"}, | 227 | {135, nullptr, "SetConsoleSixAxisSensorAngularVelocityGain"}, |
227 | {136, &ISystemSettingsServer::GetKeyboardLayout, "GetKeyboardLayout"}, | 228 | {136, C<&ISystemSettingsServer::GetKeyboardLayout>, "GetKeyboardLayout"}, |
228 | {137, &ISystemSettingsServer::SetKeyboardLayout, "SetKeyboardLayout"}, | 229 | {137, C<&ISystemSettingsServer::SetKeyboardLayout>, "SetKeyboardLayout"}, |
229 | {138, nullptr, "GetWebInspectorFlag"}, | 230 | {138, nullptr, "GetWebInspectorFlag"}, |
230 | {139, nullptr, "GetAllowedSslHosts"}, | 231 | {139, nullptr, "GetAllowedSslHosts"}, |
231 | {140, nullptr, "GetHostFsMountPoint"}, | 232 | {140, nullptr, "GetHostFsMountPoint"}, |
@@ -238,10 +239,10 @@ ISystemSettingsServer::ISystemSettingsServer(Core::System& system_) | |||
238 | {147, nullptr, "GetConsoleSixAxisSensorAngularAcceleration"}, | 239 | {147, nullptr, "GetConsoleSixAxisSensorAngularAcceleration"}, |
239 | {148, nullptr, "SetConsoleSixAxisSensorAngularAcceleration"}, | 240 | {148, nullptr, "SetConsoleSixAxisSensorAngularAcceleration"}, |
240 | {149, nullptr, "GetRebootlessSystemUpdateVersion"}, | 241 | {149, nullptr, "GetRebootlessSystemUpdateVersion"}, |
241 | {150, &ISystemSettingsServer::GetDeviceTimeZoneLocationUpdatedTime, "GetDeviceTimeZoneLocationUpdatedTime"}, | 242 | {150, C<&ISystemSettingsServer::GetDeviceTimeZoneLocationUpdatedTime>, "GetDeviceTimeZoneLocationUpdatedTime"}, |
242 | {151, &ISystemSettingsServer::SetDeviceTimeZoneLocationUpdatedTime, "SetDeviceTimeZoneLocationUpdatedTime"}, | 243 | {151, C<&ISystemSettingsServer::SetDeviceTimeZoneLocationUpdatedTime>, "SetDeviceTimeZoneLocationUpdatedTime"}, |
243 | {152, &ISystemSettingsServer::GetUserSystemClockAutomaticCorrectionUpdatedTime, "GetUserSystemClockAutomaticCorrectionUpdatedTime"}, | 244 | {152, C<&ISystemSettingsServer::GetUserSystemClockAutomaticCorrectionUpdatedTime>, "GetUserSystemClockAutomaticCorrectionUpdatedTime"}, |
244 | {153, &ISystemSettingsServer::SetUserSystemClockAutomaticCorrectionUpdatedTime, "SetUserSystemClockAutomaticCorrectionUpdatedTime"}, | 245 | {153, C<&ISystemSettingsServer::SetUserSystemClockAutomaticCorrectionUpdatedTime>, "SetUserSystemClockAutomaticCorrectionUpdatedTime"}, |
245 | {154, nullptr, "GetAccountOnlineStorageSettings"}, | 246 | {154, nullptr, "GetAccountOnlineStorageSettings"}, |
246 | {155, nullptr, "SetAccountOnlineStorageSettings"}, | 247 | {155, nullptr, "SetAccountOnlineStorageSettings"}, |
247 | {156, nullptr, "GetPctlReadyFlag"}, | 248 | {156, nullptr, "GetPctlReadyFlag"}, |
@@ -258,11 +259,11 @@ ISystemSettingsServer::ISystemSettingsServer(Core::System& system_) | |||
258 | {167, nullptr, "SetUsb30DeviceEnableFlag"}, | 259 | {167, nullptr, "SetUsb30DeviceEnableFlag"}, |
259 | {168, nullptr, "GetThemeId"}, | 260 | {168, nullptr, "GetThemeId"}, |
260 | {169, nullptr, "SetThemeId"}, | 261 | {169, nullptr, "SetThemeId"}, |
261 | {170, &ISystemSettingsServer::GetChineseTraditionalInputMethod, "GetChineseTraditionalInputMethod"}, | 262 | {170, C<&ISystemSettingsServer::GetChineseTraditionalInputMethod>, "GetChineseTraditionalInputMethod"}, |
262 | {171, nullptr, "SetChineseTraditionalInputMethod"}, | 263 | {171, nullptr, "SetChineseTraditionalInputMethod"}, |
263 | {172, nullptr, "GetPtmCycleCountReliability"}, | 264 | {172, nullptr, "GetPtmCycleCountReliability"}, |
264 | {173, nullptr, "SetPtmCycleCountReliability"}, | 265 | {173, nullptr, "SetPtmCycleCountReliability"}, |
265 | {174, &ISystemSettingsServer::GetHomeMenuScheme, "GetHomeMenuScheme"}, | 266 | {174, C<&ISystemSettingsServer::GetHomeMenuScheme>, "GetHomeMenuScheme"}, |
266 | {175, nullptr, "GetThemeSettings"}, | 267 | {175, nullptr, "GetThemeSettings"}, |
267 | {176, nullptr, "SetThemeSettings"}, | 268 | {176, nullptr, "SetThemeSettings"}, |
268 | {177, nullptr, "GetThemeKey"}, | 269 | {177, nullptr, "GetThemeKey"}, |
@@ -273,10 +274,10 @@ ISystemSettingsServer::ISystemSettingsServer(Core::System& system_) | |||
273 | {182, nullptr, "SetT"}, | 274 | {182, nullptr, "SetT"}, |
274 | {183, nullptr, "GetPlatformRegion"}, | 275 | {183, nullptr, "GetPlatformRegion"}, |
275 | {184, nullptr, "SetPlatformRegion"}, | 276 | {184, nullptr, "SetPlatformRegion"}, |
276 | {185, &ISystemSettingsServer::GetHomeMenuSchemeModel, "GetHomeMenuSchemeModel"}, | 277 | {185, C<&ISystemSettingsServer::GetHomeMenuSchemeModel>, "GetHomeMenuSchemeModel"}, |
277 | {186, nullptr, "GetMemoryUsageRateFlag"}, | 278 | {186, nullptr, "GetMemoryUsageRateFlag"}, |
278 | {187, &ISystemSettingsServer::GetTouchScreenMode, "GetTouchScreenMode"}, | 279 | {187, C<&ISystemSettingsServer::GetTouchScreenMode>, "GetTouchScreenMode"}, |
279 | {188, &ISystemSettingsServer::SetTouchScreenMode, "SetTouchScreenMode"}, | 280 | {188, C<&ISystemSettingsServer::SetTouchScreenMode>, "SetTouchScreenMode"}, |
280 | {189, nullptr, "GetButtonConfigSettingsFull"}, | 281 | {189, nullptr, "GetButtonConfigSettingsFull"}, |
281 | {190, nullptr, "SetButtonConfigSettingsFull"}, | 282 | {190, nullptr, "SetButtonConfigSettingsFull"}, |
282 | {191, nullptr, "GetButtonConfigSettingsEmbedded"}, | 283 | {191, nullptr, "GetButtonConfigSettingsEmbedded"}, |
@@ -289,10 +290,10 @@ ISystemSettingsServer::ISystemSettingsServer(Core::System& system_) | |||
289 | {198, nullptr, "SetButtonConfigRegisteredSettingsEmbedded"}, | 290 | {198, nullptr, "SetButtonConfigRegisteredSettingsEmbedded"}, |
290 | {199, nullptr, "GetButtonConfigRegisteredSettings"}, | 291 | {199, nullptr, "GetButtonConfigRegisteredSettings"}, |
291 | {200, nullptr, "SetButtonConfigRegisteredSettings"}, | 292 | {200, nullptr, "SetButtonConfigRegisteredSettings"}, |
292 | {201, &ISystemSettingsServer::GetFieldTestingFlag, "GetFieldTestingFlag"}, | 293 | {201, C<&ISystemSettingsServer::GetFieldTestingFlag>, "GetFieldTestingFlag"}, |
293 | {202, nullptr, "SetFieldTestingFlag"}, | 294 | {202, nullptr, "SetFieldTestingFlag"}, |
294 | {203, &ISystemSettingsServer::GetPanelCrcMode, "GetPanelCrcMode"}, | 295 | {203, C<&ISystemSettingsServer::GetPanelCrcMode>, "GetPanelCrcMode"}, |
295 | {204, &ISystemSettingsServer::SetPanelCrcMode, "SetPanelCrcMode"}, | 296 | {204, C<&ISystemSettingsServer::SetPanelCrcMode>, "SetPanelCrcMode"}, |
296 | {205, nullptr, "GetNxControllerSettingsEx"}, | 297 | {205, nullptr, "GetNxControllerSettingsEx"}, |
297 | {206, nullptr, "SetNxControllerSettingsEx"}, | 298 | {206, nullptr, "SetNxControllerSettingsEx"}, |
298 | {207, nullptr, "GetHearingProtectionSafeguardFlag"}, | 299 | {207, nullptr, "GetHearingProtectionSafeguardFlag"}, |
@@ -422,178 +423,134 @@ bool ISystemSettingsServer::StoreSettingsFile(std::filesystem::path& path, auto& | |||
422 | return true; | 423 | return true; |
423 | } | 424 | } |
424 | 425 | ||
425 | void ISystemSettingsServer::SetLanguageCode(HLERequestContext& ctx) { | 426 | Result ISystemSettingsServer::SetLanguageCode(LanguageCode language_code) { |
426 | IPC::RequestParser rp{ctx}; | 427 | LOG_INFO(Service_SET, "called, language_code={}", language_code); |
427 | m_system_settings.language_code = rp.PopEnum<LanguageCode>(); | ||
428 | SetSaveNeeded(); | ||
429 | |||
430 | LOG_INFO(Service_SET, "called, language_code={}", m_system_settings.language_code); | ||
431 | 428 | ||
432 | IPC::ResponseBuilder rb{ctx, 2}; | 429 | m_system_settings.language_code = language_code; |
433 | rb.Push(ResultSuccess); | 430 | SetSaveNeeded(); |
431 | R_SUCCEED(); | ||
434 | } | 432 | } |
435 | 433 | ||
436 | void ISystemSettingsServer::GetFirmwareVersion(HLERequestContext& ctx) { | 434 | Result ISystemSettingsServer::GetFirmwareVersion( |
435 | OutLargeData<FirmwareVersionFormat, BufferAttr_HipcPointer> out_firmware_data) { | ||
437 | LOG_DEBUG(Service_SET, "called"); | 436 | LOG_DEBUG(Service_SET, "called"); |
438 | 437 | ||
439 | FirmwareVersionFormat firmware_data{}; | 438 | R_RETURN(GetFirmwareVersionImpl(*out_firmware_data, system, GetFirmwareVersionType::Version1)); |
440 | const auto result = | ||
441 | GetFirmwareVersionImpl(firmware_data, system, GetFirmwareVersionType::Version1); | ||
442 | |||
443 | if (result.IsSuccess()) { | ||
444 | ctx.WriteBuffer(firmware_data); | ||
445 | } | ||
446 | |||
447 | IPC::ResponseBuilder rb{ctx, 2}; | ||
448 | rb.Push(result); | ||
449 | } | 439 | } |
450 | 440 | ||
451 | void ISystemSettingsServer::GetFirmwareVersion2(HLERequestContext& ctx) { | 441 | Result ISystemSettingsServer::GetFirmwareVersion2( |
442 | OutLargeData<FirmwareVersionFormat, BufferAttr_HipcPointer> out_firmware_data) { | ||
452 | LOG_DEBUG(Service_SET, "called"); | 443 | LOG_DEBUG(Service_SET, "called"); |
453 | 444 | ||
454 | FirmwareVersionFormat firmware_data{}; | 445 | R_RETURN(GetFirmwareVersionImpl(*out_firmware_data, system, GetFirmwareVersionType::Version2)); |
455 | const auto result = | ||
456 | GetFirmwareVersionImpl(firmware_data, system, GetFirmwareVersionType::Version2); | ||
457 | |||
458 | if (result.IsSuccess()) { | ||
459 | ctx.WriteBuffer(firmware_data); | ||
460 | } | ||
461 | |||
462 | IPC::ResponseBuilder rb{ctx, 2}; | ||
463 | rb.Push(result); | ||
464 | } | 446 | } |
465 | 447 | ||
466 | void ISystemSettingsServer::GetExternalSteadyClockSourceId(HLERequestContext& ctx) { | 448 | Result ISystemSettingsServer::GetLockScreenFlag(Out<bool> out_lock_screen_flag) { |
467 | LOG_INFO(Service_SET, "called"); | 449 | LOG_INFO(Service_SET, "called, lock_screen_flag={}", m_system_settings.lock_screen_flag); |
468 | |||
469 | Common::UUID id{}; | ||
470 | const auto res = GetExternalSteadyClockSourceId(id); | ||
471 | 450 | ||
472 | IPC::ResponseBuilder rb{ctx, 2 + sizeof(Common::UUID) / sizeof(u32)}; | 451 | *out_lock_screen_flag = m_system_settings.lock_screen_flag; |
473 | rb.Push(res); | 452 | R_SUCCEED(); |
474 | rb.PushRaw(id); | ||
475 | } | 453 | } |
476 | 454 | ||
477 | void ISystemSettingsServer::SetExternalSteadyClockSourceId(HLERequestContext& ctx) { | 455 | Result ISystemSettingsServer::SetLockScreenFlag(bool lock_screen_flag) { |
478 | LOG_INFO(Service_SET, "called"); | 456 | LOG_INFO(Service_SET, "called, lock_screen_flag={}", lock_screen_flag); |
479 | 457 | ||
480 | IPC::RequestParser rp{ctx}; | 458 | m_system_settings.lock_screen_flag = lock_screen_flag; |
481 | const auto id{rp.PopRaw<Common::UUID>()}; | 459 | SetSaveNeeded(); |
460 | R_SUCCEED(); | ||
461 | } | ||
482 | 462 | ||
483 | const auto res = SetExternalSteadyClockSourceId(id); | 463 | Result ISystemSettingsServer::GetExternalSteadyClockSourceId( |
464 | Out<Common::UUID> out_clock_source_id) { | ||
465 | LOG_INFO(Service_SET, "called, clock_source_id={}", | ||
466 | m_private_settings.external_clock_source_id.FormattedString()); | ||
484 | 467 | ||
485 | IPC::ResponseBuilder rb{ctx, 2}; | 468 | *out_clock_source_id = m_private_settings.external_clock_source_id; |
486 | rb.Push(res); | 469 | R_SUCCEED(); |
487 | } | 470 | } |
488 | 471 | ||
489 | void ISystemSettingsServer::GetUserSystemClockContext(HLERequestContext& ctx) { | 472 | Result ISystemSettingsServer::SetExternalSteadyClockSourceId(const Common::UUID& clock_source_id) { |
490 | LOG_INFO(Service_SET, "called"); | 473 | LOG_INFO(Service_SET, "called, clock_source_id={}", clock_source_id.FormattedString()); |
491 | |||
492 | Service::PSC::Time::SystemClockContext context{}; | ||
493 | const auto res = GetUserSystemClockContext(context); | ||
494 | 474 | ||
495 | IPC::ResponseBuilder rb{ctx, 2 + sizeof(Service::PSC::Time::SystemClockContext) / sizeof(u32)}; | 475 | m_private_settings.external_clock_source_id = clock_source_id; |
496 | rb.Push(res); | 476 | SetSaveNeeded(); |
497 | rb.PushRaw(context); | 477 | R_SUCCEED(); |
498 | } | 478 | } |
499 | 479 | ||
500 | void ISystemSettingsServer::SetUserSystemClockContext(HLERequestContext& ctx) { | 480 | Result ISystemSettingsServer::GetUserSystemClockContext( |
481 | Out<Service::PSC::Time::SystemClockContext> out_clock_context) { | ||
501 | LOG_INFO(Service_SET, "called"); | 482 | LOG_INFO(Service_SET, "called"); |
502 | 483 | ||
503 | IPC::RequestParser rp{ctx}; | 484 | *out_clock_context = m_system_settings.user_system_clock_context; |
504 | const auto context{rp.PopRaw<Service::PSC::Time::SystemClockContext>()}; | 485 | R_SUCCEED(); |
505 | |||
506 | const auto res = SetUserSystemClockContext(context); | ||
507 | |||
508 | IPC::ResponseBuilder rb{ctx, 2}; | ||
509 | rb.Push(res); | ||
510 | } | 486 | } |
511 | 487 | ||
512 | void ISystemSettingsServer::GetLockScreenFlag(HLERequestContext& ctx) { | 488 | Result ISystemSettingsServer::SetUserSystemClockContext( |
513 | LOG_INFO(Service_SET, "called, lock_screen_flag={}", m_system_settings.lock_screen_flag); | 489 | const Service::PSC::Time::SystemClockContext& clock_context) { |
514 | 490 | LOG_INFO(Service_SET, "called"); | |
515 | IPC::ResponseBuilder rb{ctx, 3}; | ||
516 | rb.Push(ResultSuccess); | ||
517 | rb.Push(m_system_settings.lock_screen_flag); | ||
518 | } | ||
519 | 491 | ||
520 | void ISystemSettingsServer::SetLockScreenFlag(HLERequestContext& ctx) { | 492 | m_system_settings.user_system_clock_context = clock_context; |
521 | IPC::RequestParser rp{ctx}; | ||
522 | m_system_settings.lock_screen_flag = rp.Pop<bool>(); | ||
523 | SetSaveNeeded(); | 493 | SetSaveNeeded(); |
524 | 494 | R_SUCCEED(); | |
525 | LOG_INFO(Service_SET, "called, lock_screen_flag={}", m_system_settings.lock_screen_flag); | ||
526 | |||
527 | IPC::ResponseBuilder rb{ctx, 2}; | ||
528 | rb.Push(ResultSuccess); | ||
529 | } | 495 | } |
530 | 496 | ||
531 | void ISystemSettingsServer::GetAccountSettings(HLERequestContext& ctx) { | 497 | Result ISystemSettingsServer::GetAccountSettings(Out<AccountSettings> out_account_settings) { |
532 | LOG_INFO(Service_SET, "called"); | 498 | LOG_INFO(Service_SET, "called, account_settings_flags={}", |
499 | m_system_settings.account_settings.flags); | ||
533 | 500 | ||
534 | IPC::ResponseBuilder rb{ctx, 3}; | 501 | *out_account_settings = m_system_settings.account_settings; |
535 | rb.Push(ResultSuccess); | 502 | R_SUCCEED(); |
536 | rb.PushRaw(m_system_settings.account_settings); | ||
537 | } | 503 | } |
538 | 504 | ||
539 | void ISystemSettingsServer::SetAccountSettings(HLERequestContext& ctx) { | 505 | Result ISystemSettingsServer::SetAccountSettings(AccountSettings account_settings) { |
540 | IPC::RequestParser rp{ctx}; | 506 | LOG_INFO(Service_SET, "called, account_settings_flags={}", account_settings.flags); |
541 | m_system_settings.account_settings = rp.PopRaw<AccountSettings>(); | ||
542 | SetSaveNeeded(); | ||
543 | |||
544 | LOG_INFO(Service_SET, "called, account_settings_flags={}", | ||
545 | m_system_settings.account_settings.flags); | ||
546 | 507 | ||
547 | IPC::ResponseBuilder rb{ctx, 2}; | 508 | m_system_settings.account_settings = account_settings; |
548 | rb.Push(ResultSuccess); | 509 | SetSaveNeeded(); |
510 | R_SUCCEED(); | ||
549 | } | 511 | } |
550 | 512 | ||
551 | void ISystemSettingsServer::GetEulaVersions(HLERequestContext& ctx) { | 513 | Result ISystemSettingsServer::GetEulaVersions( |
514 | Out<s32> out_count, OutArray<EulaVersion, BufferAttr_HipcMapAlias> out_eula_versions) { | ||
552 | LOG_INFO(Service_SET, "called, elements={}", m_system_settings.eula_version_count); | 515 | LOG_INFO(Service_SET, "called, elements={}", m_system_settings.eula_version_count); |
553 | 516 | ||
554 | ctx.WriteBuffer(m_system_settings.eula_versions); | 517 | *out_count = |
555 | 518 | std::min(m_system_settings.eula_version_count, static_cast<s32>(out_eula_versions.size())); | |
556 | IPC::ResponseBuilder rb{ctx, 3}; | 519 | memcpy(out_eula_versions.data(), m_system_settings.eula_versions.data(), |
557 | rb.Push(ResultSuccess); | 520 | static_cast<std::size_t>(*out_count) * sizeof(EulaVersion)); |
558 | rb.Push(m_system_settings.eula_version_count); | 521 | R_SUCCEED(); |
559 | } | 522 | } |
560 | 523 | ||
561 | void ISystemSettingsServer::SetEulaVersions(HLERequestContext& ctx) { | 524 | Result ISystemSettingsServer::SetEulaVersions( |
562 | const auto elements = ctx.GetReadBufferNumElements<EulaVersion>(); | 525 | InArray<EulaVersion, BufferAttr_HipcMapAlias> eula_versions) { |
563 | const auto buffer_data = ctx.ReadBuffer(); | 526 | LOG_INFO(Service_SET, "called, elements={}", eula_versions.size()); |
564 | 527 | ||
565 | LOG_INFO(Service_SET, "called, elements={}", elements); | 528 | ASSERT(eula_versions.size() <= m_system_settings.eula_versions.size()); |
566 | ASSERT(elements <= m_system_settings.eula_versions.size()); | ||
567 | 529 | ||
568 | m_system_settings.eula_version_count = static_cast<u32>(elements); | 530 | m_system_settings.eula_version_count = static_cast<s32>(eula_versions.size()); |
569 | std::memcpy(&m_system_settings.eula_versions, buffer_data.data(), | 531 | std::memcpy(m_system_settings.eula_versions.data(), eula_versions.data(), |
570 | sizeof(EulaVersion) * elements); | 532 | eula_versions.size() * sizeof(EulaVersion)); |
571 | SetSaveNeeded(); | 533 | SetSaveNeeded(); |
572 | 534 | R_SUCCEED(); | |
573 | IPC::ResponseBuilder rb{ctx, 2}; | ||
574 | rb.Push(ResultSuccess); | ||
575 | } | 535 | } |
576 | 536 | ||
577 | void ISystemSettingsServer::GetColorSetId(HLERequestContext& ctx) { | 537 | Result ISystemSettingsServer::GetColorSetId(Out<ColorSet> out_color_set_id) { |
578 | LOG_DEBUG(Service_SET, "called, color_set=", m_system_settings.color_set_id); | 538 | LOG_DEBUG(Service_SET, "called, color_set=", m_system_settings.color_set_id); |
579 | 539 | ||
580 | IPC::ResponseBuilder rb{ctx, 3}; | 540 | *out_color_set_id = m_system_settings.color_set_id; |
581 | rb.Push(ResultSuccess); | 541 | R_SUCCEED(); |
582 | rb.PushEnum(m_system_settings.color_set_id); | ||
583 | } | 542 | } |
584 | 543 | ||
585 | void ISystemSettingsServer::SetColorSetId(HLERequestContext& ctx) { | 544 | Result ISystemSettingsServer::SetColorSetId(ColorSet color_set_id) { |
586 | IPC::RequestParser rp{ctx}; | 545 | LOG_DEBUG(Service_SET, "called, color_set={}", color_set_id); |
587 | m_system_settings.color_set_id = rp.PopEnum<ColorSet>(); | ||
588 | SetSaveNeeded(); | ||
589 | |||
590 | LOG_DEBUG(Service_SET, "called, color_set={}", m_system_settings.color_set_id); | ||
591 | 546 | ||
592 | IPC::ResponseBuilder rb{ctx, 2}; | 547 | m_system_settings.color_set_id = color_set_id; |
593 | rb.Push(ResultSuccess); | 548 | SetSaveNeeded(); |
549 | R_SUCCEED(); | ||
594 | } | 550 | } |
595 | 551 | ||
596 | void ISystemSettingsServer::GetNotificationSettings(HLERequestContext& ctx) { | 552 | Result ISystemSettingsServer::GetNotificationSettings( |
553 | Out<NotificationSettings> out_notification_settings) { | ||
597 | LOG_INFO(Service_SET, "called, flags={}, volume={}, head_time={}:{}, tailt_time={}:{}", | 554 | LOG_INFO(Service_SET, "called, flags={}, volume={}, head_time={}:{}, tailt_time={}:{}", |
598 | m_system_settings.notification_settings.flags.raw, | 555 | m_system_settings.notification_settings.flags.raw, |
599 | m_system_settings.notification_settings.volume, | 556 | m_system_settings.notification_settings.volume, |
@@ -602,77 +559,67 @@ void ISystemSettingsServer::GetNotificationSettings(HLERequestContext& ctx) { | |||
602 | m_system_settings.notification_settings.stop_time.hour, | 559 | m_system_settings.notification_settings.stop_time.hour, |
603 | m_system_settings.notification_settings.stop_time.minute); | 560 | m_system_settings.notification_settings.stop_time.minute); |
604 | 561 | ||
605 | IPC::ResponseBuilder rb{ctx, 8}; | 562 | *out_notification_settings = m_system_settings.notification_settings; |
606 | rb.Push(ResultSuccess); | 563 | R_SUCCEED(); |
607 | rb.PushRaw(m_system_settings.notification_settings); | ||
608 | } | 564 | } |
609 | 565 | ||
610 | void ISystemSettingsServer::SetNotificationSettings(HLERequestContext& ctx) { | 566 | Result ISystemSettingsServer::SetNotificationSettings( |
611 | IPC::RequestParser rp{ctx}; | 567 | const NotificationSettings& notification_settings) { |
612 | m_system_settings.notification_settings = rp.PopRaw<NotificationSettings>(); | ||
613 | SetSaveNeeded(); | ||
614 | |||
615 | LOG_INFO(Service_SET, "called, flags={}, volume={}, head_time={}:{}, tailt_time={}:{}", | 568 | LOG_INFO(Service_SET, "called, flags={}, volume={}, head_time={}:{}, tailt_time={}:{}", |
616 | m_system_settings.notification_settings.flags.raw, | 569 | notification_settings.flags.raw, notification_settings.volume, |
617 | m_system_settings.notification_settings.volume, | 570 | notification_settings.start_time.hour, notification_settings.start_time.minute, |
618 | m_system_settings.notification_settings.start_time.hour, | 571 | notification_settings.stop_time.hour, notification_settings.stop_time.minute); |
619 | m_system_settings.notification_settings.start_time.minute, | ||
620 | m_system_settings.notification_settings.stop_time.hour, | ||
621 | m_system_settings.notification_settings.stop_time.minute); | ||
622 | 572 | ||
623 | IPC::ResponseBuilder rb{ctx, 2}; | 573 | m_system_settings.notification_settings = notification_settings; |
624 | rb.Push(ResultSuccess); | 574 | SetSaveNeeded(); |
575 | R_SUCCEED(); | ||
625 | } | 576 | } |
626 | 577 | ||
627 | void ISystemSettingsServer::GetAccountNotificationSettings(HLERequestContext& ctx) { | 578 | Result ISystemSettingsServer::GetAccountNotificationSettings( |
579 | Out<s32> out_count, OutArray<AccountNotificationSettings, BufferAttr_HipcMapAlias> | ||
580 | out_account_notification_settings) { | ||
628 | LOG_INFO(Service_SET, "called, elements={}", | 581 | LOG_INFO(Service_SET, "called, elements={}", |
629 | m_system_settings.account_notification_settings_count); | 582 | m_system_settings.account_notification_settings_count); |
630 | 583 | ||
631 | ctx.WriteBuffer(m_system_settings.account_notification_settings); | 584 | *out_count = std::min(m_system_settings.account_notification_settings_count, |
585 | static_cast<s32>(out_account_notification_settings.size())); | ||
586 | memcpy(out_account_notification_settings.data(), | ||
587 | m_system_settings.account_notification_settings.data(), | ||
588 | static_cast<std::size_t>(*out_count) * sizeof(AccountNotificationSettings)); | ||
632 | 589 | ||
633 | IPC::ResponseBuilder rb{ctx, 3}; | 590 | R_SUCCEED(); |
634 | rb.Push(ResultSuccess); | ||
635 | rb.Push(m_system_settings.account_notification_settings_count); | ||
636 | } | 591 | } |
637 | 592 | ||
638 | void ISystemSettingsServer::SetAccountNotificationSettings(HLERequestContext& ctx) { | 593 | Result ISystemSettingsServer::SetAccountNotificationSettings( |
639 | const auto elements = ctx.GetReadBufferNumElements<AccountNotificationSettings>(); | 594 | InArray<AccountNotificationSettings, BufferAttr_HipcMapAlias> account_notification_settings) { |
640 | const auto buffer_data = ctx.ReadBuffer(); | 595 | LOG_INFO(Service_SET, "called, elements={}", account_notification_settings.size()); |
641 | |||
642 | LOG_INFO(Service_SET, "called, elements={}", elements); | ||
643 | 596 | ||
644 | ASSERT(elements <= m_system_settings.account_notification_settings.size()); | 597 | ASSERT(account_notification_settings.size() <= |
598 | m_system_settings.account_notification_settings.size()); | ||
645 | 599 | ||
646 | m_system_settings.account_notification_settings_count = static_cast<u32>(elements); | 600 | m_system_settings.account_notification_settings_count = |
647 | std::memcpy(&m_system_settings.account_notification_settings, buffer_data.data(), | 601 | static_cast<s32>(account_notification_settings.size()); |
648 | elements * sizeof(AccountNotificationSettings)); | 602 | std::memcpy(m_system_settings.account_notification_settings.data(), |
603 | account_notification_settings.data(), | ||
604 | account_notification_settings.size() * sizeof(AccountNotificationSettings)); | ||
649 | SetSaveNeeded(); | 605 | SetSaveNeeded(); |
650 | 606 | R_SUCCEED(); | |
651 | IPC::ResponseBuilder rb{ctx, 2}; | ||
652 | rb.Push(ResultSuccess); | ||
653 | } | 607 | } |
654 | 608 | ||
655 | void ISystemSettingsServer::GetVibrationMasterVolume(HLERequestContext& ctx) { | 609 | Result ISystemSettingsServer::GetVibrationMasterVolume(Out<f32> vibration_master_volume) { |
656 | f32 vibration_master_volume = {}; | 610 | LOG_INFO(Service_SET, "called, vibration_master_volume={}", |
657 | const auto result = GetVibrationMasterVolume(vibration_master_volume); | 611 | m_system_settings.vibration_master_volume); |
658 | 612 | ||
659 | LOG_INFO(Service_SET, "called, master_volume={}", vibration_master_volume); | 613 | *vibration_master_volume = m_system_settings.vibration_master_volume; |
660 | 614 | R_SUCCEED(); | |
661 | IPC::ResponseBuilder rb{ctx, 3}; | ||
662 | rb.Push(result); | ||
663 | rb.Push(vibration_master_volume); | ||
664 | } | 615 | } |
665 | 616 | ||
666 | void ISystemSettingsServer::SetVibrationMasterVolume(HLERequestContext& ctx) { | 617 | Result ISystemSettingsServer::SetVibrationMasterVolume(f32 vibration_master_volume) { |
667 | IPC::RequestParser rp{ctx}; | 618 | LOG_INFO(Service_SET, "called, vibration_master_volume={}", vibration_master_volume); |
668 | const auto vibration_master_volume = rp.PopRaw<f32>(); | ||
669 | |||
670 | LOG_INFO(Service_SET, "called, elements={}", m_system_settings.vibration_master_volume); | ||
671 | 619 | ||
672 | const auto result = SetVibrationMasterVolume(vibration_master_volume); | 620 | m_system_settings.vibration_master_volume = vibration_master_volume; |
673 | 621 | SetSaveNeeded(); | |
674 | IPC::ResponseBuilder rb{ctx, 2}; | 622 | R_SUCCEED(); |
675 | rb.Push(result); | ||
676 | } | 623 | } |
677 | 624 | ||
678 | // FIXME: implement support for the real system_settings.ini | 625 | // FIXME: implement support for the real system_settings.ini |
@@ -734,55 +681,38 @@ static Settings GetSettings() { | |||
734 | return ret; | 681 | return ret; |
735 | } | 682 | } |
736 | 683 | ||
737 | void ISystemSettingsServer::GetSettingsItemValueSize(HLERequestContext& ctx) { | 684 | Result ISystemSettingsServer::GetSettingsItemValueSize( |
738 | LOG_DEBUG(Service_SET, "called"); | 685 | Out<u64> out_size, InLargeData<SettingItemName, BufferAttr_HipcPointer> setting_category_buffer, |
686 | InLargeData<SettingItemName, BufferAttr_HipcPointer> setting_name_buffer) { | ||
687 | const std::string setting_category{Common::StringFromBuffer(*setting_category_buffer)}; | ||
688 | const std::string setting_name{Common::StringFromBuffer(*setting_name_buffer)}; | ||
739 | 689 | ||
740 | // The category of the setting. This corresponds to the top-level keys of | 690 | LOG_DEBUG(Service_SET, "called, category={}, name={}", setting_category, setting_name); |
741 | // system_settings.ini. | ||
742 | const auto setting_category_buf{ctx.ReadBuffer(0)}; | ||
743 | const std::string setting_category{Common::StringFromBuffer(setting_category_buf)}; | ||
744 | 691 | ||
745 | // The name of the setting. This corresponds to the second-level keys of | 692 | *out_size = 0; |
746 | // system_settings.ini. | ||
747 | const auto setting_name_buf{ctx.ReadBuffer(1)}; | ||
748 | const std::string setting_name{Common::StringFromBuffer(setting_name_buf)}; | ||
749 | 693 | ||
750 | auto settings{GetSettings()}; | 694 | auto settings{GetSettings()}; |
751 | u64 response_size{0}; | ||
752 | |||
753 | if (settings.contains(setting_category) && settings[setting_category].contains(setting_name)) { | 695 | if (settings.contains(setting_category) && settings[setting_category].contains(setting_name)) { |
754 | response_size = settings[setting_category][setting_name].size(); | 696 | *out_size = settings[setting_category][setting_name].size(); |
755 | } | 697 | } |
756 | 698 | ||
757 | IPC::ResponseBuilder rb{ctx, 4}; | 699 | R_UNLESS(*out_size != 0, ResultUnknown); |
758 | rb.Push(response_size == 0 ? ResultUnknown : ResultSuccess); | 700 | R_SUCCEED(); |
759 | rb.Push(response_size); | ||
760 | } | 701 | } |
761 | 702 | ||
762 | void ISystemSettingsServer::GetSettingsItemValue(HLERequestContext& ctx) { | 703 | Result ISystemSettingsServer::GetSettingsItemValue( |
763 | // The category of the setting. This corresponds to the top-level keys of | 704 | OutBuffer<BufferAttr_HipcMapAlias> out_data, |
764 | // system_settings.ini. | 705 | InLargeData<SettingItemName, BufferAttr_HipcPointer> setting_category_buffer, |
765 | const auto setting_category_buf{ctx.ReadBuffer(0)}; | 706 | InLargeData<SettingItemName, BufferAttr_HipcPointer> setting_name_buffer) { |
766 | const std::string setting_category{Common::StringFromBuffer(setting_category_buf)}; | 707 | const std::string setting_category{Common::StringFromBuffer(*setting_category_buffer)}; |
767 | 708 | const std::string setting_name{Common::StringFromBuffer(*setting_name_buffer)}; | |
768 | // The name of the setting. This corresponds to the second-level keys of | ||
769 | // system_settings.ini. | ||
770 | const auto setting_name_buf{ctx.ReadBuffer(1)}; | ||
771 | const std::string setting_name{Common::StringFromBuffer(setting_name_buf)}; | ||
772 | 709 | ||
773 | std::vector<u8> value; | 710 | LOG_INFO(Service_SET, "called, category={}, name={}", setting_category, setting_name); |
774 | auto response = GetSettingsItemValue(value, setting_category, setting_name); | ||
775 | 711 | ||
776 | LOG_INFO(Service_SET, "called. category={}, name={} -- res=0x{:X}", setting_category, | 712 | R_RETURN(GetSettingsItemValueImpl(out_data, setting_category, setting_name)); |
777 | setting_name, response.raw); | ||
778 | |||
779 | ctx.WriteBuffer(value.data(), value.size()); | ||
780 | |||
781 | IPC::ResponseBuilder rb{ctx, 2}; | ||
782 | rb.Push(response); | ||
783 | } | 713 | } |
784 | 714 | ||
785 | void ISystemSettingsServer::GetTvSettings(HLERequestContext& ctx) { | 715 | Result ISystemSettingsServer::GetTvSettings(Out<TvSettings> out_tv_settings) { |
786 | LOG_INFO(Service_SET, | 716 | LOG_INFO(Service_SET, |
787 | "called, flags={}, cmu_mode={}, contrast_ratio={}, hdmi_content_type={}, " | 717 | "called, flags={}, cmu_mode={}, contrast_ratio={}, hdmi_content_type={}, " |
788 | "rgb_range={}, tv_gama={}, tv_resolution={}, tv_underscan={}", | 718 | "rgb_range={}, tv_gama={}, tv_resolution={}, tv_underscan={}", |
@@ -793,371 +723,335 @@ void ISystemSettingsServer::GetTvSettings(HLERequestContext& ctx) { | |||
793 | m_system_settings.tv_settings.tv_resolution, | 723 | m_system_settings.tv_settings.tv_resolution, |
794 | m_system_settings.tv_settings.tv_underscan); | 724 | m_system_settings.tv_settings.tv_underscan); |
795 | 725 | ||
796 | IPC::ResponseBuilder rb{ctx, 10}; | 726 | *out_tv_settings = m_system_settings.tv_settings; |
797 | rb.Push(ResultSuccess); | 727 | R_SUCCEED(); |
798 | rb.PushRaw(m_system_settings.tv_settings); | ||
799 | } | 728 | } |
800 | 729 | ||
801 | void ISystemSettingsServer::SetTvSettings(HLERequestContext& ctx) { | 730 | Result ISystemSettingsServer::SetTvSettings(TvSettings tv_settings) { |
802 | IPC::RequestParser rp{ctx}; | ||
803 | m_system_settings.tv_settings = rp.PopRaw<TvSettings>(); | ||
804 | SetSaveNeeded(); | ||
805 | 731 | ||
806 | LOG_INFO(Service_SET, | 732 | LOG_INFO(Service_SET, |
807 | "called, flags={}, cmu_mode={}, contrast_ratio={}, hdmi_content_type={}, " | 733 | "called, flags={}, cmu_mode={}, contrast_ratio={}, hdmi_content_type={}, " |
808 | "rgb_range={}, tv_gama={}, tv_resolution={}, tv_underscan={}", | 734 | "rgb_range={}, tv_gama={}, tv_resolution={}, tv_underscan={}", |
809 | m_system_settings.tv_settings.flags.raw, m_system_settings.tv_settings.cmu_mode, | 735 | tv_settings.flags.raw, tv_settings.cmu_mode, tv_settings.contrast_ratio, |
810 | m_system_settings.tv_settings.contrast_ratio, | 736 | tv_settings.hdmi_content_type, tv_settings.rgb_range, tv_settings.tv_gama, |
811 | m_system_settings.tv_settings.hdmi_content_type, | 737 | tv_settings.tv_resolution, tv_settings.tv_underscan); |
812 | m_system_settings.tv_settings.rgb_range, m_system_settings.tv_settings.tv_gama, | ||
813 | m_system_settings.tv_settings.tv_resolution, | ||
814 | m_system_settings.tv_settings.tv_underscan); | ||
815 | 738 | ||
816 | IPC::ResponseBuilder rb{ctx, 2}; | 739 | m_system_settings.tv_settings = tv_settings; |
817 | rb.Push(ResultSuccess); | 740 | SetSaveNeeded(); |
741 | R_SUCCEED(); | ||
818 | } | 742 | } |
819 | 743 | ||
820 | void ISystemSettingsServer::GetAudioOutputMode(HLERequestContext& ctx) { | 744 | Result ISystemSettingsServer::GetAudioOutputMode(Out<AudioOutputMode> out_output_mode, |
821 | IPC::RequestParser rp{ctx}; | 745 | AudioOutputModeTarget target) { |
822 | const auto target{rp.PopEnum<AudioOutputModeTarget>()}; | 746 | switch (target) { |
823 | 747 | case AudioOutputModeTarget::Hdmi: | |
824 | AudioOutputMode output_mode{}; | 748 | *out_output_mode = m_system_settings.audio_output_mode_hdmi; |
825 | const auto result = GetAudioOutputMode(output_mode, target); | 749 | break; |
826 | 750 | case AudioOutputModeTarget::Speaker: | |
827 | LOG_INFO(Service_SET, "called, target={}, output_mode={}", target, output_mode); | 751 | *out_output_mode = m_system_settings.audio_output_mode_speaker; |
752 | break; | ||
753 | case AudioOutputModeTarget::Headphone: | ||
754 | *out_output_mode = m_system_settings.audio_output_mode_headphone; | ||
755 | break; | ||
756 | case AudioOutputModeTarget::Type3: | ||
757 | *out_output_mode = m_system_settings.audio_output_mode_type3; | ||
758 | break; | ||
759 | case AudioOutputModeTarget::Type4: | ||
760 | *out_output_mode = m_system_settings.audio_output_mode_type4; | ||
761 | break; | ||
762 | default: | ||
763 | LOG_ERROR(Service_SET, "Invalid audio output mode target {}", target); | ||
764 | } | ||
828 | 765 | ||
829 | IPC::ResponseBuilder rb{ctx, 3}; | 766 | LOG_INFO(Service_SET, "called, target={}, output_mode={}", target, *out_output_mode); |
830 | rb.Push(result); | 767 | R_SUCCEED(); |
831 | rb.PushEnum(output_mode); | ||
832 | } | 768 | } |
833 | 769 | ||
834 | void ISystemSettingsServer::SetAudioOutputMode(HLERequestContext& ctx) { | 770 | Result ISystemSettingsServer::SetAudioOutputMode(AudioOutputModeTarget target, |
835 | IPC::RequestParser rp{ctx}; | 771 | AudioOutputMode output_mode) { |
836 | const auto target{rp.PopEnum<AudioOutputModeTarget>()}; | ||
837 | const auto output_mode{rp.PopEnum<AudioOutputMode>()}; | ||
838 | |||
839 | const auto result = SetAudioOutputMode(target, output_mode); | ||
840 | |||
841 | LOG_INFO(Service_SET, "called, target={}, output_mode={}", target, output_mode); | 772 | LOG_INFO(Service_SET, "called, target={}, output_mode={}", target, output_mode); |
842 | 773 | ||
843 | IPC::ResponseBuilder rb{ctx, 2}; | 774 | switch (target) { |
844 | rb.Push(result); | 775 | case AudioOutputModeTarget::Hdmi: |
776 | m_system_settings.audio_output_mode_hdmi = output_mode; | ||
777 | break; | ||
778 | case AudioOutputModeTarget::Speaker: | ||
779 | m_system_settings.audio_output_mode_speaker = output_mode; | ||
780 | break; | ||
781 | case AudioOutputModeTarget::Headphone: | ||
782 | m_system_settings.audio_output_mode_headphone = output_mode; | ||
783 | break; | ||
784 | case AudioOutputModeTarget::Type3: | ||
785 | m_system_settings.audio_output_mode_type3 = output_mode; | ||
786 | break; | ||
787 | case AudioOutputModeTarget::Type4: | ||
788 | m_system_settings.audio_output_mode_type4 = output_mode; | ||
789 | break; | ||
790 | default: | ||
791 | LOG_ERROR(Service_SET, "Invalid audio output mode target {}", target); | ||
792 | } | ||
793 | |||
794 | SetSaveNeeded(); | ||
795 | R_SUCCEED(); | ||
845 | } | 796 | } |
846 | 797 | ||
847 | void ISystemSettingsServer::GetSpeakerAutoMuteFlag(HLERequestContext& ctx) { | 798 | Result ISystemSettingsServer::GetSpeakerAutoMuteFlag( |
799 | Out<bool> out_force_mute_on_headphone_removed) { | ||
848 | LOG_INFO(Service_SET, "called, force_mute_on_headphone_removed={}", | 800 | LOG_INFO(Service_SET, "called, force_mute_on_headphone_removed={}", |
849 | m_system_settings.force_mute_on_headphone_removed); | 801 | m_system_settings.force_mute_on_headphone_removed); |
850 | 802 | ||
851 | IPC::ResponseBuilder rb{ctx, 3}; | 803 | *out_force_mute_on_headphone_removed = m_system_settings.force_mute_on_headphone_removed; |
852 | rb.Push(ResultSuccess); | 804 | R_SUCCEED(); |
853 | rb.PushRaw(m_system_settings.force_mute_on_headphone_removed); | ||
854 | } | 805 | } |
855 | 806 | ||
856 | void ISystemSettingsServer::SetSpeakerAutoMuteFlag(HLERequestContext& ctx) { | 807 | Result ISystemSettingsServer::SetSpeakerAutoMuteFlag(bool force_mute_on_headphone_removed) { |
857 | IPC::RequestParser rp{ctx}; | ||
858 | m_system_settings.force_mute_on_headphone_removed = rp.PopRaw<bool>(); | ||
859 | SetSaveNeeded(); | ||
860 | |||
861 | LOG_INFO(Service_SET, "called, force_mute_on_headphone_removed={}", | 808 | LOG_INFO(Service_SET, "called, force_mute_on_headphone_removed={}", |
862 | m_system_settings.force_mute_on_headphone_removed); | 809 | force_mute_on_headphone_removed); |
863 | 810 | ||
864 | IPC::ResponseBuilder rb{ctx, 2}; | 811 | m_system_settings.force_mute_on_headphone_removed = force_mute_on_headphone_removed; |
865 | rb.Push(ResultSuccess); | 812 | SetSaveNeeded(); |
813 | R_SUCCEED(); | ||
866 | } | 814 | } |
867 | 815 | ||
868 | void ISystemSettingsServer::GetQuestFlag(HLERequestContext& ctx) { | 816 | Result ISystemSettingsServer::GetQuestFlag(Out<QuestFlag> out_quest_flag) { |
869 | LOG_INFO(Service_SET, "called, quest_flag={}", m_system_settings.quest_flag); | 817 | LOG_INFO(Service_SET, "called, quest_flag={}", m_system_settings.quest_flag); |
870 | 818 | ||
871 | IPC::ResponseBuilder rb{ctx, 3}; | 819 | *out_quest_flag = m_system_settings.quest_flag; |
872 | rb.Push(ResultSuccess); | 820 | R_SUCCEED(); |
873 | rb.PushEnum(m_system_settings.quest_flag); | ||
874 | } | 821 | } |
875 | 822 | ||
876 | void ISystemSettingsServer::SetQuestFlag(HLERequestContext& ctx) { | 823 | Result ISystemSettingsServer::SetQuestFlag(QuestFlag quest_flag) { |
877 | IPC::RequestParser rp{ctx}; | 824 | LOG_INFO(Service_SET, "called, quest_flag={}", quest_flag); |
878 | m_system_settings.quest_flag = rp.PopEnum<QuestFlag>(); | ||
879 | SetSaveNeeded(); | ||
880 | 825 | ||
881 | LOG_INFO(Service_SET, "called, quest_flag={}", m_system_settings.quest_flag); | 826 | m_system_settings.quest_flag = quest_flag; |
882 | 827 | SetSaveNeeded(); | |
883 | IPC::ResponseBuilder rb{ctx, 2}; | 828 | R_SUCCEED(); |
884 | rb.Push(ResultSuccess); | ||
885 | } | 829 | } |
886 | 830 | ||
887 | void ISystemSettingsServer::GetDeviceTimeZoneLocationName(HLERequestContext& ctx) { | 831 | Result ISystemSettingsServer::GetDeviceTimeZoneLocationName( |
832 | Out<Service::PSC::Time::LocationName> out_name) { | ||
888 | LOG_INFO(Service_SET, "called"); | 833 | LOG_INFO(Service_SET, "called"); |
889 | 834 | ||
890 | Service::PSC::Time::LocationName name{}; | 835 | *out_name = m_system_settings.device_time_zone_location_name; |
891 | const auto res = GetDeviceTimeZoneLocationName(name); | 836 | R_SUCCEED(); |
892 | |||
893 | IPC::ResponseBuilder rb{ctx, 2 + sizeof(Service::PSC::Time::LocationName) / sizeof(u32)}; | ||
894 | rb.Push(res); | ||
895 | rb.PushRaw<Service::PSC::Time::LocationName>(name); | ||
896 | } | 837 | } |
897 | 838 | ||
898 | void ISystemSettingsServer::SetDeviceTimeZoneLocationName(HLERequestContext& ctx) { | 839 | Result ISystemSettingsServer::SetDeviceTimeZoneLocationName( |
840 | const Service::PSC::Time::LocationName& name) { | ||
899 | LOG_INFO(Service_SET, "called"); | 841 | LOG_INFO(Service_SET, "called"); |
900 | 842 | ||
901 | IPC::RequestParser rp{ctx}; | 843 | m_system_settings.device_time_zone_location_name = name; |
902 | auto name{rp.PopRaw<Service::PSC::Time::LocationName>()}; | ||
903 | |||
904 | const auto res = SetDeviceTimeZoneLocationName(name); | ||
905 | |||
906 | IPC::ResponseBuilder rb{ctx, 2}; | ||
907 | rb.Push(res); | ||
908 | } | ||
909 | |||
910 | void ISystemSettingsServer::SetRegionCode(HLERequestContext& ctx) { | ||
911 | IPC::RequestParser rp{ctx}; | ||
912 | m_system_settings.region_code = rp.PopEnum<SystemRegionCode>(); | ||
913 | SetSaveNeeded(); | 844 | SetSaveNeeded(); |
914 | 845 | R_SUCCEED(); | |
915 | LOG_INFO(Service_SET, "called, region_code={}", m_system_settings.region_code); | ||
916 | |||
917 | IPC::ResponseBuilder rb{ctx, 2}; | ||
918 | rb.Push(ResultSuccess); | ||
919 | } | 846 | } |
920 | 847 | ||
921 | void ISystemSettingsServer::GetNetworkSystemClockContext(HLERequestContext& ctx) { | 848 | Result ISystemSettingsServer::SetRegionCode(SystemRegionCode region_code) { |
922 | LOG_INFO(Service_SET, "called"); | 849 | LOG_INFO(Service_SET, "called, region_code={}", region_code); |
923 | 850 | ||
924 | Service::PSC::Time::SystemClockContext context{}; | 851 | m_system_settings.region_code = region_code; |
925 | const auto res = GetNetworkSystemClockContext(context); | 852 | SetSaveNeeded(); |
926 | 853 | R_SUCCEED(); | |
927 | IPC::ResponseBuilder rb{ctx, 2 + sizeof(Service::PSC::Time::SystemClockContext) / sizeof(u32)}; | ||
928 | rb.Push(res); | ||
929 | rb.PushRaw(context); | ||
930 | } | 854 | } |
931 | 855 | ||
932 | void ISystemSettingsServer::SetNetworkSystemClockContext(HLERequestContext& ctx) { | 856 | Result ISystemSettingsServer::GetNetworkSystemClockContext( |
857 | Out<Service::PSC::Time::SystemClockContext> out_context) { | ||
933 | LOG_INFO(Service_SET, "called"); | 858 | LOG_INFO(Service_SET, "called"); |
934 | 859 | ||
935 | IPC::RequestParser rp{ctx}; | 860 | *out_context = m_system_settings.network_system_clock_context; |
936 | const auto context{rp.PopRaw<Service::PSC::Time::SystemClockContext>()}; | 861 | R_SUCCEED(); |
937 | |||
938 | const auto res = SetNetworkSystemClockContext(context); | ||
939 | |||
940 | IPC::ResponseBuilder rb{ctx, 2}; | ||
941 | rb.Push(res); | ||
942 | } | 862 | } |
943 | 863 | ||
944 | void ISystemSettingsServer::IsUserSystemClockAutomaticCorrectionEnabled(HLERequestContext& ctx) { | 864 | Result ISystemSettingsServer::SetNetworkSystemClockContext( |
865 | const Service::PSC::Time::SystemClockContext& context) { | ||
945 | LOG_INFO(Service_SET, "called"); | 866 | LOG_INFO(Service_SET, "called"); |
946 | 867 | ||
947 | bool enabled{}; | 868 | m_system_settings.network_system_clock_context = context; |
948 | const auto res = IsUserSystemClockAutomaticCorrectionEnabled(enabled); | 869 | SetSaveNeeded(); |
949 | 870 | R_SUCCEED(); | |
950 | IPC::ResponseBuilder rb{ctx, 3}; | ||
951 | rb.Push(res); | ||
952 | rb.PushRaw(enabled); | ||
953 | } | 871 | } |
954 | 872 | ||
955 | void ISystemSettingsServer::SetUserSystemClockAutomaticCorrectionEnabled(HLERequestContext& ctx) { | 873 | Result ISystemSettingsServer::IsUserSystemClockAutomaticCorrectionEnabled( |
956 | LOG_INFO(Service_SET, "called"); | 874 | Out<bool> out_automatic_correction_enabled) { |
875 | LOG_INFO(Service_SET, "called, out_automatic_correction_enabled={}", | ||
876 | m_system_settings.user_system_clock_automatic_correction_enabled); | ||
957 | 877 | ||
958 | IPC::RequestParser rp{ctx}; | 878 | *out_automatic_correction_enabled = |
959 | auto enabled{rp.Pop<bool>()}; | 879 | m_system_settings.user_system_clock_automatic_correction_enabled; |
880 | R_SUCCEED(); | ||
881 | } | ||
960 | 882 | ||
961 | const auto res = SetUserSystemClockAutomaticCorrectionEnabled(enabled); | 883 | Result ISystemSettingsServer::SetUserSystemClockAutomaticCorrectionEnabled( |
884 | bool automatic_correction_enabled) { | ||
885 | LOG_INFO(Service_SET, "called, out_automatic_correction_enabled={}", | ||
886 | automatic_correction_enabled); | ||
962 | 887 | ||
963 | IPC::ResponseBuilder rb{ctx, 2}; | 888 | m_system_settings.user_system_clock_automatic_correction_enabled = automatic_correction_enabled; |
964 | rb.Push(res); | 889 | SetSaveNeeded(); |
890 | R_SUCCEED(); | ||
965 | } | 891 | } |
966 | 892 | ||
967 | void ISystemSettingsServer::GetDebugModeFlag(HLERequestContext& ctx) { | 893 | Result ISystemSettingsServer::GetDebugModeFlag(Out<bool> is_debug_mode_enabled) { |
968 | bool is_debug_mode_enabled = false; | 894 | const auto result = GetSettingsItemValueImpl<bool>(*is_debug_mode_enabled, "settings_debug", |
969 | GetSettingsItemValue<bool>(is_debug_mode_enabled, "settings_debug", "is_debug_mode_enabled"); | 895 | "is_debug_mode_enabled"); |
970 | 896 | ||
971 | LOG_DEBUG(Service_SET, "called, is_debug_mode_enabled={}", is_debug_mode_enabled); | 897 | LOG_DEBUG(Service_SET, "called, is_debug_mode_enabled={}", *is_debug_mode_enabled); |
972 | 898 | R_RETURN(result); | |
973 | IPC::ResponseBuilder rb{ctx, 3}; | ||
974 | rb.Push(ResultSuccess); | ||
975 | rb.Push(is_debug_mode_enabled); | ||
976 | } | 899 | } |
977 | 900 | ||
978 | void ISystemSettingsServer::GetPrimaryAlbumStorage(HLERequestContext& ctx) { | 901 | Result ISystemSettingsServer::GetPrimaryAlbumStorage( |
902 | Out<PrimaryAlbumStorage> out_primary_album_storage) { | ||
979 | LOG_INFO(Service_SET, "called, primary_album_storage={}", | 903 | LOG_INFO(Service_SET, "called, primary_album_storage={}", |
980 | m_system_settings.primary_album_storage); | 904 | m_system_settings.primary_album_storage); |
981 | 905 | ||
982 | IPC::ResponseBuilder rb{ctx, 3}; | 906 | *out_primary_album_storage = m_system_settings.primary_album_storage; |
983 | rb.Push(ResultSuccess); | 907 | R_SUCCEED(); |
984 | rb.PushEnum(m_system_settings.primary_album_storage); | ||
985 | } | 908 | } |
986 | 909 | ||
987 | void ISystemSettingsServer::SetPrimaryAlbumStorage(HLERequestContext& ctx) { | 910 | Result ISystemSettingsServer::SetPrimaryAlbumStorage(PrimaryAlbumStorage primary_album_storage) { |
988 | IPC::RequestParser rp{ctx}; | 911 | LOG_INFO(Service_SET, "called, primary_album_storage={}", primary_album_storage); |
989 | m_system_settings.primary_album_storage = rp.PopEnum<PrimaryAlbumStorage>(); | ||
990 | SetSaveNeeded(); | ||
991 | 912 | ||
992 | LOG_INFO(Service_SET, "called, primary_album_storage={}", | 913 | m_system_settings.primary_album_storage = primary_album_storage; |
993 | m_system_settings.primary_album_storage); | 914 | SetSaveNeeded(); |
994 | 915 | R_SUCCEED(); | |
995 | IPC::ResponseBuilder rb{ctx, 2}; | ||
996 | rb.Push(ResultSuccess); | ||
997 | } | 916 | } |
998 | 917 | ||
999 | void ISystemSettingsServer::GetBatteryLot(HLERequestContext& ctx) { | 918 | Result ISystemSettingsServer::GetBatteryLot(Out<BatteryLot> out_battery_lot) { |
1000 | BatteryLot battery_lot = {"YUZUEMULATOR123456789"}; | ||
1001 | |||
1002 | LOG_INFO(Service_SET, "called"); | 919 | LOG_INFO(Service_SET, "called"); |
1003 | 920 | ||
1004 | IPC::ResponseBuilder rb{ctx, 8}; | 921 | *out_battery_lot = {"YUZU0EMULATOR14022024"}; |
1005 | rb.Push(ResultSuccess); | 922 | R_SUCCEED(); |
1006 | rb.PushRaw(battery_lot); | ||
1007 | } | 923 | } |
1008 | 924 | ||
1009 | void ISystemSettingsServer::GetSerialNumber(HLERequestContext& ctx) { | 925 | Result ISystemSettingsServer::GetSerialNumber(Out<SerialNumber> out_console_serial) { |
1010 | SerialNumber console_serial = {"YUZ10012345678"}; | ||
1011 | |||
1012 | LOG_INFO(Service_SET, "called"); | 926 | LOG_INFO(Service_SET, "called"); |
1013 | 927 | ||
1014 | IPC::ResponseBuilder rb{ctx, 8}; | 928 | *out_console_serial = {"YUZ10000000001"}; |
1015 | rb.Push(ResultSuccess); | 929 | R_SUCCEED(); |
1016 | rb.PushRaw(console_serial); | ||
1017 | } | 930 | } |
1018 | 931 | ||
1019 | void ISystemSettingsServer::GetNfcEnableFlag(HLERequestContext& ctx) { | 932 | Result ISystemSettingsServer::GetNfcEnableFlag(Out<bool> out_nfc_enable_flag) { |
1020 | LOG_INFO(Service_SET, "called, nfc_enable_flag={}", m_system_settings.nfc_enable_flag); | 933 | LOG_INFO(Service_SET, "called, nfc_enable_flag={}", m_system_settings.nfc_enable_flag); |
1021 | 934 | ||
1022 | IPC::ResponseBuilder rb{ctx, 3}; | 935 | *out_nfc_enable_flag = m_system_settings.nfc_enable_flag; |
1023 | rb.Push(ResultSuccess); | 936 | R_SUCCEED(); |
1024 | rb.Push<u8>(m_system_settings.nfc_enable_flag); | ||
1025 | } | 937 | } |
1026 | 938 | ||
1027 | void ISystemSettingsServer::SetNfcEnableFlag(HLERequestContext& ctx) { | 939 | Result ISystemSettingsServer::SetNfcEnableFlag(bool nfc_enable_flag) { |
1028 | IPC::RequestParser rp{ctx}; | 940 | LOG_INFO(Service_SET, "called, nfc_enable_flag={}", nfc_enable_flag); |
1029 | m_system_settings.nfc_enable_flag = rp.Pop<bool>(); | ||
1030 | SetSaveNeeded(); | ||
1031 | |||
1032 | LOG_INFO(Service_SET, "called, nfc_enable_flag={}", m_system_settings.nfc_enable_flag); | ||
1033 | 941 | ||
1034 | IPC::ResponseBuilder rb{ctx, 2}; | 942 | m_system_settings.nfc_enable_flag = nfc_enable_flag; |
1035 | rb.Push(ResultSuccess); | 943 | SetSaveNeeded(); |
944 | R_SUCCEED(); | ||
1036 | } | 945 | } |
1037 | 946 | ||
1038 | void ISystemSettingsServer::GetSleepSettings(HLERequestContext& ctx) { | 947 | Result ISystemSettingsServer::GetSleepSettings(Out<SleepSettings> out_sleep_settings) { |
1039 | LOG_INFO(Service_SET, "called, flags={}, handheld_sleep_plan={}, console_sleep_plan={}", | 948 | LOG_INFO(Service_SET, "called, flags={}, handheld_sleep_plan={}, console_sleep_plan={}", |
1040 | m_system_settings.sleep_settings.flags.raw, | 949 | m_system_settings.sleep_settings.flags.raw, |
1041 | m_system_settings.sleep_settings.handheld_sleep_plan, | 950 | m_system_settings.sleep_settings.handheld_sleep_plan, |
1042 | m_system_settings.sleep_settings.console_sleep_plan); | 951 | m_system_settings.sleep_settings.console_sleep_plan); |
1043 | 952 | ||
1044 | IPC::ResponseBuilder rb{ctx, 5}; | 953 | *out_sleep_settings = m_system_settings.sleep_settings; |
1045 | rb.Push(ResultSuccess); | 954 | R_SUCCEED(); |
1046 | rb.PushRaw(m_system_settings.sleep_settings); | ||
1047 | } | 955 | } |
1048 | 956 | ||
1049 | void ISystemSettingsServer::SetSleepSettings(HLERequestContext& ctx) { | 957 | Result ISystemSettingsServer::SetSleepSettings(SleepSettings sleep_settings) { |
1050 | IPC::RequestParser rp{ctx}; | ||
1051 | m_system_settings.sleep_settings = rp.PopRaw<SleepSettings>(); | ||
1052 | SetSaveNeeded(); | ||
1053 | |||
1054 | LOG_INFO(Service_SET, "called, flags={}, handheld_sleep_plan={}, console_sleep_plan={}", | 958 | LOG_INFO(Service_SET, "called, flags={}, handheld_sleep_plan={}, console_sleep_plan={}", |
1055 | m_system_settings.sleep_settings.flags.raw, | 959 | sleep_settings.flags.raw, sleep_settings.handheld_sleep_plan, |
1056 | m_system_settings.sleep_settings.handheld_sleep_plan, | 960 | sleep_settings.console_sleep_plan); |
1057 | m_system_settings.sleep_settings.console_sleep_plan); | ||
1058 | 961 | ||
1059 | IPC::ResponseBuilder rb{ctx, 2}; | 962 | m_system_settings.sleep_settings = sleep_settings; |
1060 | rb.Push(ResultSuccess); | 963 | SetSaveNeeded(); |
964 | R_SUCCEED(); | ||
1061 | } | 965 | } |
1062 | 966 | ||
1063 | void ISystemSettingsServer::GetWirelessLanEnableFlag(HLERequestContext& ctx) { | 967 | Result ISystemSettingsServer::GetWirelessLanEnableFlag(Out<bool> out_wireless_lan_enable_flag) { |
1064 | LOG_INFO(Service_SET, "called, wireless_lan_enable_flag={}", | 968 | LOG_INFO(Service_SET, "called, wireless_lan_enable_flag={}", |
1065 | m_system_settings.wireless_lan_enable_flag); | 969 | m_system_settings.wireless_lan_enable_flag); |
1066 | 970 | ||
1067 | IPC::ResponseBuilder rb{ctx, 3}; | 971 | *out_wireless_lan_enable_flag = m_system_settings.wireless_lan_enable_flag; |
1068 | rb.Push(ResultSuccess); | 972 | R_SUCCEED(); |
1069 | rb.Push(m_system_settings.wireless_lan_enable_flag); | ||
1070 | } | 973 | } |
1071 | 974 | ||
1072 | void ISystemSettingsServer::SetWirelessLanEnableFlag(HLERequestContext& ctx) { | 975 | Result ISystemSettingsServer::SetWirelessLanEnableFlag(bool wireless_lan_enable_flag) { |
1073 | IPC::RequestParser rp{ctx}; | 976 | LOG_INFO(Service_SET, "called, wireless_lan_enable_flag={}", wireless_lan_enable_flag); |
1074 | m_system_settings.wireless_lan_enable_flag = rp.Pop<bool>(); | ||
1075 | SetSaveNeeded(); | ||
1076 | |||
1077 | LOG_INFO(Service_SET, "called, wireless_lan_enable_flag={}", | ||
1078 | m_system_settings.wireless_lan_enable_flag); | ||
1079 | 977 | ||
1080 | IPC::ResponseBuilder rb{ctx, 2}; | 978 | m_system_settings.wireless_lan_enable_flag = wireless_lan_enable_flag; |
1081 | rb.Push(ResultSuccess); | 979 | SetSaveNeeded(); |
980 | R_SUCCEED(); | ||
1082 | } | 981 | } |
1083 | 982 | ||
1084 | void ISystemSettingsServer::GetInitialLaunchSettings(HLERequestContext& ctx) { | 983 | Result ISystemSettingsServer::GetInitialLaunchSettings( |
984 | Out<InitialLaunchSettings> out_initial_launch_settings) { | ||
1085 | LOG_INFO(Service_SET, "called, flags={}, timestamp={}", | 985 | LOG_INFO(Service_SET, "called, flags={}, timestamp={}", |
1086 | m_system_settings.initial_launch_settings_packed.flags.raw, | 986 | m_system_settings.initial_launch_settings_packed.flags.raw, |
1087 | m_system_settings.initial_launch_settings_packed.timestamp.time_point); | 987 | m_system_settings.initial_launch_settings_packed.timestamp.time_point); |
1088 | 988 | ||
1089 | IPC::ResponseBuilder rb{ctx, 10}; | 989 | *out_initial_launch_settings = { |
1090 | rb.Push(ResultSuccess); | 990 | .flags = m_system_settings.initial_launch_settings_packed.flags, |
1091 | rb.PushRaw(m_system_settings.initial_launch_settings_packed); | 991 | .timestamp = m_system_settings.initial_launch_settings_packed.timestamp, |
992 | }; | ||
993 | R_SUCCEED(); | ||
1092 | } | 994 | } |
1093 | 995 | ||
1094 | void ISystemSettingsServer::SetInitialLaunchSettings(HLERequestContext& ctx) { | 996 | Result ISystemSettingsServer::SetInitialLaunchSettings( |
1095 | IPC::RequestParser rp{ctx}; | 997 | InitialLaunchSettings initial_launch_settings) { |
1096 | auto initial_launch_settings = rp.PopRaw<InitialLaunchSettings>(); | 998 | LOG_INFO(Service_SET, "called, flags={}, timestamp={}", initial_launch_settings.flags.raw, |
999 | initial_launch_settings.timestamp.time_point); | ||
1097 | 1000 | ||
1098 | m_system_settings.initial_launch_settings_packed.flags = initial_launch_settings.flags; | 1001 | m_system_settings.initial_launch_settings_packed.flags = initial_launch_settings.flags; |
1099 | m_system_settings.initial_launch_settings_packed.timestamp = initial_launch_settings.timestamp; | 1002 | m_system_settings.initial_launch_settings_packed.timestamp = initial_launch_settings.timestamp; |
1100 | SetSaveNeeded(); | 1003 | SetSaveNeeded(); |
1101 | 1004 | R_SUCCEED(); | |
1102 | LOG_INFO(Service_SET, "called, flags={}, timestamp={}", | ||
1103 | m_system_settings.initial_launch_settings_packed.flags.raw, | ||
1104 | m_system_settings.initial_launch_settings_packed.timestamp.time_point); | ||
1105 | |||
1106 | IPC::ResponseBuilder rb{ctx, 2}; | ||
1107 | rb.Push(ResultSuccess); | ||
1108 | } | 1005 | } |
1109 | 1006 | ||
1110 | void ISystemSettingsServer::GetDeviceNickName(HLERequestContext& ctx) { | 1007 | Result ISystemSettingsServer::GetDeviceNickName( |
1008 | OutLargeData<std::array<u8, 0x80>, BufferAttr_HipcMapAlias> out_device_name) { | ||
1111 | LOG_DEBUG(Service_SET, "called"); | 1009 | LOG_DEBUG(Service_SET, "called"); |
1112 | 1010 | ||
1113 | ctx.WriteBuffer(::Settings::values.device_name.GetValue()); | 1011 | *out_device_name = {}; |
1012 | const auto device_name_buffer = ::Settings::values.device_name.GetValue().c_str(); | ||
1013 | memcpy(out_device_name->data(), device_name_buffer, | ||
1014 | ::Settings::values.device_name.GetValue().size()); | ||
1114 | 1015 | ||
1115 | IPC::ResponseBuilder rb{ctx, 2}; | 1016 | R_SUCCEED(); |
1116 | rb.Push(ResultSuccess); | ||
1117 | } | 1017 | } |
1118 | 1018 | ||
1119 | void ISystemSettingsServer::SetDeviceNickName(HLERequestContext& ctx) { | 1019 | Result ISystemSettingsServer::SetDeviceNickName( |
1120 | const std::string device_name = Common::StringFromBuffer(ctx.ReadBuffer()); | 1020 | InLargeData<std::array<u8, 0x80>, BufferAttr_HipcMapAlias> device_name_buffer) { |
1021 | const std::string device_name = Common::StringFromBuffer(*device_name_buffer); | ||
1121 | 1022 | ||
1122 | LOG_INFO(Service_SET, "called, device_name={}", device_name); | 1023 | LOG_INFO(Service_SET, "called, device_name={}", device_name); |
1123 | 1024 | ||
1124 | ::Settings::values.device_name = device_name; | 1025 | ::Settings::values.device_name = device_name; |
1125 | 1026 | R_SUCCEED(); | |
1126 | IPC::ResponseBuilder rb{ctx, 2}; | ||
1127 | rb.Push(ResultSuccess); | ||
1128 | } | 1027 | } |
1129 | 1028 | ||
1130 | void ISystemSettingsServer::GetProductModel(HLERequestContext& ctx) { | 1029 | Result ISystemSettingsServer::GetProductModel(Out<u32> out_product_model) { |
1131 | const u32 product_model = 1; | 1030 | const u32 product_model = 1; |
1132 | 1031 | ||
1133 | LOG_WARNING(Service_SET, "(STUBBED) called, product_model={}", product_model); | 1032 | LOG_WARNING(Service_SET, "(STUBBED) called, product_model={}", product_model); |
1134 | IPC::ResponseBuilder rb{ctx, 3}; | 1033 | |
1135 | rb.Push(ResultSuccess); | 1034 | *out_product_model = product_model; |
1136 | rb.Push(product_model); | 1035 | R_SUCCEED(); |
1137 | } | 1036 | } |
1138 | 1037 | ||
1139 | void ISystemSettingsServer::GetBluetoothEnableFlag(HLERequestContext& ctx) { | 1038 | Result ISystemSettingsServer::GetBluetoothEnableFlag(Out<bool> out_bluetooth_enable_flag) { |
1140 | LOG_INFO(Service_SET, "called, bluetooth_enable_flag={}", | 1039 | LOG_INFO(Service_SET, "called, bluetooth_enable_flag={}", |
1141 | m_system_settings.bluetooth_enable_flag); | 1040 | m_system_settings.bluetooth_enable_flag); |
1142 | 1041 | ||
1143 | IPC::ResponseBuilder rb{ctx, 3}; | 1042 | *out_bluetooth_enable_flag = m_system_settings.bluetooth_enable_flag; |
1144 | rb.Push(ResultSuccess); | 1043 | R_SUCCEED(); |
1145 | rb.Push<u8>(m_system_settings.bluetooth_enable_flag); | ||
1146 | } | 1044 | } |
1147 | 1045 | ||
1148 | void ISystemSettingsServer::SetBluetoothEnableFlag(HLERequestContext& ctx) { | 1046 | Result ISystemSettingsServer::SetBluetoothEnableFlag(bool bluetooth_enable_flag) { |
1149 | IPC::RequestParser rp{ctx}; | 1047 | LOG_INFO(Service_SET, "called, bluetooth_enable_flag={}", bluetooth_enable_flag); |
1150 | m_system_settings.bluetooth_enable_flag = rp.Pop<bool>(); | ||
1151 | SetSaveNeeded(); | ||
1152 | 1048 | ||
1153 | LOG_INFO(Service_SET, "called, bluetooth_enable_flag={}", | 1049 | m_system_settings.bluetooth_enable_flag = bluetooth_enable_flag; |
1154 | m_system_settings.bluetooth_enable_flag); | 1050 | SetSaveNeeded(); |
1155 | 1051 | R_SUCCEED(); | |
1156 | IPC::ResponseBuilder rb{ctx, 2}; | ||
1157 | rb.Push(ResultSuccess); | ||
1158 | } | 1052 | } |
1159 | 1053 | ||
1160 | void ISystemSettingsServer::GetMiiAuthorId(HLERequestContext& ctx) { | 1054 | Result ISystemSettingsServer::GetMiiAuthorId(Out<Common::UUID> out_mii_author_id) { |
1161 | if (m_system_settings.mii_author_id.IsInvalid()) { | 1055 | if (m_system_settings.mii_author_id.IsInvalid()) { |
1162 | m_system_settings.mii_author_id = Common::UUID::MakeDefault(); | 1056 | m_system_settings.mii_author_id = Common::UUID::MakeDefault(); |
1163 | SetSaveNeeded(); | 1057 | SetSaveNeeded(); |
@@ -1166,282 +1060,224 @@ void ISystemSettingsServer::GetMiiAuthorId(HLERequestContext& ctx) { | |||
1166 | LOG_INFO(Service_SET, "called, author_id={}", | 1060 | LOG_INFO(Service_SET, "called, author_id={}", |
1167 | m_system_settings.mii_author_id.FormattedString()); | 1061 | m_system_settings.mii_author_id.FormattedString()); |
1168 | 1062 | ||
1169 | IPC::ResponseBuilder rb{ctx, 6}; | 1063 | *out_mii_author_id = m_system_settings.mii_author_id; |
1170 | rb.Push(ResultSuccess); | 1064 | R_SUCCEED(); |
1171 | rb.PushRaw(m_system_settings.mii_author_id); | ||
1172 | } | 1065 | } |
1173 | 1066 | ||
1174 | void ISystemSettingsServer::GetAutoUpdateEnableFlag(HLERequestContext& ctx) { | 1067 | Result ISystemSettingsServer::GetAutoUpdateEnableFlag(Out<bool> out_auto_update_enable_flag) { |
1175 | LOG_INFO(Service_SET, "called, auto_update_flag={}", m_system_settings.auto_update_enable_flag); | 1068 | LOG_INFO(Service_SET, "called, auto_update_flag={}", m_system_settings.auto_update_enable_flag); |
1176 | 1069 | ||
1177 | IPC::ResponseBuilder rb{ctx, 3}; | 1070 | *out_auto_update_enable_flag = m_system_settings.auto_update_enable_flag; |
1178 | rb.Push(ResultSuccess); | 1071 | R_SUCCEED(); |
1179 | rb.Push(m_system_settings.auto_update_enable_flag); | ||
1180 | } | 1072 | } |
1181 | 1073 | ||
1182 | void ISystemSettingsServer::SetAutoUpdateEnableFlag(HLERequestContext& ctx) { | 1074 | Result ISystemSettingsServer::SetAutoUpdateEnableFlag(bool auto_update_enable_flag) { |
1183 | IPC::RequestParser rp{ctx}; | 1075 | LOG_INFO(Service_SET, "called, auto_update_flag={}", auto_update_enable_flag); |
1184 | m_system_settings.auto_update_enable_flag = rp.Pop<bool>(); | ||
1185 | SetSaveNeeded(); | ||
1186 | 1076 | ||
1187 | LOG_INFO(Service_SET, "called, auto_update_flag={}", m_system_settings.auto_update_enable_flag); | 1077 | m_system_settings.auto_update_enable_flag = auto_update_enable_flag; |
1188 | 1078 | SetSaveNeeded(); | |
1189 | IPC::ResponseBuilder rb{ctx, 2}; | 1079 | R_SUCCEED(); |
1190 | rb.Push(ResultSuccess); | ||
1191 | } | 1080 | } |
1192 | 1081 | ||
1193 | void ISystemSettingsServer::GetBatteryPercentageFlag(HLERequestContext& ctx) { | 1082 | Result ISystemSettingsServer::GetBatteryPercentageFlag(Out<bool> out_battery_percentage_flag) { |
1194 | LOG_DEBUG(Service_SET, "called, battery_percentage_flag={}", | 1083 | LOG_DEBUG(Service_SET, "called, battery_percentage_flag={}", |
1195 | m_system_settings.battery_percentage_flag); | 1084 | m_system_settings.battery_percentage_flag); |
1196 | 1085 | ||
1197 | IPC::ResponseBuilder rb{ctx, 3}; | 1086 | *out_battery_percentage_flag = m_system_settings.battery_percentage_flag; |
1198 | rb.Push(ResultSuccess); | 1087 | R_SUCCEED(); |
1199 | rb.Push(m_system_settings.battery_percentage_flag); | ||
1200 | } | 1088 | } |
1201 | 1089 | ||
1202 | void ISystemSettingsServer::SetBatteryPercentageFlag(HLERequestContext& ctx) { | 1090 | Result ISystemSettingsServer::SetBatteryPercentageFlag(bool battery_percentage_flag) { |
1203 | IPC::RequestParser rp{ctx}; | 1091 | LOG_INFO(Service_SET, "called, battery_percentage_flag={}", battery_percentage_flag); |
1204 | m_system_settings.battery_percentage_flag = rp.Pop<bool>(); | ||
1205 | SetSaveNeeded(); | ||
1206 | |||
1207 | LOG_INFO(Service_SET, "called, battery_percentage_flag={}", | ||
1208 | m_system_settings.battery_percentage_flag); | ||
1209 | 1092 | ||
1210 | IPC::ResponseBuilder rb{ctx, 2}; | 1093 | m_system_settings.battery_percentage_flag = battery_percentage_flag; |
1211 | rb.Push(ResultSuccess); | 1094 | SetSaveNeeded(); |
1095 | R_SUCCEED(); | ||
1212 | } | 1096 | } |
1213 | 1097 | ||
1214 | void ISystemSettingsServer::SetExternalSteadyClockInternalOffset(HLERequestContext& ctx) { | 1098 | Result ISystemSettingsServer::SetExternalSteadyClockInternalOffset(s64 offset) { |
1215 | LOG_DEBUG(Service_SET, "called."); | 1099 | LOG_DEBUG(Service_SET, "called, external_steady_clock_internal_offset={}", offset); |
1216 | |||
1217 | IPC::RequestParser rp{ctx}; | ||
1218 | auto offset{rp.Pop<s64>()}; | ||
1219 | |||
1220 | const auto res = SetExternalSteadyClockInternalOffset(offset); | ||
1221 | 1100 | ||
1222 | IPC::ResponseBuilder rb{ctx, 2}; | 1101 | m_private_settings.external_steady_clock_internal_offset = offset; |
1223 | rb.Push(res); | 1102 | SetSaveNeeded(); |
1103 | R_SUCCEED(); | ||
1224 | } | 1104 | } |
1225 | 1105 | ||
1226 | void ISystemSettingsServer::GetExternalSteadyClockInternalOffset(HLERequestContext& ctx) { | 1106 | Result ISystemSettingsServer::GetExternalSteadyClockInternalOffset(Out<s64> out_offset) { |
1227 | LOG_DEBUG(Service_SET, "called."); | 1107 | LOG_DEBUG(Service_SET, "called, external_steady_clock_internal_offset={}", |
1108 | m_private_settings.external_steady_clock_internal_offset); | ||
1228 | 1109 | ||
1229 | s64 offset{}; | 1110 | *out_offset = m_private_settings.external_steady_clock_internal_offset; |
1230 | const auto res = GetExternalSteadyClockInternalOffset(offset); | 1111 | R_SUCCEED(); |
1231 | |||
1232 | IPC::ResponseBuilder rb{ctx, 4}; | ||
1233 | rb.Push(res); | ||
1234 | rb.Push(offset); | ||
1235 | } | 1112 | } |
1236 | 1113 | ||
1237 | void ISystemSettingsServer::GetPushNotificationActivityModeOnSleep(HLERequestContext& ctx) { | 1114 | Result ISystemSettingsServer::GetPushNotificationActivityModeOnSleep( |
1115 | Out<s32> out_push_notification_activity_mode_on_sleep) { | ||
1238 | LOG_INFO(Service_SET, "called, push_notification_activity_mode_on_sleep={}", | 1116 | LOG_INFO(Service_SET, "called, push_notification_activity_mode_on_sleep={}", |
1239 | m_system_settings.push_notification_activity_mode_on_sleep); | 1117 | m_system_settings.push_notification_activity_mode_on_sleep); |
1240 | 1118 | ||
1241 | IPC::ResponseBuilder rb{ctx, 3}; | 1119 | *out_push_notification_activity_mode_on_sleep = |
1242 | rb.Push(ResultSuccess); | 1120 | m_system_settings.push_notification_activity_mode_on_sleep; |
1243 | rb.Push(m_system_settings.push_notification_activity_mode_on_sleep); | 1121 | R_SUCCEED(); |
1244 | } | 1122 | } |
1245 | 1123 | ||
1246 | void ISystemSettingsServer::SetPushNotificationActivityModeOnSleep(HLERequestContext& ctx) { | 1124 | Result ISystemSettingsServer::SetPushNotificationActivityModeOnSleep( |
1247 | IPC::RequestParser rp{ctx}; | 1125 | s32 push_notification_activity_mode_on_sleep) { |
1248 | m_system_settings.push_notification_activity_mode_on_sleep = rp.Pop<s32>(); | ||
1249 | SetSaveNeeded(); | ||
1250 | |||
1251 | LOG_INFO(Service_SET, "called, push_notification_activity_mode_on_sleep={}", | 1126 | LOG_INFO(Service_SET, "called, push_notification_activity_mode_on_sleep={}", |
1252 | m_system_settings.push_notification_activity_mode_on_sleep); | 1127 | push_notification_activity_mode_on_sleep); |
1253 | 1128 | ||
1254 | IPC::ResponseBuilder rb{ctx, 2}; | 1129 | m_system_settings.push_notification_activity_mode_on_sleep = |
1255 | rb.Push(ResultSuccess); | 1130 | push_notification_activity_mode_on_sleep; |
1131 | SetSaveNeeded(); | ||
1132 | R_SUCCEED(); | ||
1256 | } | 1133 | } |
1257 | 1134 | ||
1258 | void ISystemSettingsServer::GetErrorReportSharePermission(HLERequestContext& ctx) { | 1135 | Result ISystemSettingsServer::GetErrorReportSharePermission( |
1136 | Out<ErrorReportSharePermission> out_error_report_share_permission) { | ||
1259 | LOG_INFO(Service_SET, "called, error_report_share_permission={}", | 1137 | LOG_INFO(Service_SET, "called, error_report_share_permission={}", |
1260 | m_system_settings.error_report_share_permission); | 1138 | m_system_settings.error_report_share_permission); |
1261 | 1139 | ||
1262 | IPC::ResponseBuilder rb{ctx, 3}; | 1140 | *out_error_report_share_permission = m_system_settings.error_report_share_permission; |
1263 | rb.Push(ResultSuccess); | 1141 | R_SUCCEED(); |
1264 | rb.PushEnum(m_system_settings.error_report_share_permission); | ||
1265 | } | 1142 | } |
1266 | 1143 | ||
1267 | void ISystemSettingsServer::SetErrorReportSharePermission(HLERequestContext& ctx) { | 1144 | Result ISystemSettingsServer::SetErrorReportSharePermission( |
1268 | IPC::RequestParser rp{ctx}; | 1145 | ErrorReportSharePermission error_report_share_permission) { |
1269 | m_system_settings.error_report_share_permission = rp.PopEnum<ErrorReportSharePermission>(); | ||
1270 | SetSaveNeeded(); | ||
1271 | |||
1272 | LOG_INFO(Service_SET, "called, error_report_share_permission={}", | 1146 | LOG_INFO(Service_SET, "called, error_report_share_permission={}", |
1273 | m_system_settings.error_report_share_permission); | 1147 | error_report_share_permission); |
1274 | 1148 | ||
1275 | IPC::ResponseBuilder rb{ctx, 2}; | 1149 | m_system_settings.error_report_share_permission = error_report_share_permission; |
1276 | rb.Push(ResultSuccess); | 1150 | SetSaveNeeded(); |
1151 | R_SUCCEED(); | ||
1277 | } | 1152 | } |
1278 | 1153 | ||
1279 | void ISystemSettingsServer::GetAppletLaunchFlags(HLERequestContext& ctx) { | 1154 | Result ISystemSettingsServer::GetAppletLaunchFlags(Out<u32> out_applet_launch_flag) { |
1280 | LOG_INFO(Service_SET, "called, applet_launch_flag={}", m_system_settings.applet_launch_flag); | 1155 | LOG_INFO(Service_SET, "called, applet_launch_flag={}", m_system_settings.applet_launch_flag); |
1281 | 1156 | ||
1282 | IPC::ResponseBuilder rb{ctx, 3}; | 1157 | *out_applet_launch_flag = m_system_settings.applet_launch_flag; |
1283 | rb.Push(ResultSuccess); | 1158 | R_SUCCEED(); |
1284 | rb.Push(m_system_settings.applet_launch_flag); | ||
1285 | } | 1159 | } |
1286 | 1160 | ||
1287 | void ISystemSettingsServer::SetAppletLaunchFlags(HLERequestContext& ctx) { | 1161 | Result ISystemSettingsServer::SetAppletLaunchFlags(u32 applet_launch_flag) { |
1288 | IPC::RequestParser rp{ctx}; | 1162 | LOG_INFO(Service_SET, "called, applet_launch_flag={}", applet_launch_flag); |
1289 | m_system_settings.applet_launch_flag = rp.Pop<u32>(); | ||
1290 | SetSaveNeeded(); | ||
1291 | |||
1292 | LOG_INFO(Service_SET, "called, applet_launch_flag={}", m_system_settings.applet_launch_flag); | ||
1293 | 1163 | ||
1294 | IPC::ResponseBuilder rb{ctx, 2}; | 1164 | m_system_settings.applet_launch_flag = applet_launch_flag; |
1295 | rb.Push(ResultSuccess); | 1165 | SetSaveNeeded(); |
1166 | R_SUCCEED(); | ||
1296 | } | 1167 | } |
1297 | 1168 | ||
1298 | void ISystemSettingsServer::GetKeyboardLayout(HLERequestContext& ctx) { | 1169 | Result ISystemSettingsServer::GetKeyboardLayout(Out<KeyboardLayout> out_keyboard_layout) { |
1299 | LOG_INFO(Service_SET, "called, keyboard_layout={}", m_system_settings.keyboard_layout); | 1170 | LOG_INFO(Service_SET, "called, keyboard_layout={}", m_system_settings.keyboard_layout); |
1300 | 1171 | ||
1301 | IPC::ResponseBuilder rb{ctx, 3}; | 1172 | *out_keyboard_layout = m_system_settings.keyboard_layout; |
1302 | rb.Push(ResultSuccess); | 1173 | R_SUCCEED(); |
1303 | rb.Push(static_cast<u32>(m_system_settings.keyboard_layout)); | ||
1304 | } | 1174 | } |
1305 | 1175 | ||
1306 | void ISystemSettingsServer::SetKeyboardLayout(HLERequestContext& ctx) { | 1176 | Result ISystemSettingsServer::SetKeyboardLayout(KeyboardLayout keyboard_layout) { |
1307 | IPC::RequestParser rp{ctx}; | 1177 | LOG_INFO(Service_SET, "called, keyboard_layout={}", keyboard_layout); |
1308 | m_system_settings.keyboard_layout = rp.PopRaw<KeyboardLayout>(); | ||
1309 | SetSaveNeeded(); | ||
1310 | |||
1311 | LOG_INFO(Service_SET, "called, keyboard_layout={}", m_system_settings.keyboard_layout); | ||
1312 | 1178 | ||
1313 | IPC::ResponseBuilder rb{ctx, 2}; | 1179 | m_system_settings.keyboard_layout = keyboard_layout; |
1314 | rb.Push(ResultSuccess); | 1180 | R_SUCCEED(); |
1315 | } | 1181 | } |
1316 | 1182 | ||
1317 | void ISystemSettingsServer::GetDeviceTimeZoneLocationUpdatedTime(HLERequestContext& ctx) { | 1183 | Result ISystemSettingsServer::GetDeviceTimeZoneLocationUpdatedTime( |
1184 | Out<Service::PSC::Time::SteadyClockTimePoint> out_time_point) { | ||
1318 | LOG_INFO(Service_SET, "called"); | 1185 | LOG_INFO(Service_SET, "called"); |
1319 | 1186 | ||
1320 | Service::PSC::Time::SteadyClockTimePoint time_point{}; | 1187 | *out_time_point = m_system_settings.device_time_zone_location_updated_time; |
1321 | const auto res = GetDeviceTimeZoneLocationUpdatedTime(time_point); | 1188 | R_SUCCEED(); |
1322 | |||
1323 | IPC::ResponseBuilder rb{ctx, 4}; | ||
1324 | rb.Push(res); | ||
1325 | rb.PushRaw<Service::PSC::Time::SteadyClockTimePoint>(time_point); | ||
1326 | } | 1189 | } |
1327 | 1190 | ||
1328 | void ISystemSettingsServer::SetDeviceTimeZoneLocationUpdatedTime(HLERequestContext& ctx) { | 1191 | Result ISystemSettingsServer::SetDeviceTimeZoneLocationUpdatedTime( |
1192 | const Service::PSC::Time::SteadyClockTimePoint& time_point) { | ||
1329 | LOG_INFO(Service_SET, "called"); | 1193 | LOG_INFO(Service_SET, "called"); |
1330 | 1194 | ||
1331 | IPC::RequestParser rp{ctx}; | 1195 | m_system_settings.device_time_zone_location_updated_time = time_point; |
1332 | auto time_point{rp.PopRaw<Service::PSC::Time::SteadyClockTimePoint>()}; | 1196 | SetSaveNeeded(); |
1333 | 1197 | R_SUCCEED(); | |
1334 | const auto res = SetDeviceTimeZoneLocationUpdatedTime(time_point); | ||
1335 | |||
1336 | IPC::ResponseBuilder rb{ctx, 2}; | ||
1337 | rb.Push(res); | ||
1338 | } | 1198 | } |
1339 | 1199 | ||
1340 | void ISystemSettingsServer::GetUserSystemClockAutomaticCorrectionUpdatedTime( | 1200 | Result ISystemSettingsServer::GetUserSystemClockAutomaticCorrectionUpdatedTime( |
1341 | HLERequestContext& ctx) { | 1201 | Out<Service::PSC::Time::SteadyClockTimePoint> out_time_point) { |
1342 | LOG_INFO(Service_SET, "called"); | 1202 | LOG_INFO(Service_SET, "called"); |
1343 | 1203 | ||
1344 | Service::PSC::Time::SteadyClockTimePoint time_point{}; | 1204 | *out_time_point = m_system_settings.user_system_clock_automatic_correction_updated_time_point; |
1345 | const auto res = GetUserSystemClockAutomaticCorrectionUpdatedTime(time_point); | 1205 | R_SUCCEED(); |
1346 | |||
1347 | IPC::ResponseBuilder rb{ctx, 4}; | ||
1348 | rb.Push(res); | ||
1349 | rb.PushRaw<Service::PSC::Time::SteadyClockTimePoint>(time_point); | ||
1350 | } | 1206 | } |
1351 | 1207 | ||
1352 | void ISystemSettingsServer::SetUserSystemClockAutomaticCorrectionUpdatedTime( | 1208 | Result ISystemSettingsServer::SetUserSystemClockAutomaticCorrectionUpdatedTime( |
1353 | HLERequestContext& ctx) { | 1209 | const Service::PSC::Time::SteadyClockTimePoint& out_time_point) { |
1354 | LOG_INFO(Service_SET, "called"); | 1210 | LOG_INFO(Service_SET, "called"); |
1355 | 1211 | ||
1356 | IPC::RequestParser rp{ctx}; | 1212 | m_system_settings.user_system_clock_automatic_correction_updated_time_point = out_time_point; |
1357 | const auto time_point{rp.PopRaw<Service::PSC::Time::SteadyClockTimePoint>()}; | 1213 | SetSaveNeeded(); |
1358 | 1214 | R_SUCCEED(); | |
1359 | const auto res = SetUserSystemClockAutomaticCorrectionUpdatedTime(time_point); | ||
1360 | |||
1361 | IPC::ResponseBuilder rb{ctx, 2}; | ||
1362 | rb.Push(res); | ||
1363 | } | 1215 | } |
1364 | 1216 | ||
1365 | void ISystemSettingsServer::GetChineseTraditionalInputMethod(HLERequestContext& ctx) { | 1217 | Result ISystemSettingsServer::GetChineseTraditionalInputMethod( |
1218 | Out<ChineseTraditionalInputMethod> out_chinese_traditional_input_method) { | ||
1366 | LOG_INFO(Service_SET, "called, chinese_traditional_input_method={}", | 1219 | LOG_INFO(Service_SET, "called, chinese_traditional_input_method={}", |
1367 | m_system_settings.chinese_traditional_input_method); | 1220 | m_system_settings.chinese_traditional_input_method); |
1368 | 1221 | ||
1369 | IPC::ResponseBuilder rb{ctx, 3}; | 1222 | *out_chinese_traditional_input_method = m_system_settings.chinese_traditional_input_method; |
1370 | rb.Push(ResultSuccess); | 1223 | R_SUCCEED(); |
1371 | rb.PushEnum(m_system_settings.chinese_traditional_input_method); | ||
1372 | } | 1224 | } |
1373 | 1225 | ||
1374 | void ISystemSettingsServer::GetHomeMenuScheme(HLERequestContext& ctx) { | 1226 | Result ISystemSettingsServer::GetHomeMenuScheme(Out<HomeMenuScheme> out_home_menu_scheme) { |
1375 | LOG_DEBUG(Service_SET, "(STUBBED) called"); | 1227 | LOG_DEBUG(Service_SET, "(STUBBED) called"); |
1376 | 1228 | ||
1377 | const HomeMenuScheme default_color = { | 1229 | *out_home_menu_scheme = { |
1378 | .main = 0xFF323232, | 1230 | .main = 0xFF323232, |
1379 | .back = 0xFF323232, | 1231 | .back = 0xFF323232, |
1380 | .sub = 0xFFFFFFFF, | 1232 | .sub = 0xFFFFFFFF, |
1381 | .bezel = 0xFFFFFFFF, | 1233 | .bezel = 0xFFFFFFFF, |
1382 | .extra = 0xFF000000, | 1234 | .extra = 0xFF000000, |
1383 | }; | 1235 | }; |
1384 | 1236 | R_SUCCEED(); | |
1385 | IPC::ResponseBuilder rb{ctx, 2 + sizeof(HomeMenuScheme) / sizeof(u32)}; | ||
1386 | rb.Push(ResultSuccess); | ||
1387 | rb.PushRaw(default_color); | ||
1388 | } | 1237 | } |
1389 | 1238 | ||
1390 | void ISystemSettingsServer::GetHomeMenuSchemeModel(HLERequestContext& ctx) { | 1239 | Result ISystemSettingsServer::GetHomeMenuSchemeModel(Out<u32> out_home_menu_scheme_model) { |
1391 | LOG_WARNING(Service_SET, "(STUBBED) called"); | 1240 | LOG_WARNING(Service_SET, "(STUBBED) called"); |
1392 | 1241 | ||
1393 | IPC::ResponseBuilder rb{ctx, 3}; | 1242 | *out_home_menu_scheme_model = 0; |
1394 | rb.Push(ResultSuccess); | 1243 | R_SUCCEED(); |
1395 | rb.Push(0); | ||
1396 | } | 1244 | } |
1397 | 1245 | ||
1398 | void ISystemSettingsServer::GetTouchScreenMode(HLERequestContext& ctx) { | 1246 | Result ISystemSettingsServer::GetTouchScreenMode(Out<TouchScreenMode> out_touch_screen_mode) { |
1399 | TouchScreenMode touch_screen_mode{}; | 1247 | LOG_INFO(Service_SET, "called, touch_screen_mode={}", m_system_settings.touch_screen_mode); |
1400 | auto res = GetTouchScreenMode(touch_screen_mode); | ||
1401 | 1248 | ||
1402 | LOG_INFO(Service_SET, "called, touch_screen_mode={}", touch_screen_mode); | 1249 | *out_touch_screen_mode = m_system_settings.touch_screen_mode; |
1403 | 1250 | R_SUCCEED(); | |
1404 | IPC::ResponseBuilder rb{ctx, 3}; | ||
1405 | rb.Push(res); | ||
1406 | rb.PushEnum(touch_screen_mode); | ||
1407 | } | 1251 | } |
1408 | 1252 | ||
1409 | void ISystemSettingsServer::SetTouchScreenMode(HLERequestContext& ctx) { | 1253 | Result ISystemSettingsServer::SetTouchScreenMode(TouchScreenMode touch_screen_mode) { |
1410 | IPC::RequestParser rp{ctx}; | ||
1411 | const auto touch_screen_mode = rp.PopEnum<TouchScreenMode>(); | ||
1412 | auto res = SetTouchScreenMode(touch_screen_mode); | ||
1413 | |||
1414 | LOG_INFO(Service_SET, "called, touch_screen_mode={}", touch_screen_mode); | 1254 | LOG_INFO(Service_SET, "called, touch_screen_mode={}", touch_screen_mode); |
1415 | 1255 | ||
1416 | IPC::ResponseBuilder rb{ctx, 2}; | 1256 | m_system_settings.touch_screen_mode = touch_screen_mode; |
1417 | rb.Push(res); | 1257 | SetSaveNeeded(); |
1258 | R_SUCCEED(); | ||
1418 | } | 1259 | } |
1419 | 1260 | ||
1420 | void ISystemSettingsServer::GetFieldTestingFlag(HLERequestContext& ctx) { | 1261 | Result ISystemSettingsServer::GetFieldTestingFlag(Out<bool> out_field_testing_flag) { |
1421 | LOG_INFO(Service_SET, "called, field_testing_flag={}", m_system_settings.field_testing_flag); | 1262 | LOG_INFO(Service_SET, "called, field_testing_flag={}", m_system_settings.field_testing_flag); |
1422 | 1263 | ||
1423 | IPC::ResponseBuilder rb{ctx, 3}; | 1264 | *out_field_testing_flag = m_system_settings.field_testing_flag; |
1424 | rb.Push(ResultSuccess); | 1265 | R_SUCCEED(); |
1425 | rb.Push(m_system_settings.field_testing_flag); | ||
1426 | } | 1266 | } |
1427 | 1267 | ||
1428 | void ISystemSettingsServer::GetPanelCrcMode(HLERequestContext& ctx) { | 1268 | Result ISystemSettingsServer::GetPanelCrcMode(Out<s32> out_panel_crc_mode) { |
1429 | LOG_INFO(Service_SET, "called, panel_crc_mode={}", m_system_settings.panel_crc_mode); | 1269 | LOG_INFO(Service_SET, "called, panel_crc_mode={}", m_system_settings.panel_crc_mode); |
1430 | 1270 | ||
1431 | IPC::ResponseBuilder rb{ctx, 3}; | 1271 | *out_panel_crc_mode = m_system_settings.panel_crc_mode; |
1432 | rb.Push(ResultSuccess); | 1272 | R_SUCCEED(); |
1433 | rb.Push(m_system_settings.panel_crc_mode); | ||
1434 | } | 1273 | } |
1435 | 1274 | ||
1436 | void ISystemSettingsServer::SetPanelCrcMode(HLERequestContext& ctx) { | 1275 | Result ISystemSettingsServer::SetPanelCrcMode(s32 panel_crc_mode) { |
1437 | IPC::RequestParser rp{ctx}; | 1276 | LOG_INFO(Service_SET, "called, panel_crc_mode={}", panel_crc_mode); |
1438 | m_system_settings.panel_crc_mode = rp.PopRaw<s32>(); | ||
1439 | SetSaveNeeded(); | ||
1440 | 1277 | ||
1441 | LOG_INFO(Service_SET, "called, panel_crc_mode={}", m_system_settings.panel_crc_mode); | 1278 | m_system_settings.panel_crc_mode = panel_crc_mode; |
1442 | 1279 | SetSaveNeeded(); | |
1443 | IPC::ResponseBuilder rb{ctx, 2}; | 1280 | R_SUCCEED(); |
1444 | rb.Push(ResultSuccess); | ||
1445 | } | 1281 | } |
1446 | 1282 | ||
1447 | void ISystemSettingsServer::SetupSettings() { | 1283 | void ISystemSettingsServer::SetupSettings() { |
@@ -1513,9 +1349,9 @@ void ISystemSettingsServer::SetSaveNeeded() { | |||
1513 | m_save_needed = true; | 1349 | m_save_needed = true; |
1514 | } | 1350 | } |
1515 | 1351 | ||
1516 | Result ISystemSettingsServer::GetSettingsItemValue(std::vector<u8>& out_value, | 1352 | Result ISystemSettingsServer::GetSettingsItemValueImpl(std::vector<u8>& out_value, |
1517 | const std::string& category, | 1353 | const std::string& category, |
1518 | const std::string& name) { | 1354 | const std::string& name) { |
1519 | auto settings{GetSettings()}; | 1355 | auto settings{GetSettings()}; |
1520 | R_UNLESS(settings.contains(category) && settings[category].contains(name), ResultUnknown); | 1356 | R_UNLESS(settings.contains(category) && settings[category].contains(name), ResultUnknown); |
1521 | 1357 | ||
@@ -1523,184 +1359,4 @@ Result ISystemSettingsServer::GetSettingsItemValue(std::vector<u8>& out_value, | |||
1523 | R_SUCCEED(); | 1359 | R_SUCCEED(); |
1524 | } | 1360 | } |
1525 | 1361 | ||
1526 | Result ISystemSettingsServer::GetVibrationMasterVolume(f32& out_volume) const { | ||
1527 | out_volume = m_system_settings.vibration_master_volume; | ||
1528 | R_SUCCEED(); | ||
1529 | } | ||
1530 | |||
1531 | Result ISystemSettingsServer::SetVibrationMasterVolume(f32 volume) { | ||
1532 | m_system_settings.vibration_master_volume = volume; | ||
1533 | SetSaveNeeded(); | ||
1534 | R_SUCCEED(); | ||
1535 | } | ||
1536 | |||
1537 | Result ISystemSettingsServer::GetAudioOutputMode(AudioOutputMode& out_output_mode, | ||
1538 | AudioOutputModeTarget target) const { | ||
1539 | switch (target) { | ||
1540 | case AudioOutputModeTarget::Hdmi: | ||
1541 | out_output_mode = m_system_settings.audio_output_mode_hdmi; | ||
1542 | break; | ||
1543 | case AudioOutputModeTarget::Speaker: | ||
1544 | out_output_mode = m_system_settings.audio_output_mode_speaker; | ||
1545 | break; | ||
1546 | case AudioOutputModeTarget::Headphone: | ||
1547 | out_output_mode = m_system_settings.audio_output_mode_headphone; | ||
1548 | break; | ||
1549 | case AudioOutputModeTarget::Type3: | ||
1550 | out_output_mode = m_system_settings.audio_output_mode_type3; | ||
1551 | break; | ||
1552 | case AudioOutputModeTarget::Type4: | ||
1553 | out_output_mode = m_system_settings.audio_output_mode_type4; | ||
1554 | break; | ||
1555 | default: | ||
1556 | LOG_ERROR(Service_SET, "Invalid audio output mode target {}", target); | ||
1557 | } | ||
1558 | R_SUCCEED(); | ||
1559 | } | ||
1560 | |||
1561 | Result ISystemSettingsServer::SetAudioOutputMode(AudioOutputModeTarget target, | ||
1562 | AudioOutputMode output_mode) { | ||
1563 | switch (target) { | ||
1564 | case AudioOutputModeTarget::Hdmi: | ||
1565 | m_system_settings.audio_output_mode_hdmi = output_mode; | ||
1566 | break; | ||
1567 | case AudioOutputModeTarget::Speaker: | ||
1568 | m_system_settings.audio_output_mode_speaker = output_mode; | ||
1569 | break; | ||
1570 | case AudioOutputModeTarget::Headphone: | ||
1571 | m_system_settings.audio_output_mode_headphone = output_mode; | ||
1572 | break; | ||
1573 | case AudioOutputModeTarget::Type3: | ||
1574 | m_system_settings.audio_output_mode_type3 = output_mode; | ||
1575 | break; | ||
1576 | case AudioOutputModeTarget::Type4: | ||
1577 | m_system_settings.audio_output_mode_type4 = output_mode; | ||
1578 | break; | ||
1579 | default: | ||
1580 | LOG_ERROR(Service_SET, "Invalid audio output mode target {}", target); | ||
1581 | } | ||
1582 | SetSaveNeeded(); | ||
1583 | R_SUCCEED(); | ||
1584 | } | ||
1585 | |||
1586 | Result ISystemSettingsServer::GetSpeakerAutoMuteFlag(bool& is_auto_mute) const { | ||
1587 | is_auto_mute = m_system_settings.force_mute_on_headphone_removed; | ||
1588 | R_SUCCEED(); | ||
1589 | } | ||
1590 | |||
1591 | Result ISystemSettingsServer::SetSpeakerAutoMuteFlag(bool is_auto_mute) { | ||
1592 | m_system_settings.force_mute_on_headphone_removed = is_auto_mute; | ||
1593 | SetSaveNeeded(); | ||
1594 | R_SUCCEED(); | ||
1595 | } | ||
1596 | |||
1597 | Result ISystemSettingsServer::GetExternalSteadyClockSourceId(Common::UUID& out_id) const { | ||
1598 | out_id = m_private_settings.external_clock_source_id; | ||
1599 | R_SUCCEED(); | ||
1600 | } | ||
1601 | |||
1602 | Result ISystemSettingsServer::SetExternalSteadyClockSourceId(const Common::UUID& id) { | ||
1603 | m_private_settings.external_clock_source_id = id; | ||
1604 | SetSaveNeeded(); | ||
1605 | R_SUCCEED(); | ||
1606 | } | ||
1607 | |||
1608 | Result ISystemSettingsServer::GetUserSystemClockContext( | ||
1609 | Service::PSC::Time::SystemClockContext& out_context) const { | ||
1610 | out_context = m_system_settings.user_system_clock_context; | ||
1611 | R_SUCCEED(); | ||
1612 | } | ||
1613 | |||
1614 | Result ISystemSettingsServer::SetUserSystemClockContext( | ||
1615 | const Service::PSC::Time::SystemClockContext& context) { | ||
1616 | m_system_settings.user_system_clock_context = context; | ||
1617 | SetSaveNeeded(); | ||
1618 | R_SUCCEED(); | ||
1619 | } | ||
1620 | |||
1621 | Result ISystemSettingsServer::GetDeviceTimeZoneLocationName( | ||
1622 | Service::PSC::Time::LocationName& out_name) const { | ||
1623 | out_name = m_system_settings.device_time_zone_location_name; | ||
1624 | R_SUCCEED(); | ||
1625 | } | ||
1626 | |||
1627 | Result ISystemSettingsServer::SetDeviceTimeZoneLocationName( | ||
1628 | const Service::PSC::Time::LocationName& name) { | ||
1629 | m_system_settings.device_time_zone_location_name = name; | ||
1630 | SetSaveNeeded(); | ||
1631 | R_SUCCEED(); | ||
1632 | } | ||
1633 | |||
1634 | Result ISystemSettingsServer::GetNetworkSystemClockContext( | ||
1635 | Service::PSC::Time::SystemClockContext& out_context) const { | ||
1636 | out_context = m_system_settings.network_system_clock_context; | ||
1637 | R_SUCCEED(); | ||
1638 | } | ||
1639 | |||
1640 | Result ISystemSettingsServer::SetNetworkSystemClockContext( | ||
1641 | const Service::PSC::Time::SystemClockContext& context) { | ||
1642 | m_system_settings.network_system_clock_context = context; | ||
1643 | SetSaveNeeded(); | ||
1644 | R_SUCCEED(); | ||
1645 | } | ||
1646 | |||
1647 | Result ISystemSettingsServer::IsUserSystemClockAutomaticCorrectionEnabled(bool& out_enabled) const { | ||
1648 | out_enabled = m_system_settings.user_system_clock_automatic_correction_enabled; | ||
1649 | R_SUCCEED(); | ||
1650 | } | ||
1651 | |||
1652 | Result ISystemSettingsServer::SetUserSystemClockAutomaticCorrectionEnabled(bool enabled) { | ||
1653 | m_system_settings.user_system_clock_automatic_correction_enabled = enabled; | ||
1654 | SetSaveNeeded(); | ||
1655 | R_SUCCEED(); | ||
1656 | } | ||
1657 | |||
1658 | Result ISystemSettingsServer::SetExternalSteadyClockInternalOffset(s64 offset) { | ||
1659 | m_private_settings.external_steady_clock_internal_offset = offset; | ||
1660 | SetSaveNeeded(); | ||
1661 | R_SUCCEED(); | ||
1662 | } | ||
1663 | |||
1664 | Result ISystemSettingsServer::GetExternalSteadyClockInternalOffset(s64& out_offset) const { | ||
1665 | out_offset = m_private_settings.external_steady_clock_internal_offset; | ||
1666 | R_SUCCEED(); | ||
1667 | } | ||
1668 | |||
1669 | Result ISystemSettingsServer::GetDeviceTimeZoneLocationUpdatedTime( | ||
1670 | Service::PSC::Time::SteadyClockTimePoint& out_time_point) const { | ||
1671 | out_time_point = m_system_settings.device_time_zone_location_updated_time; | ||
1672 | R_SUCCEED(); | ||
1673 | } | ||
1674 | |||
1675 | Result ISystemSettingsServer::SetDeviceTimeZoneLocationUpdatedTime( | ||
1676 | const Service::PSC::Time::SteadyClockTimePoint& time_point) { | ||
1677 | m_system_settings.device_time_zone_location_updated_time = time_point; | ||
1678 | SetSaveNeeded(); | ||
1679 | R_SUCCEED(); | ||
1680 | } | ||
1681 | |||
1682 | Result ISystemSettingsServer::GetUserSystemClockAutomaticCorrectionUpdatedTime( | ||
1683 | Service::PSC::Time::SteadyClockTimePoint& out_time_point) const { | ||
1684 | out_time_point = m_system_settings.user_system_clock_automatic_correction_updated_time_point; | ||
1685 | R_SUCCEED(); | ||
1686 | } | ||
1687 | |||
1688 | Result ISystemSettingsServer::SetUserSystemClockAutomaticCorrectionUpdatedTime( | ||
1689 | const Service::PSC::Time::SteadyClockTimePoint& out_time_point) { | ||
1690 | m_system_settings.user_system_clock_automatic_correction_updated_time_point = out_time_point; | ||
1691 | SetSaveNeeded(); | ||
1692 | R_SUCCEED(); | ||
1693 | } | ||
1694 | |||
1695 | Result ISystemSettingsServer::GetTouchScreenMode(TouchScreenMode& touch_screen_mode) const { | ||
1696 | touch_screen_mode = m_system_settings.touch_screen_mode; | ||
1697 | R_SUCCEED(); | ||
1698 | } | ||
1699 | |||
1700 | Result ISystemSettingsServer::SetTouchScreenMode(TouchScreenMode touch_screen_mode) { | ||
1701 | m_system_settings.touch_screen_mode = touch_screen_mode; | ||
1702 | SetSaveNeeded(); | ||
1703 | R_SUCCEED(); | ||
1704 | } | ||
1705 | |||
1706 | } // namespace Service::Set | 1362 | } // namespace Service::Set |
diff --git a/src/core/hle/service/set/system_settings_server.h b/src/core/hle/service/set/system_settings_server.h index 9a3b36f0c..46e06c8ea 100755 --- a/src/core/hle/service/set/system_settings_server.h +++ b/src/core/hle/service/set/system_settings_server.h | |||
@@ -11,6 +11,7 @@ | |||
11 | #include "common/polyfill_thread.h" | 11 | #include "common/polyfill_thread.h" |
12 | #include "common/uuid.h" | 12 | #include "common/uuid.h" |
13 | #include "core/hle/result.h" | 13 | #include "core/hle/result.h" |
14 | #include "core/hle/service/cmif_types.h" | ||
14 | #include "core/hle/service/psc/time/common.h" | 15 | #include "core/hle/service/psc/time/common.h" |
15 | #include "core/hle/service/service.h" | 16 | #include "core/hle/service/service.h" |
16 | #include "core/hle/service/set/setting_formats/appln_settings.h" | 17 | #include "core/hle/service/set/setting_formats/appln_settings.h" |
@@ -33,13 +34,14 @@ public: | |||
33 | explicit ISystemSettingsServer(Core::System& system_); | 34 | explicit ISystemSettingsServer(Core::System& system_); |
34 | ~ISystemSettingsServer() override; | 35 | ~ISystemSettingsServer() override; |
35 | 36 | ||
36 | Result GetSettingsItemValue(std::vector<u8>& out_value, const std::string& category, | 37 | Result GetSettingsItemValueImpl(std::vector<u8>& out_value, const std::string& category, |
37 | const std::string& name); | 38 | const std::string& name); |
38 | 39 | ||
39 | template <typename T> | 40 | template <typename T> |
40 | Result GetSettingsItemValue(T& value, const std::string& category, const std::string& name) { | 41 | Result GetSettingsItemValueImpl(T& value, const std::string& category, |
42 | const std::string& name) { | ||
41 | std::vector<u8> data; | 43 | std::vector<u8> data; |
42 | const auto result = GetSettingsItemValue(data, category, name); | 44 | const auto result = GetSettingsItemValueImpl(data, category, name); |
43 | if (result.IsError()) { | 45 | if (result.IsError()) { |
44 | return result; | 46 | return result; |
45 | } | 47 | } |
@@ -48,120 +50,114 @@ public: | |||
48 | return result; | 50 | return result; |
49 | } | 51 | } |
50 | 52 | ||
51 | Result GetVibrationMasterVolume(f32& out_volume) const; | 53 | public: |
52 | Result SetVibrationMasterVolume(f32 volume); | 54 | Result SetLanguageCode(LanguageCode language_code); |
53 | Result GetAudioOutputMode(AudioOutputMode& out_output_mode, AudioOutputModeTarget target) const; | 55 | Result GetFirmwareVersion( |
56 | OutLargeData<FirmwareVersionFormat, BufferAttr_HipcPointer> out_firmware_data); | ||
57 | Result GetFirmwareVersion2( | ||
58 | OutLargeData<FirmwareVersionFormat, BufferAttr_HipcPointer> out_firmware_data); | ||
59 | Result GetLockScreenFlag(Out<bool> out_lock_screen_flag); | ||
60 | Result SetLockScreenFlag(bool lock_screen_flag); | ||
61 | Result GetExternalSteadyClockSourceId(Out<Common::UUID> out_clock_source_id); | ||
62 | Result SetExternalSteadyClockSourceId(const Common::UUID& clock_source_id); | ||
63 | Result GetUserSystemClockContext(Out<Service::PSC::Time::SystemClockContext> out_clock_context); | ||
64 | Result SetUserSystemClockContext(const Service::PSC::Time::SystemClockContext& clock_context); | ||
65 | Result GetAccountSettings(Out<AccountSettings> out_account_settings); | ||
66 | Result SetAccountSettings(AccountSettings account_settings); | ||
67 | Result GetEulaVersions(Out<s32> out_count, | ||
68 | OutArray<EulaVersion, BufferAttr_HipcMapAlias> out_eula_versions); | ||
69 | Result SetEulaVersions(InArray<EulaVersion, BufferAttr_HipcMapAlias> eula_versions); | ||
70 | Result GetColorSetId(Out<ColorSet> out_color_set_id); | ||
71 | Result SetColorSetId(ColorSet color_set_id); | ||
72 | Result GetNotificationSettings(Out<NotificationSettings> out_notification_settings); | ||
73 | Result SetNotificationSettings(const NotificationSettings& notification_settings); | ||
74 | Result GetAccountNotificationSettings( | ||
75 | Out<s32> out_count, OutArray<AccountNotificationSettings, BufferAttr_HipcMapAlias> | ||
76 | out_account_notification_settings); | ||
77 | Result SetAccountNotificationSettings( | ||
78 | InArray<AccountNotificationSettings, BufferAttr_HipcMapAlias> | ||
79 | account_notification_settings); | ||
80 | Result GetVibrationMasterVolume(Out<f32> vibration_master_volume); | ||
81 | Result SetVibrationMasterVolume(f32 vibration_master_volume); | ||
82 | Result GetSettingsItemValueSize( | ||
83 | Out<u64> out_size, | ||
84 | InLargeData<SettingItemName, BufferAttr_HipcPointer> setting_category_buffer, | ||
85 | InLargeData<SettingItemName, BufferAttr_HipcPointer> setting_name_buf); | ||
86 | Result GetSettingsItemValue( | ||
87 | OutBuffer<BufferAttr_HipcMapAlias> out_data, | ||
88 | InLargeData<SettingItemName, BufferAttr_HipcPointer> setting_category_buffer, | ||
89 | InLargeData<SettingItemName, BufferAttr_HipcPointer> setting_name_buffer); | ||
90 | Result GetTvSettings(Out<TvSettings> out_tv_settings); | ||
91 | Result SetTvSettings(TvSettings tv_settings); | ||
92 | Result GetAudioOutputMode(Out<AudioOutputMode> out_output_mode, AudioOutputModeTarget target); | ||
54 | Result SetAudioOutputMode(AudioOutputModeTarget target, AudioOutputMode output_mode); | 93 | Result SetAudioOutputMode(AudioOutputModeTarget target, AudioOutputMode output_mode); |
55 | Result GetSpeakerAutoMuteFlag(bool& is_auto_mute) const; | 94 | Result GetSpeakerAutoMuteFlag(Out<bool> out_force_mute_on_headphone_removed); |
56 | Result SetSpeakerAutoMuteFlag(bool auto_mute); | 95 | Result SetSpeakerAutoMuteFlag(bool force_mute_on_headphone_removed); |
57 | Result GetExternalSteadyClockSourceId(Common::UUID& out_id) const; | 96 | Result GetQuestFlag(Out<QuestFlag> out_quest_flag); |
58 | Result SetExternalSteadyClockSourceId(const Common::UUID& id); | 97 | Result SetQuestFlag(QuestFlag quest_flag); |
59 | Result GetUserSystemClockContext(Service::PSC::Time::SystemClockContext& out_context) const; | 98 | Result GetDeviceTimeZoneLocationName(Out<Service::PSC::Time::LocationName> out_name); |
60 | Result SetUserSystemClockContext(const Service::PSC::Time::SystemClockContext& context); | ||
61 | Result GetDeviceTimeZoneLocationName(Service::PSC::Time::LocationName& out_name) const; | ||
62 | Result SetDeviceTimeZoneLocationName(const Service::PSC::Time::LocationName& name); | 99 | Result SetDeviceTimeZoneLocationName(const Service::PSC::Time::LocationName& name); |
63 | Result GetNetworkSystemClockContext(Service::PSC::Time::SystemClockContext& out_context) const; | 100 | Result SetRegionCode(SystemRegionCode region_code); |
101 | Result GetNetworkSystemClockContext(Out<Service::PSC::Time::SystemClockContext> out_context); | ||
64 | Result SetNetworkSystemClockContext(const Service::PSC::Time::SystemClockContext& context); | 102 | Result SetNetworkSystemClockContext(const Service::PSC::Time::SystemClockContext& context); |
65 | Result IsUserSystemClockAutomaticCorrectionEnabled(bool& out_enabled) const; | 103 | Result IsUserSystemClockAutomaticCorrectionEnabled(Out<bool> out_automatic_correction_enabled); |
66 | Result SetUserSystemClockAutomaticCorrectionEnabled(bool enabled); | 104 | Result SetUserSystemClockAutomaticCorrectionEnabled(bool automatic_correction_enabled); |
105 | Result GetDebugModeFlag(Out<bool> is_debug_mode_enabled); | ||
106 | Result GetPrimaryAlbumStorage(Out<PrimaryAlbumStorage> out_primary_album_storage); | ||
107 | Result SetPrimaryAlbumStorage(PrimaryAlbumStorage primary_album_storage); | ||
108 | Result GetBatteryLot(Out<BatteryLot> out_battery_lot); | ||
109 | Result GetSerialNumber(Out<SerialNumber> out_console_serial); | ||
110 | Result GetNfcEnableFlag(Out<bool> out_nfc_enable_flag); | ||
111 | Result SetNfcEnableFlag(bool nfc_enable_flag); | ||
112 | Result GetSleepSettings(Out<SleepSettings> out_sleep_settings); | ||
113 | Result SetSleepSettings(SleepSettings sleep_settings); | ||
114 | Result GetWirelessLanEnableFlag(Out<bool> out_wireless_lan_enable_flag); | ||
115 | Result SetWirelessLanEnableFlag(bool wireless_lan_enable_flag); | ||
116 | Result GetInitialLaunchSettings(Out<InitialLaunchSettings> out_initial_launch_settings); | ||
117 | Result SetInitialLaunchSettings(InitialLaunchSettings initial_launch_settings); | ||
118 | Result GetDeviceNickName( | ||
119 | OutLargeData<std::array<u8, 0x80>, BufferAttr_HipcMapAlias> out_device_name); | ||
120 | Result SetDeviceNickName( | ||
121 | InLargeData<std::array<u8, 0x80>, BufferAttr_HipcMapAlias> device_name_buffer); | ||
122 | Result GetProductModel(Out<u32> out_product_model); | ||
123 | Result GetBluetoothEnableFlag(Out<bool> out_bluetooth_enable_flag); | ||
124 | Result SetBluetoothEnableFlag(bool bluetooth_enable_flag); | ||
125 | Result GetMiiAuthorId(Out<Common::UUID> out_mii_author_id); | ||
126 | Result GetAutoUpdateEnableFlag(Out<bool> out_auto_update_enable_flag); | ||
127 | Result SetAutoUpdateEnableFlag(bool auto_update_enable_flag); | ||
128 | Result GetBatteryPercentageFlag(Out<bool> out_battery_percentage_flag); | ||
129 | Result SetBatteryPercentageFlag(bool battery_percentage_flag); | ||
67 | Result SetExternalSteadyClockInternalOffset(s64 offset); | 130 | Result SetExternalSteadyClockInternalOffset(s64 offset); |
68 | Result GetExternalSteadyClockInternalOffset(s64& out_offset) const; | 131 | Result GetExternalSteadyClockInternalOffset(Out<s64> out_offset); |
132 | Result GetPushNotificationActivityModeOnSleep( | ||
133 | Out<s32> out_push_notification_activity_mode_on_sleep); | ||
134 | Result SetPushNotificationActivityModeOnSleep(s32 push_notification_activity_mode_on_sleep); | ||
135 | Result GetErrorReportSharePermission( | ||
136 | Out<ErrorReportSharePermission> out_error_report_share_permission); | ||
137 | Result SetErrorReportSharePermission(ErrorReportSharePermission error_report_share_permission); | ||
138 | Result GetAppletLaunchFlags(Out<u32> out_applet_launch_flag); | ||
139 | Result SetAppletLaunchFlags(u32 applet_launch_flag); | ||
140 | Result GetKeyboardLayout(Out<KeyboardLayout> out_keyboard_layout); | ||
141 | Result SetKeyboardLayout(KeyboardLayout keyboard_layout); | ||
69 | Result GetDeviceTimeZoneLocationUpdatedTime( | 142 | Result GetDeviceTimeZoneLocationUpdatedTime( |
70 | Service::PSC::Time::SteadyClockTimePoint& out_time_point) const; | 143 | Out<Service::PSC::Time::SteadyClockTimePoint> out_time_point); |
71 | Result SetDeviceTimeZoneLocationUpdatedTime( | 144 | Result SetDeviceTimeZoneLocationUpdatedTime( |
72 | const Service::PSC::Time::SteadyClockTimePoint& time_point); | 145 | const Service::PSC::Time::SteadyClockTimePoint& time_point); |
73 | Result GetUserSystemClockAutomaticCorrectionUpdatedTime( | 146 | Result GetUserSystemClockAutomaticCorrectionUpdatedTime( |
74 | Service::PSC::Time::SteadyClockTimePoint& out_time_point) const; | 147 | Out<Service::PSC::Time::SteadyClockTimePoint> out_time_point); |
75 | Result SetUserSystemClockAutomaticCorrectionUpdatedTime( | 148 | Result SetUserSystemClockAutomaticCorrectionUpdatedTime( |
76 | const Service::PSC::Time::SteadyClockTimePoint& time_point); | 149 | const Service::PSC::Time::SteadyClockTimePoint& out_time_point); |
77 | Result GetTouchScreenMode(TouchScreenMode& touch_screen_mode) const; | 150 | Result GetChineseTraditionalInputMethod( |
151 | Out<ChineseTraditionalInputMethod> out_chinese_traditional_input_method); | ||
152 | Result GetHomeMenuScheme(Out<HomeMenuScheme> out_home_menu_scheme); | ||
153 | Result GetHomeMenuSchemeModel(Out<u32> out_home_menu_scheme_model); | ||
154 | Result GetTouchScreenMode(Out<TouchScreenMode> out_touch_screen_mode); | ||
78 | Result SetTouchScreenMode(TouchScreenMode touch_screen_mode); | 155 | Result SetTouchScreenMode(TouchScreenMode touch_screen_mode); |
156 | Result GetFieldTestingFlag(Out<bool> out_field_testing_flag); | ||
157 | Result GetPanelCrcMode(Out<s32> out_panel_crc_mode); | ||
158 | Result SetPanelCrcMode(s32 panel_crc_mode); | ||
79 | 159 | ||
80 | private: | 160 | private: |
81 | void SetLanguageCode(HLERequestContext& ctx); | ||
82 | void GetFirmwareVersion(HLERequestContext& ctx); | ||
83 | void GetFirmwareVersion2(HLERequestContext& ctx); | ||
84 | void GetLockScreenFlag(HLERequestContext& ctx); | ||
85 | void SetLockScreenFlag(HLERequestContext& ctx); | ||
86 | void GetExternalSteadyClockSourceId(HLERequestContext& ctx); | ||
87 | void SetExternalSteadyClockSourceId(HLERequestContext& ctx); | ||
88 | void GetUserSystemClockContext(HLERequestContext& ctx); | ||
89 | void SetUserSystemClockContext(HLERequestContext& ctx); | ||
90 | void GetAccountSettings(HLERequestContext& ctx); | ||
91 | void SetAccountSettings(HLERequestContext& ctx); | ||
92 | void GetEulaVersions(HLERequestContext& ctx); | ||
93 | void SetEulaVersions(HLERequestContext& ctx); | ||
94 | void GetColorSetId(HLERequestContext& ctx); | ||
95 | void SetColorSetId(HLERequestContext& ctx); | ||
96 | void GetNotificationSettings(HLERequestContext& ctx); | ||
97 | void SetNotificationSettings(HLERequestContext& ctx); | ||
98 | void GetAccountNotificationSettings(HLERequestContext& ctx); | ||
99 | void SetAccountNotificationSettings(HLERequestContext& ctx); | ||
100 | void GetVibrationMasterVolume(HLERequestContext& ctx); | ||
101 | void SetVibrationMasterVolume(HLERequestContext& ctx); | ||
102 | void GetSettingsItemValueSize(HLERequestContext& ctx); | ||
103 | void GetSettingsItemValue(HLERequestContext& ctx); | ||
104 | void GetTvSettings(HLERequestContext& ctx); | ||
105 | void SetTvSettings(HLERequestContext& ctx); | ||
106 | void GetAudioOutputMode(HLERequestContext& ctx); | ||
107 | void SetAudioOutputMode(HLERequestContext& ctx); | ||
108 | void GetSpeakerAutoMuteFlag(HLERequestContext& ctx); | ||
109 | void SetSpeakerAutoMuteFlag(HLERequestContext& ctx); | ||
110 | void GetDebugModeFlag(HLERequestContext& ctx); | ||
111 | void GetQuestFlag(HLERequestContext& ctx); | ||
112 | void SetQuestFlag(HLERequestContext& ctx); | ||
113 | void GetDeviceTimeZoneLocationName(HLERequestContext& ctx); | ||
114 | void SetDeviceTimeZoneLocationName(HLERequestContext& ctx); | ||
115 | void SetRegionCode(HLERequestContext& ctx); | ||
116 | void GetNetworkSystemClockContext(HLERequestContext& ctx); | ||
117 | void SetNetworkSystemClockContext(HLERequestContext& ctx); | ||
118 | void IsUserSystemClockAutomaticCorrectionEnabled(HLERequestContext& ctx); | ||
119 | void SetUserSystemClockAutomaticCorrectionEnabled(HLERequestContext& ctx); | ||
120 | void GetPrimaryAlbumStorage(HLERequestContext& ctx); | ||
121 | void SetPrimaryAlbumStorage(HLERequestContext& ctx); | ||
122 | void GetBatteryLot(HLERequestContext& ctx); | ||
123 | void GetSerialNumber(HLERequestContext& ctx); | ||
124 | void GetNfcEnableFlag(HLERequestContext& ctx); | ||
125 | void SetNfcEnableFlag(HLERequestContext& ctx); | ||
126 | void GetSleepSettings(HLERequestContext& ctx); | ||
127 | void SetSleepSettings(HLERequestContext& ctx); | ||
128 | void GetWirelessLanEnableFlag(HLERequestContext& ctx); | ||
129 | void SetWirelessLanEnableFlag(HLERequestContext& ctx); | ||
130 | void GetInitialLaunchSettings(HLERequestContext& ctx); | ||
131 | void SetInitialLaunchSettings(HLERequestContext& ctx); | ||
132 | void GetDeviceNickName(HLERequestContext& ctx); | ||
133 | void SetDeviceNickName(HLERequestContext& ctx); | ||
134 | void GetProductModel(HLERequestContext& ctx); | ||
135 | void GetBluetoothEnableFlag(HLERequestContext& ctx); | ||
136 | void SetBluetoothEnableFlag(HLERequestContext& ctx); | ||
137 | void GetMiiAuthorId(HLERequestContext& ctx); | ||
138 | void GetAutoUpdateEnableFlag(HLERequestContext& ctx); | ||
139 | void SetAutoUpdateEnableFlag(HLERequestContext& ctx); | ||
140 | void GetBatteryPercentageFlag(HLERequestContext& ctx); | ||
141 | void SetBatteryPercentageFlag(HLERequestContext& ctx); | ||
142 | void SetExternalSteadyClockInternalOffset(HLERequestContext& ctx); | ||
143 | void GetExternalSteadyClockInternalOffset(HLERequestContext& ctx); | ||
144 | void GetPushNotificationActivityModeOnSleep(HLERequestContext& ctx); | ||
145 | void SetPushNotificationActivityModeOnSleep(HLERequestContext& ctx); | ||
146 | void GetErrorReportSharePermission(HLERequestContext& ctx); | ||
147 | void SetErrorReportSharePermission(HLERequestContext& ctx); | ||
148 | void GetAppletLaunchFlags(HLERequestContext& ctx); | ||
149 | void SetAppletLaunchFlags(HLERequestContext& ctx); | ||
150 | void GetKeyboardLayout(HLERequestContext& ctx); | ||
151 | void SetKeyboardLayout(HLERequestContext& ctx); | ||
152 | void GetDeviceTimeZoneLocationUpdatedTime(HLERequestContext& ctx); | ||
153 | void SetDeviceTimeZoneLocationUpdatedTime(HLERequestContext& ctx); | ||
154 | void GetUserSystemClockAutomaticCorrectionUpdatedTime(HLERequestContext& ctx); | ||
155 | void SetUserSystemClockAutomaticCorrectionUpdatedTime(HLERequestContext& ctx); | ||
156 | void GetChineseTraditionalInputMethod(HLERequestContext& ctx); | ||
157 | void GetHomeMenuScheme(HLERequestContext& ctx); | ||
158 | void GetHomeMenuSchemeModel(HLERequestContext& ctx); | ||
159 | void GetTouchScreenMode(HLERequestContext& ctx); | ||
160 | void SetTouchScreenMode(HLERequestContext& ctx); | ||
161 | void GetFieldTestingFlag(HLERequestContext& ctx); | ||
162 | void GetPanelCrcMode(HLERequestContext& ctx); | ||
163 | void SetPanelCrcMode(HLERequestContext& ctx); | ||
164 | |||
165 | bool LoadSettingsFile(std::filesystem::path& path, auto&& default_func); | 161 | bool LoadSettingsFile(std::filesystem::path& path, auto&& default_func); |
166 | bool StoreSettingsFile(std::filesystem::path& path, auto& settings); | 162 | bool StoreSettingsFile(std::filesystem::path& path, auto& settings); |
167 | void SetupSettings(); | 163 | void SetupSettings(); |
diff --git a/src/hid_core/resources/hid_firmware_settings.cpp b/src/hid_core/resources/hid_firmware_settings.cpp index b32c0660a..c0a76d0eb 100755 --- a/src/hid_core/resources/hid_firmware_settings.cpp +++ b/src/hid_core/resources/hid_firmware_settings.cpp | |||
@@ -22,29 +22,30 @@ void HidFirmwareSettings::LoadSettings(bool reload_config) { | |||
22 | return; | 22 | return; |
23 | } | 23 | } |
24 | 24 | ||
25 | m_set_sys->GetSettingsItemValue<bool>(is_debug_pad_enabled, "hid_debug", "enables_debugpad"); | 25 | m_set_sys->GetSettingsItemValueImpl<bool>(is_debug_pad_enabled, "hid_debug", |
26 | m_set_sys->GetSettingsItemValue<bool>(is_device_managed, "hid_debug", "manages_devices"); | 26 | "enables_debugpad"); |
27 | m_set_sys->GetSettingsItemValue<bool>(is_touch_i2c_managed, "hid_debug", | 27 | m_set_sys->GetSettingsItemValueImpl<bool>(is_device_managed, "hid_debug", "manages_devices"); |
28 | "manages_touch_ic_i2c"); | 28 | m_set_sys->GetSettingsItemValueImpl<bool>(is_touch_i2c_managed, "hid_debug", |
29 | m_set_sys->GetSettingsItemValue<bool>(is_future_devices_emulated, "hid_debug", | 29 | "manages_touch_ic_i2c"); |
30 | "emulate_future_device"); | 30 | m_set_sys->GetSettingsItemValueImpl<bool>(is_future_devices_emulated, "hid_debug", |
31 | m_set_sys->GetSettingsItemValue<bool>(is_mcu_hardware_error_emulated, "hid_debug", | 31 | "emulate_future_device"); |
32 | "emulate_mcu_hardware_error"); | 32 | m_set_sys->GetSettingsItemValueImpl<bool>(is_mcu_hardware_error_emulated, "hid_debug", |
33 | m_set_sys->GetSettingsItemValue<bool>(is_rail_enabled, "hid_debug", "enables_rail"); | 33 | "emulate_mcu_hardware_error"); |
34 | m_set_sys->GetSettingsItemValue<bool>(is_firmware_update_failure_emulated, "hid_debug", | 34 | m_set_sys->GetSettingsItemValueImpl<bool>(is_rail_enabled, "hid_debug", "enables_rail"); |
35 | "emulate_firmware_update_failure"); | 35 | m_set_sys->GetSettingsItemValueImpl<bool>(is_firmware_update_failure_emulated, "hid_debug", |
36 | "emulate_firmware_update_failure"); | ||
36 | is_firmware_update_failure = {}; | 37 | is_firmware_update_failure = {}; |
37 | m_set_sys->GetSettingsItemValue<bool>(is_ble_disabled, "hid_debug", "ble_disabled"); | 38 | m_set_sys->GetSettingsItemValueImpl<bool>(is_ble_disabled, "hid_debug", "ble_disabled"); |
38 | m_set_sys->GetSettingsItemValue<bool>(is_dscale_disabled, "hid_debug", "dscale_disabled"); | 39 | m_set_sys->GetSettingsItemValueImpl<bool>(is_dscale_disabled, "hid_debug", "dscale_disabled"); |
39 | m_set_sys->GetSettingsItemValue<bool>(is_handheld_forced, "hid_debug", "force_handheld"); | 40 | m_set_sys->GetSettingsItemValueImpl<bool>(is_handheld_forced, "hid_debug", "force_handheld"); |
40 | features_per_id_disabled = {}; | 41 | features_per_id_disabled = {}; |
41 | m_set_sys->GetSettingsItemValue<bool>(is_touch_firmware_auto_update_disabled, "hid_debug", | 42 | m_set_sys->GetSettingsItemValueImpl<bool>(is_touch_firmware_auto_update_disabled, "hid_debug", |
42 | "touch_firmware_auto_update_disabled"); | 43 | "touch_firmware_auto_update_disabled"); |
43 | 44 | ||
44 | bool has_rail_interface{}; | 45 | bool has_rail_interface{}; |
45 | bool has_sio_mcu{}; | 46 | bool has_sio_mcu{}; |
46 | m_set_sys->GetSettingsItemValue<bool>(has_rail_interface, "hid", "has_rail_interface"); | 47 | m_set_sys->GetSettingsItemValueImpl<bool>(has_rail_interface, "hid", "has_rail_interface"); |
47 | m_set_sys->GetSettingsItemValue<bool>(has_sio_mcu, "hid", "has_sio_mcu"); | 48 | m_set_sys->GetSettingsItemValueImpl<bool>(has_sio_mcu, "hid", "has_sio_mcu"); |
48 | platform_config.has_rail_interface.Assign(has_rail_interface); | 49 | platform_config.has_rail_interface.Assign(has_rail_interface); |
49 | platform_config.has_sio_mcu.Assign(has_sio_mcu); | 50 | platform_config.has_sio_mcu.Assign(has_sio_mcu); |
50 | 51 | ||
diff --git a/src/hid_core/resources/npad/npad_vibration.cpp b/src/hid_core/resources/npad/npad_vibration.cpp index 02b1f0290..4c103889a 100755 --- a/src/hid_core/resources/npad/npad_vibration.cpp +++ b/src/hid_core/resources/npad/npad_vibration.cpp | |||
@@ -15,7 +15,7 @@ Result NpadVibration::Activate() { | |||
15 | std::scoped_lock lock{mutex}; | 15 | std::scoped_lock lock{mutex}; |
16 | 16 | ||
17 | f32 master_volume = 1.0f; | 17 | f32 master_volume = 1.0f; |
18 | m_set_sys->GetVibrationMasterVolume(master_volume); | 18 | m_set_sys->GetVibrationMasterVolume(&master_volume); |
19 | if (master_volume < 0.0f || master_volume > 1.0f) { | 19 | if (master_volume < 0.0f || master_volume > 1.0f) { |
20 | return ResultVibrationStrengthOutOfRange; | 20 | return ResultVibrationStrengthOutOfRange; |
21 | } | 21 | } |
@@ -57,7 +57,7 @@ Result NpadVibration::GetVibrationMasterVolume(f32& out_volume) const { | |||
57 | std::scoped_lock lock{mutex}; | 57 | std::scoped_lock lock{mutex}; |
58 | 58 | ||
59 | f32 master_volume = 1.0f; | 59 | f32 master_volume = 1.0f; |
60 | m_set_sys->GetVibrationMasterVolume(master_volume); | 60 | m_set_sys->GetVibrationMasterVolume(&master_volume); |
61 | if (master_volume < 0.0f || master_volume > 1.0f) { | 61 | if (master_volume < 0.0f || master_volume > 1.0f) { |
62 | return ResultVibrationStrengthOutOfRange; | 62 | return ResultVibrationStrengthOutOfRange; |
63 | } | 63 | } |
@@ -77,7 +77,7 @@ Result NpadVibration::EndPermitVibrationSession() { | |||
77 | std::scoped_lock lock{mutex}; | 77 | std::scoped_lock lock{mutex}; |
78 | 78 | ||
79 | f32 master_volume = 1.0f; | 79 | f32 master_volume = 1.0f; |
80 | m_set_sys->GetVibrationMasterVolume(master_volume); | 80 | m_set_sys->GetVibrationMasterVolume(&master_volume); |
81 | if (master_volume < 0.0f || master_volume > 1.0f) { | 81 | if (master_volume < 0.0f || master_volume > 1.0f) { |
82 | return ResultVibrationStrengthOutOfRange; | 82 | return ResultVibrationStrengthOutOfRange; |
83 | } | 83 | } |
diff --git a/src/hid_core/resources/touch_screen/touch_screen_resource.cpp b/src/hid_core/resources/touch_screen/touch_screen_resource.cpp index c39321915..79ddaa4df 100755 --- a/src/hid_core/resources/touch_screen/touch_screen_resource.cpp +++ b/src/hid_core/resources/touch_screen/touch_screen_resource.cpp | |||
@@ -48,7 +48,7 @@ Result TouchResource::ActivateTouch() { | |||
48 | } | 48 | } |
49 | 49 | ||
50 | Set::TouchScreenMode touch_mode{Set::TouchScreenMode::Standard}; | 50 | Set::TouchScreenMode touch_mode{Set::TouchScreenMode::Standard}; |
51 | m_set_sys->GetTouchScreenMode(touch_mode); | 51 | m_set_sys->GetTouchScreenMode(&touch_mode); |
52 | default_touch_screen_mode = static_cast<Core::HID::TouchScreenModeForNx>(touch_mode); | 52 | default_touch_screen_mode = static_cast<Core::HID::TouchScreenModeForNx>(touch_mode); |
53 | 53 | ||
54 | global_ref_counter++; | 54 | global_ref_counter++; |