service: nfp: address comments

src/common/input.h

@@ -332,7 +332,7 @@ public:
         return CameraError::NotSupported;
     }
 
-    virtual NfcState SupportsNfc() {
+    virtual NfcState SupportsNfc() const {
         return NfcState::NotSupported;
     }
 

src/core/hid/input_converter.cpp

@@ -291,7 +291,7 @@ Common::Input::NfcStatus TransformToNfc(const Common::Input::CallbackStatus& cal
     Common::Input::NfcStatus nfc{};
     switch (callback.type) {
     case Common::Input::InputType::Nfc:
-        nfc = callback.nfc_status;
+        return callback.nfc_status;
         break;
     default:
         LOG_ERROR(Input, "Conversion from type {} to NFC not implemented", callback.type);

src/core/hle/service/nfp/nfp_device.cpp

@@ -42,10 +42,11 @@ NfpDevice::NfpDevice(Core::HID::NpadIdType npad_id_, Core::System& system_,
 }
 
 NfpDevice::~NfpDevice() {
-    if (is_controller_set) {
+    if (!is_controller_set) {
-        npad_device->DeleteCallback(callback_key);
+        return;
-        is_controller_set = false;
     }
+    npad_device->DeleteCallback(callback_key);
+    is_controller_set = false;
 };
 
 void NfpDevice::NpadUpdate(Core::HID::ControllerTriggerType type) {
@@ -453,7 +454,7 @@ Result NfpDevice::SetApplicationArea(const std::vector<u8>& data) {
     return ResultSuccess;
 }
 
-Result NfpDevice::CreateApplicationArea(u32 access_id, const std::vector<u8>& data) {
+Result NfpDevice::CreateApplicationArea(u32 access_id, std::span<const u8> data) {
     if (device_state != DeviceState::TagMounted) {
         LOG_ERROR(Service_NFP, "Wrong device state {}", device_state);
         if (device_state == DeviceState::TagRemoved) {
@@ -470,7 +471,7 @@ Result NfpDevice::CreateApplicationArea(u32 access_id, const std::vector<u8>& da
     return RecreateApplicationArea(access_id, data);
 }
 
-Result NfpDevice::RecreateApplicationArea(u32 access_id, const std::vector<u8>& data) {
+Result NfpDevice::RecreateApplicationArea(u32 access_id, std::span<const u8> data) {
     if (device_state != DeviceState::TagMounted) {
         LOG_ERROR(Service_NFP, "Wrong device state {}", device_state);
         if (device_state == DeviceState::TagRemoved) {

src/core/hle/service/nfp/nfp_device.h

@@ -56,8 +56,8 @@ public:
     Result OpenApplicationArea(u32 access_id);
     Result GetApplicationArea(std::vector<u8>& data) const;
     Result SetApplicationArea(const std::vector<u8>& data);
-    Result CreateApplicationArea(u32 access_id, const std::vector<u8>& data);
+    Result CreateApplicationArea(u32 access_id, std::span<const u8> data);
-    Result RecreateApplicationArea(u32 access_id, const std::vector<u8>& data);
+    Result RecreateApplicationArea(u32 access_id, std::span<const u8> data);
     Result DeleteApplicationArea();
 
     u64 GetHandle() const;

src/core/hle/service/nfp/nfp_types.h

@@ -5,6 +5,7 @@
 
 #include <array>
 
+#include "common/swap.h"
 #include "core/hle/service/mii/types.h"
 
 namespace Service::NFP {
@@ -80,33 +81,33 @@ using ApplicationArea = std::array<u8, 0xD8>;
 using AmiiboName = std::array<char, (amiibo_name_length * 4) + 1>;
 
 struct AmiiboDate {
-    u16_be raw_date{};
+    u16 raw_date{};
 
-    u16 DateRaw() const {
+    u16 GetValue() const {
-        return static_cast<u16>(raw_date);
+        return Common::swap16(raw_date);
     }
 
     u16 GetYear() const {
-        return static_cast<u16>(((DateRaw() & 0xFE00) >> 9) + 2000);
+        return static_cast<u16>(((GetValue() & 0xFE00) >> 9) + 2000);
     }
     u8 GetMonth() const {
-        return static_cast<u8>(((DateRaw() & 0x01E0) >> 5) - 1);
+        return static_cast<u8>(((GetValue() & 0x01E0) >> 5) - 1);
     }
     u8 GetDay() const {
-        return static_cast<u8>(DateRaw() & 0x001F);
+        return static_cast<u8>(GetValue() & 0x001F);
     }
 
     void SetYear(u16 year) {
-        raw_date = DateRaw() & ~0xFE00;
+        const u16 year_converted = static_cast<u16>((year - 2000) << 9);
-        raw_date |= static_cast<u16_be>((year - 2000) << 9);
+        raw_date = Common::swap16((GetValue() & ~0xFE00) | year_converted);
     }
     void SetMonth(u8 month) {
-        raw_date = DateRaw() & ~0x01E0;
+        const u16 month_converted = static_cast<u16>((month + 1) << 5);
-        raw_date |= static_cast<u16_be>((month + 1) << 5);
+        raw_date = Common::swap16((GetValue() & ~0x01E0) | month_converted);
     }
     void SetDay(u8 day) {
-        raw_date = DateRaw() & ~0x001F;
+        const u16 day_converted = static_cast<u16>(day);
-        raw_date |= static_cast<u16_be>(day);
+        raw_date = Common::swap16((GetValue() & ~0x001F) | day_converted);
     }
 };
 static_assert(sizeof(AmiiboDate) == 2, "AmiiboDate is an invalid size");

src/input_common/drivers/virtual_amiibo.cpp

@@ -20,7 +20,7 @@ constexpr PadIdentifier identifier = {
 
 VirtualAmiibo::VirtualAmiibo(std::string input_engine_) : InputEngine(std::move(input_engine_)) {}
 
-VirtualAmiibo::~VirtualAmiibo() {}
+VirtualAmiibo::~VirtualAmiibo() = default;
 
 Common::Input::PollingError VirtualAmiibo::SetPollingMode(
     [[maybe_unused]] const PadIdentifier& identifier_,
@@ -41,7 +41,7 @@ Common::Input::PollingError VirtualAmiibo::SetPollingMode(
 }
 
 Common::Input::NfcState VirtualAmiibo::SupportsNfc(
-    [[maybe_unused]] const PadIdentifier& identifier_) {
+    [[maybe_unused]] const PadIdentifier& identifier_) const {
     return Common::Input::NfcState::Success;
 }
 

src/input_common/drivers/virtual_amiibo.h

@@ -39,7 +39,7 @@ public:
     Common::Input::PollingError SetPollingMode(
         const PadIdentifier& identifier_, const Common::Input::PollingMode polling_mode_) override;
 
-    Common::Input::NfcState SupportsNfc(const PadIdentifier& identifier_) override;
+    Common::Input::NfcState SupportsNfc(const PadIdentifier& identifier_) const override;
 
     Common::Input::NfcState WriteNfcData(const PadIdentifier& identifier_,
                                          const std::vector<u8>& data) override;

src/input_common/input_engine.h

@@ -129,7 +129,8 @@ public:
     }
 
     // Request nfc data from a controller
-    virtual Common::Input::NfcState SupportsNfc([[maybe_unused]] const PadIdentifier& identifier) {
+    virtual Common::Input::NfcState SupportsNfc(
+        [[maybe_unused]] const PadIdentifier& identifier) const {
         return Common::Input::NfcState::NotSupported;
     }
 

src/input_common/input_poller.cpp

@@ -768,7 +768,7 @@ public:
         return input_engine->SetCameraFormat(identifier, camera_format);
     }
 
-    Common::Input::NfcState SupportsNfc() override {
+    Common::Input::NfcState SupportsNfc() const override {
         return input_engine->SupportsNfc(identifier);
     }