Android #15

.ci/templates/build-msvc.yml

@@ -12,7 +12,7 @@ steps:
   inputs:
     targetType: 'filePath'
     filePath: './.ci/scripts/windows/install-vulkan-sdk.ps1'
-- script: refreshenv && glslangValidator --version && mkdir build && cd build && cmake -E env CXXFLAGS="/Gw" cmake -G "Visual Studio 17 2022" -A x64 -DCMAKE_POLICY_DEFAULT_CMP0069=NEW -DYUZU_ENABLE_LTO=ON -DYUZU_USE_BUNDLED_QT=1 -DYUZU_USE_BUNDLED_SDL2=1 -DYUZU_USE_QT_WEB_ENGINE=ON -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${COMPAT} -DYUZU_TESTS=OFF -DUSE_DISCORD_PRESENCE=ON -DENABLE_QT_TRANSLATION=ON -DDISPLAY_VERSION=${{ parameters['version'] }} -DCMAKE_BUILD_TYPE=Release -DYUZU_CRASH_DUMPS=ON .. && cd ..
+- script: refreshenv && glslangValidator --version && mkdir build && cd build && cmake -E env CXXFLAGS="/Gw /GA /Gr /Ob2" cmake -G "Visual Studio 17 2022" -A x64 -DCMAKE_POLICY_DEFAULT_CMP0069=NEW -DYUZU_ENABLE_LTO=ON -DYUZU_USE_BUNDLED_QT=1 -DYUZU_USE_BUNDLED_SDL2=1 -DYUZU_USE_QT_WEB_ENGINE=ON -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${COMPAT} -DYUZU_TESTS=OFF -DUSE_DISCORD_PRESENCE=ON -DENABLE_QT_TRANSLATION=ON -DDISPLAY_VERSION=${{ parameters['version'] }} -DCMAKE_BUILD_TYPE=Release -DYUZU_CRASH_DUMPS=ON .. && cd ..
   displayName: 'Configure CMake'
 - task: MSBuild@1
   displayName: 'Build'

src/common/settings.cpp

@@ -26,8 +26,7 @@ std::string GetTimeZoneString() {
 
     std::string location_name;
     if (time_zone_index == 0) { // Auto
-#if __cpp_lib_chrono >= 201907L && !defined(MINGW)
-        // Disabled for MinGW -- tzdb always returns Etc/UTC
+#if __cpp_lib_chrono >= 201907L
         try {
             const struct std::chrono::tzdb& time_zone_data = std::chrono::get_tzdb();
             const std::chrono::time_zone* current_zone = time_zone_data.current_zone();

src/common/time_zone.cpp

@@ -4,13 +4,13 @@
 #include <chrono>
 #include <exception>
 #include <iomanip>
-#include <map>
 #include <sstream>
 #include <stdexcept>
 #include <fmt/chrono.h>
 #include <fmt/core.h>
 
 #include "common/logging/log.h"
+#include "common/settings.h"
 #include "common/time_zone.h"
 
 namespace Common::TimeZone {
@@ -33,29 +33,32 @@ std::string GetDefaultTimeZone() {
     return "GMT";
 }
 
-// Results are not comparable to seconds since Epoch
-static std::time_t TmSpecToSeconds(const struct std::tm& spec) {
-    const int year = spec.tm_year - 1; // Years up to now
-    const int leap_years = year / 4 - year / 100;
-    std::time_t cumulative = spec.tm_year;
-    cumulative = cumulative * 365 + leap_years + spec.tm_yday; // Years to days
-    cumulative = cumulative * 24 + spec.tm_hour;               // Days to hours
-    cumulative = cumulative * 60 + spec.tm_min;                // Hours to minutes
-    cumulative = cumulative * 60 + spec.tm_sec;                // Minutes to seconds
-    return cumulative;
+static std::string GetOsTimeZoneOffset() {
+    const std::time_t t{std::time(nullptr)};
+    const std::tm tm{*std::localtime(&t)};
+
+    return fmt::format("{:%z}", tm);
+}
+
+static int ConvertOsTimeZoneOffsetToInt(const std::string& timezone) {
+    try {
+        return std::stoi(timezone);
+    } catch (const std::invalid_argument&) {
+        LOG_CRITICAL(Common, "invalid_argument with {}!", timezone);
+        return 0;
+    } catch (const std::out_of_range&) {
+        LOG_CRITICAL(Common, "out_of_range with {}!", timezone);
+        return 0;
+    }
 }
 
 std::chrono::seconds GetCurrentOffsetSeconds() {
-    const std::time_t t{std::time(nullptr)};
-    const std::tm local{*std::localtime(&t)};
-    const std::tm gmt{*std::gmtime(&t)};
+    const int offset{ConvertOsTimeZoneOffsetToInt(GetOsTimeZoneOffset())};
 
-    // gmt_seconds is a different offset than time(nullptr)
-    const auto gmt_seconds = TmSpecToSeconds(gmt);
-    const auto local_seconds = TmSpecToSeconds(local);
-    const auto seconds_offset = local_seconds - gmt_seconds;
+    int seconds{(offset / 100) * 60 * 60}; // Convert hour component to seconds
+    seconds += (offset % 100) * 60;        // Convert minute component to seconds
 
-    return std::chrono::seconds{seconds_offset};
+    return std::chrono::seconds{seconds};
 }
 
 // Key is [Hours * 100 + Minutes], multiplied by 100 if DST
@@ -68,6 +71,11 @@ const static std::map<s64, const char*> off_timezones = {
 };
 
 std::string FindSystemTimeZone() {
+#if defined(MINGW)
+    // MinGW has broken strftime -- https://sourceforge.net/p/mingw-w64/bugs/793/
+    // e.g. fmt::format("{:%z}") -- returns "Eastern Daylight Time" when it should be "-0400"
+    return timezones[0];
+#else
     const s64 seconds = static_cast<s64>(GetCurrentOffsetSeconds().count());
 
     const s64 minutes = seconds / 60;
@@ -89,6 +97,7 @@ std::string FindSystemTimeZone() {
         }
     }
     return fmt::format("Etc/GMT{:s}{:d}", hours > 0 ? "-" : "+", std::abs(hours));
+#endif
 }
 
 } // namespace Common::TimeZone

src/core/hle/service/nfc/common/amiibo_crypto.cpp

@@ -180,7 +180,7 @@ std::vector<u8> GenerateInternalKey(const InternalKey& key, const HashSeed& seed
 }
 
 void CryptoInit(CryptoCtx& ctx, mbedtls_md_context_t& hmac_ctx, const HmacKey& hmac_key,
-                std::span<const u8> seed) {
+                const std::vector<u8>& seed) {
     // Initialize context
     ctx.used = false;
     ctx.counter = 0;

src/core/hle/service/nfc/common/amiibo_crypto.h

@@ -75,7 +75,7 @@ std::vector<u8> GenerateInternalKey(const InternalKey& key, const HashSeed& seed
 
 // Initializes mbedtls context
 void CryptoInit(CryptoCtx& ctx, mbedtls_md_context_t& hmac_ctx, const HmacKey& hmac_key,
-                std::span<const u8> seed);
+                const std::vector<u8>& seed);
 
 // Feeds data to mbedtls context to generate the derived key
 void CryptoStep(CryptoCtx& ctx, mbedtls_md_context_t& hmac_ctx, DrgbOutput& output);

src/core/hle/service/nfc/common/device.cpp

@@ -34,6 +34,8 @@
 #include "core/hle/service/nfc/mifare_result.h"
 #include "core/hle/service/nfc/nfc_result.h"
 #include "core/hle/service/time/time_manager.h"
+#include "core/hle/service/time/time_zone_content_manager.h"
+#include "core/hle/service/time/time_zone_types.h"
 
 namespace Service::NFC {
 NfcDevice::NfcDevice(Core::HID::NpadIdType npad_id_, Core::System& system_,
@@ -1484,7 +1486,6 @@ DeviceState NfcDevice::GetCurrentState() const {
 }
 
 Result NfcDevice::GetNpadId(Core::HID::NpadIdType& out_npad_id) const {
-    // TODO: This should get the npad id from nn::hid::system::GetXcdHandleForNpadWithNfc
     out_npad_id = npad_id;
     return ResultSuccess;
 }

src/core/hle/service/nfc/common/device_manager.cpp

@@ -1,8 +1,6 @@
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
-#include <algorithm>
-
 #include "common/logging/log.h"
 #include "core/core.h"
 #include "core/hid/hid_types.h"
@@ -12,7 +10,6 @@
 #include "core/hle/service/nfc/common/device_manager.h"
 #include "core/hle/service/nfc/nfc_result.h"
 #include "core/hle/service/time/clock_types.h"
-#include "core/hle/service/time/time_manager.h"
 
 namespace Service::NFC {
 
@@ -54,53 +51,22 @@ Result DeviceManager::Finalize() {
     return ResultSuccess;
 }
 
-Result DeviceManager::ListDevices(std::vector<u64>& nfp_devices, std::size_t max_allowed_devices,
-                                  bool skip_fatal_errors) const {
-    std::scoped_lock lock{mutex};
-    if (max_allowed_devices < 1) {
-        return ResultInvalidArgument;
-    }
-
-    Result result = IsNfcParameterSet();
-    if (result.IsError()) {
-        return result;
-    }
-
-    result = IsNfcEnabled();
-    if (result.IsError()) {
-        return result;
-    }
-
-    result = IsNfcInitialized();
-    if (result.IsError()) {
-        return result;
-    }
-
+Result DeviceManager::ListDevices(std::vector<u64>& nfp_devices,
+                                  std::size_t max_allowed_devices) const {
     for (auto& device : devices) {
         if (nfp_devices.size() >= max_allowed_devices) {
             continue;
         }
-        if (skip_fatal_errors) {
-            constexpr u64 MinimumRecoveryTime = 60;
-            auto& standard_steady_clock{system.GetTimeManager().GetStandardSteadyClockCore()};
-            const u64 elapsed_time = standard_steady_clock.GetCurrentTimePoint(system).time_point -
-                                     time_since_last_error;
-
-            if (time_since_last_error != 0 && elapsed_time < MinimumRecoveryTime) {
-                continue;
-            }
+        if (device->GetCurrentState() != DeviceState::Unavailable) {
+            nfp_devices.push_back(device->GetHandle());
         }
-        if (device->GetCurrentState() == DeviceState::Unavailable) {
-            continue;
-        }
-        nfp_devices.push_back(device->GetHandle());
     }
 
     if (nfp_devices.empty()) {
         return ResultDeviceNotFound;
     }
 
-    return result;
+    return ResultSuccess;
 }
 
 DeviceState DeviceManager::GetDeviceState(u64 device_handle) const {
@@ -113,10 +79,10 @@ DeviceState DeviceManager::GetDeviceState(u64 device_handle) const {
         return device->GetCurrentState();
     }
 
-    return DeviceState::Finalized;
+    return DeviceState::Unavailable;
 }
 
-Result DeviceManager::GetNpadId(u64 device_handle, Core::HID::NpadIdType& npad_id) {
+Result DeviceManager::GetNpadId(u64 device_handle, Core::HID::NpadIdType& npad_id) const {
     std::scoped_lock lock{mutex};
 
     std::shared_ptr<NfcDevice> device = nullptr;
@@ -162,7 +128,7 @@ Result DeviceManager::StopDetection(u64 device_handle) {
     return result;
 }
 
-Result DeviceManager::GetTagInfo(u64 device_handle, TagInfo& tag_info) {
+Result DeviceManager::GetTagInfo(u64 device_handle, TagInfo& tag_info) const {
     std::scoped_lock lock{mutex};
 
     std::shared_ptr<NfcDevice> device = nullptr;
@@ -176,46 +142,24 @@ Result DeviceManager::GetTagInfo(u64 device_handle, TagInfo& tag_info) {
     return result;
 }
 
-Result DeviceManager::AttachActivateEvent(Kernel::KReadableEvent** out_event,
-                                          u64 device_handle) const {
-    std::vector<u64> nfp_devices;
+Kernel::KReadableEvent& DeviceManager::AttachActivateEvent(u64 device_handle) const {
+    std::scoped_lock lock{mutex};
+
     std::shared_ptr<NfcDevice> device = nullptr;
-    Result result = ListDevices(nfp_devices, 9, false);
+    GetDeviceFromHandle(device_handle, device, false);
 
-    if (result.IsSuccess()) {
-        result = CheckHandleOnList(device_handle, nfp_devices);
-    }
-
-    if (result.IsSuccess()) {
-        result = GetDeviceFromHandle(device_handle, device, false);
-    }
-
-    if (result.IsSuccess()) {
-        *out_event = &device->GetActivateEvent();
-    }
-
-    return result;
+    // TODO: Return proper error code on failure
+    return device->GetActivateEvent();
 }
 
-Result DeviceManager::AttachDeactivateEvent(Kernel::KReadableEvent** out_event,
-                                            u64 device_handle) const {
-    std::vector<u64> nfp_devices;
+Kernel::KReadableEvent& DeviceManager::AttachDeactivateEvent(u64 device_handle) const {
+    std::scoped_lock lock{mutex};
+
     std::shared_ptr<NfcDevice> device = nullptr;
-    Result result = ListDevices(nfp_devices, 9, false);
+    GetDeviceFromHandle(device_handle, device, false);
 
-    if (result.IsSuccess()) {
-        result = CheckHandleOnList(device_handle, nfp_devices);
-    }
-
-    if (result.IsSuccess()) {
-        result = GetDeviceFromHandle(device_handle, device, false);
-    }
-
-    if (result.IsSuccess()) {
-        *out_event = &device->GetDeactivateEvent();
-    }
-
-    return result;
+    // TODO: Return proper error code on failure
+    return device->GetDeactivateEvent();
 }
 
 Result DeviceManager::ReadMifare(u64 device_handle,
@@ -309,7 +253,7 @@ Result DeviceManager::OpenApplicationArea(u64 device_handle, u32 access_id) {
     return result;
 }
 
-Result DeviceManager::GetApplicationArea(u64 device_handle, std::span<u8> data) {
+Result DeviceManager::GetApplicationArea(u64 device_handle, std::span<u8> data) const {
     std::scoped_lock lock{mutex};
 
     std::shared_ptr<NfcDevice> device = nullptr;
@@ -380,7 +324,7 @@ Result DeviceManager::CreateApplicationArea(u64 device_handle, u32 access_id,
     return result;
 }
 
-Result DeviceManager::GetRegisterInfo(u64 device_handle, NFP::RegisterInfo& register_info) {
+Result DeviceManager::GetRegisterInfo(u64 device_handle, NFP::RegisterInfo& register_info) const {
     std::scoped_lock lock{mutex};
 
     std::shared_ptr<NfcDevice> device = nullptr;
@@ -394,7 +338,7 @@ Result DeviceManager::GetRegisterInfo(u64 device_handle, NFP::RegisterInfo& regi
     return result;
 }
 
-Result DeviceManager::GetCommonInfo(u64 device_handle, NFP::CommonInfo& common_info) {
+Result DeviceManager::GetCommonInfo(u64 device_handle, NFP::CommonInfo& common_info) const {
     std::scoped_lock lock{mutex};
 
     std::shared_ptr<NfcDevice> device = nullptr;
@@ -408,7 +352,7 @@ Result DeviceManager::GetCommonInfo(u64 device_handle, NFP::CommonInfo& common_i
     return result;
 }
 
-Result DeviceManager::GetModelInfo(u64 device_handle, NFP::ModelInfo& model_info) {
+Result DeviceManager::GetModelInfo(u64 device_handle, NFP::ModelInfo& model_info) const {
     std::scoped_lock lock{mutex};
 
     std::shared_ptr<NfcDevice> device = nullptr;
@@ -455,7 +399,7 @@ Result DeviceManager::Format(u64 device_handle) {
     return result;
 }
 
-Result DeviceManager::GetAdminInfo(u64 device_handle, NFP::AdminInfo& admin_info) {
+Result DeviceManager::GetAdminInfo(u64 device_handle, NFP::AdminInfo& admin_info) const {
     std::scoped_lock lock{mutex};
 
     std::shared_ptr<NfcDevice> device = nullptr;
@@ -470,7 +414,7 @@ Result DeviceManager::GetAdminInfo(u64 device_handle, NFP::AdminInfo& admin_info
 }
 
 Result DeviceManager::GetRegisterInfoPrivate(u64 device_handle,
-                                             NFP::RegisterInfoPrivate& register_info) {
+                                             NFP::RegisterInfoPrivate& register_info) const {
     std::scoped_lock lock{mutex};
 
     std::shared_ptr<NfcDevice> device = nullptr;
@@ -527,7 +471,7 @@ Result DeviceManager::DeleteApplicationArea(u64 device_handle) {
     return result;
 }
 
-Result DeviceManager::ExistsApplicationArea(u64 device_handle, bool& has_application_area) {
+Result DeviceManager::ExistsApplicationArea(u64 device_handle, bool& has_application_area) const {
     std::scoped_lock lock{mutex};
 
     std::shared_ptr<NfcDevice> device = nullptr;
@@ -541,7 +485,7 @@ Result DeviceManager::ExistsApplicationArea(u64 device_handle, bool& has_applica
     return result;
 }
 
-Result DeviceManager::GetAll(u64 device_handle, NFP::NfpData& nfp_data) {
+Result DeviceManager::GetAll(u64 device_handle, NFP::NfpData& nfp_data) const {
     std::scoped_lock lock{mutex};
 
     std::shared_ptr<NfcDevice> device = nullptr;
@@ -597,7 +541,7 @@ Result DeviceManager::BreakTag(u64 device_handle, NFP::BreakType break_type) {
     return result;
 }
 
-Result DeviceManager::ReadBackupData(u64 device_handle, std::span<u8> data) {
+Result DeviceManager::ReadBackupData(u64 device_handle, std::span<u8> data) const {
     std::scoped_lock lock{mutex};
 
     std::shared_ptr<NfcDevice> device = nullptr;
@@ -649,19 +593,6 @@ Result DeviceManager::WriteNtf(u64 device_handle, NFP::WriteType, std::span<cons
     return result;
 }
 
-Result DeviceManager::CheckHandleOnList(u64 device_handle,
-                                        const std::span<const u64> device_list) const {
-    if (device_list.size() < 1) {
-        return ResultDeviceNotFound;
-    }
-
-    if (std::find(device_list.begin(), device_list.end(), device_handle) != device_list.end()) {
-        return ResultSuccess;
-    }
-
-    return ResultDeviceNotFound;
-}
-
 Result DeviceManager::GetDeviceFromHandle(u64 handle, std::shared_ptr<NfcDevice>& nfc_device,
                                           bool check_state) const {
     if (check_state) {
@@ -716,7 +647,7 @@ Result DeviceManager::GetDeviceHandle(u64 handle, std::shared_ptr<NfcDevice>& de
 }
 
 Result DeviceManager::VerifyDeviceResult(std::shared_ptr<NfcDevice> device,
-                                         Result operation_result) {
+                                         Result operation_result) const {
     if (operation_result.IsSuccess()) {
         return operation_result;
     }
@@ -738,12 +669,6 @@ Result DeviceManager::VerifyDeviceResult(std::shared_ptr<NfcDevice> device,
         return device_state;
     }
 
-    if (operation_result == ResultUnknown112 || operation_result == ResultUnknown114 ||
-        operation_result == ResultUnknown115) {
-        auto& standard_steady_clock{system.GetTimeManager().GetStandardSteadyClockCore()};
-        time_since_last_error = standard_steady_clock.GetCurrentTimePoint(system).time_point;
-    }
-
     return operation_result;
 }
 

src/core/hle/service/nfc/common/device_manager.h

@@ -27,16 +27,15 @@ public:
     // Nfc device manager
     Result Initialize();
     Result Finalize();
-    Result ListDevices(std::vector<u64>& nfp_devices, std::size_t max_allowed_devices,
-                       bool skip_fatal_errors) const;
+    Result ListDevices(std::vector<u64>& nfp_devices, std::size_t max_allowed_devices) const;
     DeviceState GetDeviceState(u64 device_handle) const;
-    Result GetNpadId(u64 device_handle, Core::HID::NpadIdType& npad_id);
+    Result GetNpadId(u64 device_handle, Core::HID::NpadIdType& npad_id) const;
     Kernel::KReadableEvent& AttachAvailabilityChangeEvent() const;
     Result StartDetection(u64 device_handle, NfcProtocol tag_protocol);
     Result StopDetection(u64 device_handle);
-    Result GetTagInfo(u64 device_handle, NFP::TagInfo& tag_info);
-    Result AttachActivateEvent(Kernel::KReadableEvent** event, u64 device_handle) const;
-    Result AttachDeactivateEvent(Kernel::KReadableEvent** event, u64 device_handle) const;
+    Result GetTagInfo(u64 device_handle, NFP::TagInfo& tag_info) const;
+    Kernel::KReadableEvent& AttachActivateEvent(u64 device_handle) const;
+    Kernel::KReadableEvent& AttachDeactivateEvent(u64 device_handle) const;
     Result ReadMifare(u64 device_handle,
                       const std::span<const MifareReadBlockParameter> read_parameters,
                       std::span<MifareReadBlockData> read_data);
@@ -49,28 +48,28 @@ public:
     Result Mount(u64 device_handle, NFP::ModelType model_type, NFP::MountTarget mount_target);
     Result Unmount(u64 device_handle);
     Result OpenApplicationArea(u64 device_handle, u32 access_id);
-    Result GetApplicationArea(u64 device_handle, std::span<u8> data);
+    Result GetApplicationArea(u64 device_handle, std::span<u8> data) const;
     Result SetApplicationArea(u64 device_handle, std::span<const u8> data);
     Result Flush(u64 device_handle);
     Result Restore(u64 device_handle);
     Result CreateApplicationArea(u64 device_handle, u32 access_id, std::span<const u8> data);
-    Result GetRegisterInfo(u64 device_handle, NFP::RegisterInfo& register_info);
-    Result GetCommonInfo(u64 device_handle, NFP::CommonInfo& common_info);
-    Result GetModelInfo(u64 device_handle, NFP::ModelInfo& model_info);
+    Result GetRegisterInfo(u64 device_handle, NFP::RegisterInfo& register_info) const;
+    Result GetCommonInfo(u64 device_handle, NFP::CommonInfo& common_info) const;
+    Result GetModelInfo(u64 device_handle, NFP::ModelInfo& model_info) const;
     u32 GetApplicationAreaSize() const;
     Result RecreateApplicationArea(u64 device_handle, u32 access_id, std::span<const u8> data);
     Result Format(u64 device_handle);
-    Result GetAdminInfo(u64 device_handle, NFP::AdminInfo& admin_info);
-    Result GetRegisterInfoPrivate(u64 device_handle, NFP::RegisterInfoPrivate& register_info);
+    Result GetAdminInfo(u64 device_handle, NFP::AdminInfo& admin_info) const;
+    Result GetRegisterInfoPrivate(u64 device_handle, NFP::RegisterInfoPrivate& register_info) const;
     Result SetRegisterInfoPrivate(u64 device_handle, const NFP::RegisterInfoPrivate& register_info);
     Result DeleteRegisterInfo(u64 device_handle);
     Result DeleteApplicationArea(u64 device_handle);
-    Result ExistsApplicationArea(u64 device_handle, bool& has_application_area);
-    Result GetAll(u64 device_handle, NFP::NfpData& nfp_data);
+    Result ExistsApplicationArea(u64 device_handle, bool& has_application_area) const;
+    Result GetAll(u64 device_handle, NFP::NfpData& nfp_data) const;
     Result SetAll(u64 device_handle, const NFP::NfpData& nfp_data);
     Result FlushDebug(u64 device_handle);
     Result BreakTag(u64 device_handle, NFP::BreakType break_type);
-    Result ReadBackupData(u64 device_handle, std::span<u8> data);
+    Result ReadBackupData(u64 device_handle, std::span<u8> data) const;
     Result WriteBackupData(u64 device_handle, std::span<const u8> data);
     Result WriteNtf(u64 device_handle, NFP::WriteType, std::span<const u8> data);
 
@@ -79,20 +78,17 @@ private:
     Result IsNfcParameterSet() const;
     Result IsNfcInitialized() const;
 
-    Result CheckHandleOnList(u64 device_handle, std::span<const u64> device_list) const;
-
     Result GetDeviceFromHandle(u64 handle, std::shared_ptr<NfcDevice>& device,
                                bool check_state) const;
 
     Result GetDeviceHandle(u64 handle, std::shared_ptr<NfcDevice>& device) const;
-    Result VerifyDeviceResult(std::shared_ptr<NfcDevice> device, Result operation_result);
+    Result VerifyDeviceResult(std::shared_ptr<NfcDevice> device, Result operation_result) const;
     Result CheckDeviceState(std::shared_ptr<NfcDevice> device) const;
 
     std::optional<std::shared_ptr<NfcDevice>> GetNfcDevice(u64 handle);
     const std::optional<std::shared_ptr<NfcDevice>> GetNfcDevice(u64 handle) const;
 
     bool is_initialized = false;
-    u64 time_since_last_error = 0;
     mutable std::mutex mutex;
     std::array<std::shared_ptr<NfcDevice>, 10> devices{};
 

src/core/hle/service/nfc/nfc_interface.cpp

@@ -79,7 +79,7 @@ void NfcInterface::ListDevices(HLERequestContext& ctx) {
     const std::size_t max_allowed_devices = ctx.GetWriteBufferNumElements<u64>();
     LOG_DEBUG(Service_NFC, "called");
 
-    auto result = GetManager()->ListDevices(nfp_devices, max_allowed_devices, true);
+    auto result = GetManager()->ListDevices(nfp_devices, max_allowed_devices);
     result = TranslateResultToServiceError(result);
 
     if (result.IsError()) {
@@ -190,13 +190,9 @@ void NfcInterface::AttachActivateEvent(HLERequestContext& ctx) {
     const auto device_handle{rp.Pop<u64>()};
     LOG_DEBUG(Service_NFC, "called, device_handle={}", device_handle);
 
-    Kernel::KReadableEvent* out_event = nullptr;
-    auto result = GetManager()->AttachActivateEvent(&out_event, device_handle);
-    result = TranslateResultToServiceError(result);
-
     IPC::ResponseBuilder rb{ctx, 2, 1};
-    rb.Push(result);
-    rb.PushCopyObjects(out_event);
+    rb.Push(ResultSuccess);
+    rb.PushCopyObjects(GetManager()->AttachActivateEvent(device_handle));
 }
 
 void NfcInterface::AttachDeactivateEvent(HLERequestContext& ctx) {
@@ -204,13 +200,9 @@ void NfcInterface::AttachDeactivateEvent(HLERequestContext& ctx) {
     const auto device_handle{rp.Pop<u64>()};
     LOG_DEBUG(Service_NFC, "called, device_handle={}", device_handle);
 
-    Kernel::KReadableEvent* out_event = nullptr;
-    auto result = GetManager()->AttachDeactivateEvent(&out_event, device_handle);
-    result = TranslateResultToServiceError(result);
-
     IPC::ResponseBuilder rb{ctx, 2, 1};
-    rb.Push(result);
-    rb.PushCopyObjects(out_event);
+    rb.Push(ResultSuccess);
+    rb.PushCopyObjects(GetManager()->AttachDeactivateEvent(device_handle));
 }
 
 void NfcInterface::ReadMifare(HLERequestContext& ctx) {

src/core/hle/service/nfc/nfc_result.h

@@ -17,10 +17,7 @@ constexpr Result ResultNfcNotInitialized(ErrorModule::NFC, 77);
 constexpr Result ResultNfcDisabled(ErrorModule::NFC, 80);
 constexpr Result ResultWriteAmiiboFailed(ErrorModule::NFC, 88);
 constexpr Result ResultTagRemoved(ErrorModule::NFC, 97);
-constexpr Result ResultUnknown112(ErrorModule::NFC, 112);
 constexpr Result ResultUnableToAccessBackupFile(ErrorModule::NFC, 113);
-constexpr Result ResultUnknown114(ErrorModule::NFC, 114);
-constexpr Result ResultUnknown115(ErrorModule::NFC, 115);
 constexpr Result ResultRegistrationIsNotInitialized(ErrorModule::NFC, 120);
 constexpr Result ResultApplicationAreaIsNotInitialized(ErrorModule::NFC, 128);
 constexpr Result ResultCorruptedDataWithBackup(ErrorModule::NFC, 136);