input_common: Implement native mifare support

src/core/hid/emulated_controller.cpp

@@ -149,12 +149,16 @@ void EmulatedController::LoadDevices() {
 
     camera_params[0] = right_joycon;
     camera_params[0].Set("camera", true);
-    camera_params[1] = Common::ParamPackage{"engine:camera,camera:1"};
-    ring_params[1] = Common::ParamPackage{"engine:joycon,axis_x:100,axis_y:101"};
-    nfc_params[0] = Common::ParamPackage{"engine:virtual_amiibo,nfc:1"};
     nfc_params[1] = right_joycon;
     nfc_params[1].Set("nfc", true);
 
+    // Only map virtual devices to the first controller
+    if (npad_id_type == NpadIdType::Player1 || npad_id_type == NpadIdType::Handheld) {
+        camera_params[1] = Common::ParamPackage{"engine:camera,camera:1"};
+        ring_params[1] = Common::ParamPackage{"engine:joycon,axis_x:100,axis_y:101"};
+        nfc_params[0] = Common::ParamPackage{"engine:virtual_amiibo,nfc:1"};
+    }
+
     output_params[LeftIndex] = left_joycon;
     output_params[RightIndex] = right_joycon;
     output_params[2] = camera_params[1];
@@ -1176,10 +1180,7 @@ void EmulatedController::SetNfc(const Common::Input::CallbackStatus& callback) {
         return;
     }
 
-    controller.nfc_state = {
-        controller.nfc_values.state,
-        controller.nfc_values.data,
-    };
+    controller.nfc_state = controller.nfc_values;
 }
 
 bool EmulatedController::SetVibration(std::size_t device_index, VibrationValue vibration) {
@@ -1308,6 +1309,73 @@ bool EmulatedController::HasNfc() const {
     return is_connected && (has_virtual_nfc && is_virtual_nfc_supported);
 }
 
+bool EmulatedController::AddNfcHandle() {
+    nfc_handles++;
+    return SetPollingMode(EmulatedDeviceIndex::RightIndex, Common::Input::PollingMode::NFC) ==
+           Common::Input::DriverResult::Success;
+}
+
+bool EmulatedController::RemoveNfcHandle() {
+    nfc_handles--;
+    if (nfc_handles <= 0) {
+        return SetPollingMode(EmulatedDeviceIndex::RightIndex,
+                              Common::Input::PollingMode::Active) ==
+               Common::Input::DriverResult::Success;
+    }
+    return true;
+}
+
+bool EmulatedController::StartNfcPolling() {
+    auto& nfc_output_device = output_devices[static_cast<std::size_t>(DeviceIndex::Right)];
+    auto& nfc_virtual_output_device = output_devices[3];
+
+    return nfc_output_device->StartNfcPolling() == Common::Input::NfcState::Success ||
+           nfc_virtual_output_device->StartNfcPolling() == Common::Input::NfcState::Success;
+}
+
+bool EmulatedController::StopNfcPolling() {
+    auto& nfc_output_device = output_devices[static_cast<std::size_t>(DeviceIndex::Right)];
+    auto& nfc_virtual_output_device = output_devices[3];
+
+    return nfc_output_device->StopNfcPolling() == Common::Input::NfcState::Success ||
+           nfc_virtual_output_device->StopNfcPolling() == Common::Input::NfcState::Success;
+}
+
+bool EmulatedController::ReadAmiiboData(std::vector<u8>& data) {
+    auto& nfc_output_device = output_devices[static_cast<std::size_t>(DeviceIndex::Right)];
+    auto& nfc_virtual_output_device = output_devices[3];
+
+    if (nfc_output_device->ReadAmiiboData(data) == Common::Input::NfcState::Success) {
+        return true;
+    }
+
+    return nfc_virtual_output_device->ReadAmiiboData(data) == Common::Input::NfcState::Success;
+}
+
+bool EmulatedController::ReadMifareData(const Common::Input::MifareRequest& request,
+                                        Common::Input::MifareRequest& out_data) {
+    auto& nfc_output_device = output_devices[static_cast<std::size_t>(DeviceIndex::Right)];
+    auto& nfc_virtual_output_device = output_devices[3];
+
+    if (nfc_output_device->ReadMifareData(request, out_data) == Common::Input::NfcState::Success) {
+        return true;
+    }
+
+    return nfc_virtual_output_device->ReadMifareData(request, out_data) ==
+           Common::Input::NfcState::Success;
+}
+
+bool EmulatedController::WriteMifareData(const Common::Input::MifareRequest& request) {
+    auto& nfc_output_device = output_devices[static_cast<std::size_t>(DeviceIndex::Right)];
+    auto& nfc_virtual_output_device = output_devices[3];
+
+    if (nfc_output_device->WriteMifareData(request) == Common::Input::NfcState::Success) {
+        return true;
+    }
+
+    return nfc_virtual_output_device->WriteMifareData(request) == Common::Input::NfcState::Success;
+}
+
 bool EmulatedController::WriteNfc(const std::vector<u8>& data) {
     auto& nfc_output_device = output_devices[static_cast<std::size_t>(DeviceIndex::Right)];
     auto& nfc_virtual_output_device = output_devices[3];

src/core/hid/emulated_controller.h

@@ -97,10 +97,7 @@ struct RingSensorForce {
     f32 force;
 };
 
-struct NfcState {
-    Common::Input::NfcState state{};
-    std::vector<u8> data{};
-};
+using NfcState = Common::Input::NfcStatus;
 
 struct ControllerMotion {
     Common::Vec3f accel{};
@@ -393,9 +390,31 @@ public:
     /// Returns true if the device has nfc support
     bool HasNfc() const;
 
+    /// Sets the joycon in nfc mode and increments the handle count
+    bool AddNfcHandle();
+
+    /// Decrements the handle count if zero sets the joycon in active mode
+    bool RemoveNfcHandle();
+
+    /// Start searching for nfc tags
+    bool StartNfcPolling();
+
+    /// Stop searching for nfc tags
+    bool StopNfcPolling();
+
+    /// Returns true if the nfc tag was readable
+    bool ReadAmiiboData(std::vector<u8>& data);
+
     /// Returns true if the nfc tag was written
     bool WriteNfc(const std::vector<u8>& data);
 
+    /// Returns true if the nfc tag was readable
+    bool ReadMifareData(const Common::Input::MifareRequest& request,
+                        Common::Input::MifareRequest& out_data);
+
+    /// Returns true if the nfc tag was written
+    bool WriteMifareData(const Common::Input::MifareRequest& request);
+
     /// Returns the led pattern corresponding to this emulated controller
     LedPattern GetLedPattern() const;
 
@@ -532,6 +551,7 @@ private:
     bool system_buttons_enabled{true};
     f32 motion_sensitivity{Core::HID::MotionInput::IsAtRestStandard};
     u32 turbo_button_state{0};
+    std::size_t nfc_handles{0};
 
     // Temporary values to avoid doing changes while the controller is in configuring mode
     NpadStyleIndex tmp_npad_type{NpadStyleIndex::None};

src/core/hid/input_converter.cpp

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