early-access version 3292

2023-01-06 15:33:58 +01:00
parent 7576231ec1
commit 76fd797270
147 changed files with 894 additions and 1909 deletions
--- a/src/core/hid/emulated_controller.cpp
+++ b/src/core/hid/emulated_controller.cpp
@@ -93,7 +93,6 @@ void EmulatedController::ReloadFromSettings() {
        motion_params[index] = Common::ParamPackage(player.motions[index]);
    }

-    controller.color_values = {};
    controller.colors_state.fullkey = {
        .body = GetNpadColor(player.body_color_left),
        .button = GetNpadColor(player.button_color_left),
@@ -107,8 +106,6 @@ void EmulatedController::ReloadFromSettings() {
        .button = GetNpadColor(player.button_color_right),
    };

-    ring_params[0] = Common::ParamPackage(Settings::values.ringcon_analogs);
-
    // Other or debug controller should always be a pro controller
    if (npad_id_type != NpadIdType::Other) {
        SetNpadStyleIndex(MapSettingsTypeToNPad(player.controller_type));
@@ -135,28 +132,18 @@ void EmulatedController::LoadDevices() {
    trigger_params[LeftIndex] = button_params[Settings::NativeButton::ZL];
    trigger_params[RightIndex] = button_params[Settings::NativeButton::ZR];

-    color_params[LeftIndex] = left_joycon;
-    color_params[RightIndex] = right_joycon;
-    color_params[LeftIndex].Set("color", true);
-    color_params[RightIndex].Set("color", true);
-
    battery_params[LeftIndex] = left_joycon;
    battery_params[RightIndex] = right_joycon;
    battery_params[LeftIndex].Set("battery", true);
    battery_params[RightIndex].Set("battery", true);

-    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);
+    camera_params = Common::ParamPackage{"engine:camera,camera:1"};
+    nfc_params = Common::ParamPackage{"engine:virtual_amiibo,nfc:1"};

    output_params[LeftIndex] = left_joycon;
    output_params[RightIndex] = right_joycon;
-    output_params[2] = camera_params[1];
-    output_params[3] = nfc_params[0];
+    output_params[2] = camera_params;
+    output_params[3] = nfc_params;
    output_params[LeftIndex].Set("output", true);
    output_params[RightIndex].Set("output", true);
    output_params[2].Set("output", true);
@@ -172,11 +159,8 @@ void EmulatedController::LoadDevices() {
                           Common::Input::CreateInputDevice);
    std::ranges::transform(battery_params, battery_devices.begin(),
                           Common::Input::CreateInputDevice);
-    std::ranges::transform(color_params, color_devices.begin(), Common::Input::CreateInputDevice);
-    std::ranges::transform(camera_params, camera_devices.begin(), Common::Input::CreateInputDevice);
-    std::ranges::transform(ring_params, ring_analog_devices.begin(),
-                           Common::Input::CreateInputDevice);
-    std::ranges::transform(nfc_params, nfc_devices.begin(), Common::Input::CreateInputDevice);
+    camera_devices = Common::Input::CreateInputDevice(camera_params);
+    nfc_devices = Common::Input::CreateInputDevice(nfc_params);
    std::ranges::transform(output_params, output_devices.begin(),
                           Common::Input::CreateOutputDevice);

@@ -338,19 +322,6 @@ void EmulatedController::ReloadInput() {
        battery_devices[index]->ForceUpdate();
    }

-    for (std::size_t index = 0; index < color_devices.size(); ++index) {
-        if (!color_devices[index]) {
-            continue;
-        }
-        color_devices[index]->SetCallback({
-            .on_change =
-                [this, index](const Common::Input::CallbackStatus& callback) {
-                    SetColors(callback, index);
-                },
-        });
-        color_devices[index]->ForceUpdate();
-    }
-
    for (std::size_t index = 0; index < motion_devices.size(); ++index) {
        if (!motion_devices[index]) {
            continue;
@@ -364,37 +335,22 @@ void EmulatedController::ReloadInput() {
        motion_devices[index]->ForceUpdate();
    }

-    for (std::size_t index = 0; index < camera_devices.size(); ++index) {
-        if (!camera_devices[index]) {
-            continue;
-        }
-        camera_devices[index]->SetCallback({
+    if (camera_devices) {
+        camera_devices->SetCallback({
            .on_change =
                [this](const Common::Input::CallbackStatus& callback) { SetCamera(callback); },
        });
-        camera_devices[index]->ForceUpdate();
+        camera_devices->ForceUpdate();
    }

-    for (std::size_t index = 0; index < ring_analog_devices.size(); ++index) {
-        if (!ring_analog_devices[index]) {
-            continue;
+    if (nfc_devices) {
+        if (npad_id_type == NpadIdType::Handheld || npad_id_type == NpadIdType::Player1) {
+            nfc_devices->SetCallback({
+                .on_change =
+                    [this](const Common::Input::CallbackStatus& callback) { SetNfc(callback); },
+            });
+            nfc_devices->ForceUpdate();
        }
-        ring_analog_devices[index]->SetCallback({
-            .on_change =
-                [this](const Common::Input::CallbackStatus& callback) { SetRingAnalog(callback); },
-        });
-        ring_analog_devices[index]->ForceUpdate();
-    }
-
-    for (std::size_t index = 0; index < nfc_devices.size(); ++index) {
-        if (!nfc_devices[index]) {
-            continue;
-        }
-        nfc_devices[index]->SetCallback({
-            .on_change =
-                [this](const Common::Input::CallbackStatus& callback) { SetNfc(callback); },
-        });
-        nfc_devices[index]->ForceUpdate();
    }

    // Register TAS devices. No need to force update
@@ -464,9 +420,6 @@ void EmulatedController::UnloadInput() {
    for (auto& battery : battery_devices) {
        battery.reset();
    }
-    for (auto& color : color_devices) {
-        color.reset();
-    }
    for (auto& output : output_devices) {
        output.reset();
    }
@@ -482,15 +435,8 @@ void EmulatedController::UnloadInput() {
    for (auto& stick : virtual_stick_devices) {
        stick.reset();
    }
-    for (auto& camera : camera_devices) {
-        camera.reset();
-    }
-    for (auto& ring : ring_analog_devices) {
-        ring.reset();
-    }
-    for (auto& nfc : nfc_devices) {
-        nfc.reset();
-    }
+    camera_devices.reset();
+    nfc_devices.reset();
 }

 void EmulatedController::EnableConfiguration() {
@@ -502,11 +448,6 @@ void EmulatedController::EnableConfiguration() {
 void EmulatedController::DisableConfiguration() {
    is_configuring = false;

-    // Get Joycon colors before turning on the controller
-    for (const auto& color_device : color_devices) {
-        color_device->ForceUpdate();
-    }
-
    // Apply temporary npad type to the real controller
    if (tmp_npad_type != npad_type) {
        if (is_connected) {
@@ -560,9 +501,6 @@ void EmulatedController::SaveCurrentConfig() {
    for (std::size_t index = 0; index < player.motions.size(); ++index) {
        player.motions[index] = motion_params[index].Serialize();
    }
-    if (npad_id_type == NpadIdType::Player1) {
-        Settings::values.ringcon_analogs = ring_params[0].Serialize();
-    }
 }

 void EmulatedController::RestoreConfig() {
@@ -977,58 +915,6 @@ void EmulatedController::SetMotion(const Common::Input::CallbackStatus& callback
    TriggerOnChange(ControllerTriggerType::Motion, true);
 }

-void EmulatedController::SetColors(const Common::Input::CallbackStatus& callback,
-                                   std::size_t index) {
-    if (index >= controller.color_values.size()) {
-        return;
-    }
-    std::unique_lock lock{mutex};
-    controller.color_values[index] = TransformToColor(callback);
-
-    if (is_configuring) {
-        lock.unlock();
-        TriggerOnChange(ControllerTriggerType::Color, false);
-        return;
-    }
-
-    if (controller.color_values[index].body == 0) {
-        return;
-    }
-
-    controller.colors_state.fullkey = {
-        .body = GetNpadColor(controller.color_values[index].body),
-        .button = GetNpadColor(controller.color_values[index].buttons),
-    };
-    if (npad_type == NpadStyleIndex::ProController) {
-        controller.colors_state.left = {
-            .body = GetNpadColor(controller.color_values[index].left_grip),
-            .button = GetNpadColor(controller.color_values[index].buttons),
-        };
-        controller.colors_state.right = {
-            .body = GetNpadColor(controller.color_values[index].right_grip),
-            .button = GetNpadColor(controller.color_values[index].buttons),
-        };
-    } else {
-        switch (index) {
-        case LeftIndex:
-            controller.colors_state.left = {
-                .body = GetNpadColor(controller.color_values[index].body),
-                .button = GetNpadColor(controller.color_values[index].buttons),
-            };
-            break;
-        case RightIndex:
-            controller.colors_state.right = {
-                .body = GetNpadColor(controller.color_values[index].body),
-                .button = GetNpadColor(controller.color_values[index].buttons),
-            };
-            break;
-        }
-    }
-
-    lock.unlock();
-    TriggerOnChange(ControllerTriggerType::Color, true);
-}
-
 void EmulatedController::SetBattery(const Common::Input::CallbackStatus& callback,
                                    std::size_t index) {
    if (index >= controller.battery_values.size()) {
@@ -1119,24 +1005,6 @@ void EmulatedController::SetCamera(const Common::Input::CallbackStatus& callback
    TriggerOnChange(ControllerTriggerType::IrSensor, true);
 }

-void EmulatedController::SetRingAnalog(const Common::Input::CallbackStatus& callback) {
-    std::unique_lock lock{mutex};
-    const auto force_value = TransformToStick(callback);
-
-    controller.ring_analog_value = force_value.x;
-
-    if (is_configuring) {
-        lock.unlock();
-        TriggerOnChange(ControllerTriggerType::RingController, false);
-        return;
-    }
-
-    controller.ring_analog_state.force = force_value.x.value;
-
-    lock.unlock();
-    TriggerOnChange(ControllerTriggerType::RingController, true);
-}
-
 void EmulatedController::SetNfc(const Common::Input::CallbackStatus& callback) {
    std::unique_lock lock{mutex};
    controller.nfc_values = TransformToNfc(callback);
@@ -1185,7 +1053,7 @@ bool EmulatedController::SetVibration(std::size_t device_index, VibrationValue v
        .type = type,
    };
    return output_devices[device_index]->SetVibration(status) ==
-           Common::Input::DriverResult::Success;
+           Common::Input::VibrationError::None;
 }

 bool EmulatedController::IsVibrationEnabled(std::size_t device_index) {
@@ -1207,8 +1075,7 @@ bool EmulatedController::IsVibrationEnabled(std::size_t device_index) {
    return output_devices[device_index]->IsVibrationEnabled();
 }

-Common::Input::DriverResult EmulatedController::SetPollingMode(
-    Common::Input::PollingMode polling_mode) {
+bool EmulatedController::SetPollingMode(Common::Input::PollingMode polling_mode) {
    LOG_INFO(Service_HID, "Set polling mode {}", polling_mode);
    auto& output_device = output_devices[static_cast<std::size_t>(DeviceIndex::Right)];
    auto& nfc_output_device = output_devices[3];
@@ -1216,11 +1083,8 @@ Common::Input::DriverResult EmulatedController::SetPollingMode(
    const auto virtual_nfc_result = nfc_output_device->SetPollingMode(polling_mode);
    const auto mapped_nfc_result = output_device->SetPollingMode(polling_mode);

-    if (virtual_nfc_result == Common::Input::DriverResult::Success) {
-        return virtual_nfc_result;
-    }
-
-    return mapped_nfc_result;
+    return virtual_nfc_result == Common::Input::PollingError::None ||
+           mapped_nfc_result == Common::Input::PollingError::None;
 }

 bool EmulatedController::SetCameraFormat(
@@ -1231,22 +1095,13 @@ bool EmulatedController::SetCameraFormat(
    auto& camera_output_device = output_devices[2];

    if (right_output_device->SetCameraFormat(static_cast<Common::Input::CameraFormat>(
-            camera_format)) == Common::Input::DriverResult::Success) {
+            camera_format)) == Common::Input::CameraError::None) {
        return true;
    }

    // Fallback to Qt camera if native device doesn't have support
    return camera_output_device->SetCameraFormat(static_cast<Common::Input::CameraFormat>(
-               camera_format)) == Common::Input::DriverResult::Success;
-}
-
-Common::ParamPackage EmulatedController::GetRingParam() const {
-    return ring_params[0];
-}
-
-void EmulatedController::SetRingParam(Common::ParamPackage param) {
-    ring_params[0] = std::move(param);
-    ReloadInput();
+               camera_format)) == Common::Input::CameraError::None;
 }

 bool EmulatedController::HasNfc() const {
@@ -1540,10 +1395,6 @@ CameraValues EmulatedController::GetCameraValues() const {
    return controller.camera_values;
 }

-RingAnalogValue EmulatedController::GetRingSensorValues() const {
-    return controller.ring_analog_value;
-}
-
 HomeButtonState EmulatedController::GetHomeButtons() const {
    std::scoped_lock lock{mutex};
    if (is_configuring) {
@@ -1637,10 +1488,6 @@ const CameraState& EmulatedController::GetCamera() const {
    return controller.camera_state;
 }

-RingSensorForce EmulatedController::GetRingSensorForce() const {
-    return controller.ring_analog_state;
-}
-
 const NfcState& EmulatedController::GetNfc() const {
    std::scoped_lock lock{mutex};
    return controller.nfc_state;
--- a/src/core/hid/emulated_controller.h
+++ b/src/core/hid/emulated_controller.h
@@ -35,27 +35,19 @@ using ControllerMotionDevices =
    std::array<std::unique_ptr<Common::Input::InputDevice>, Settings::NativeMotion::NumMotions>;
 using TriggerDevices =
    std::array<std::unique_ptr<Common::Input::InputDevice>, Settings::NativeTrigger::NumTriggers>;
-using ColorDevices =
-    std::array<std::unique_ptr<Common::Input::InputDevice>, max_emulated_controllers>;
 using BatteryDevices =
    std::array<std::unique_ptr<Common::Input::InputDevice>, max_emulated_controllers>;
-using CameraDevices =
-    std::array<std::unique_ptr<Common::Input::InputDevice>, max_emulated_controllers>;
-using RingAnalogDevices =
-    std::array<std::unique_ptr<Common::Input::InputDevice>, max_emulated_controllers>;
-using NfcDevices =
-    std::array<std::unique_ptr<Common::Input::InputDevice>, max_emulated_controllers>;
+using CameraDevices = std::unique_ptr<Common::Input::InputDevice>;
+using NfcDevices = std::unique_ptr<Common::Input::InputDevice>;
 using OutputDevices = std::array<std::unique_ptr<Common::Input::OutputDevice>, output_devices_size>;

 using ButtonParams = std::array<Common::ParamPackage, Settings::NativeButton::NumButtons>;
 using StickParams = std::array<Common::ParamPackage, Settings::NativeAnalog::NumAnalogs>;
 using ControllerMotionParams = std::array<Common::ParamPackage, Settings::NativeMotion::NumMotions>;
 using TriggerParams = std::array<Common::ParamPackage, Settings::NativeTrigger::NumTriggers>;
-using ColorParams = std::array<Common::ParamPackage, max_emulated_controllers>;
 using BatteryParams = std::array<Common::ParamPackage, max_emulated_controllers>;
-using CameraParams = std::array<Common::ParamPackage, max_emulated_controllers>;
-using RingAnalogParams = std::array<Common::ParamPackage, max_emulated_controllers>;
-using NfcParams = std::array<Common::ParamPackage, max_emulated_controllers>;
+using CameraParams = Common::ParamPackage;
+using NfcParams = Common::ParamPackage;
 using OutputParams = std::array<Common::ParamPackage, output_devices_size>;

 using ButtonValues = std::array<Common::Input::ButtonStatus, Settings::NativeButton::NumButtons>;
@@ -66,7 +58,6 @@ using ControllerMotionValues = std::array<ControllerMotionInfo, Settings::Native
 using ColorValues = std::array<Common::Input::BodyColorStatus, max_emulated_controllers>;
 using BatteryValues = std::array<Common::Input::BatteryStatus, max_emulated_controllers>;
 using CameraValues = Common::Input::CameraStatus;
-using RingAnalogValue = Common::Input::AnalogStatus;
 using NfcValues = Common::Input::NfcStatus;
 using VibrationValues = std::array<Common::Input::VibrationStatus, max_emulated_controllers>;

@@ -93,10 +84,6 @@ struct CameraState {
    std::size_t sample{};
 };

-struct RingSensorForce {
-    f32 force;
-};
-
 struct NfcState {
    Common::Input::NfcState state{};
    std::vector<u8> data{};
@@ -129,7 +116,6 @@ struct ControllerStatus {
    BatteryValues battery_values{};
    VibrationValues vibration_values{};
    CameraValues camera_values{};
-    RingAnalogValue ring_analog_value{};
    NfcValues nfc_values{};

    // Data for HID serices
@@ -143,7 +129,6 @@ struct ControllerStatus {
    ControllerColors colors_state{};
    BatteryLevelState battery_state{};
    CameraState camera_state{};
-    RingSensorForce ring_analog_state{};
    NfcState nfc_state{};
 };

@@ -156,7 +141,6 @@ enum class ControllerTriggerType {
    Battery,
    Vibration,
    IrSensor,
-    RingController,
    Nfc,
    Connected,
    Disconnected,
@@ -310,9 +294,6 @@ public:
    /// Returns the latest camera status from the controller with parameters
    CameraValues GetCameraValues() const;

-    /// Returns the latest status of analog input from the ring sensor with parameters
-    RingAnalogValue GetRingSensorValues() const;
-
    /// Returns the latest status of button input for the hid::HomeButton service
    HomeButtonState GetHomeButtons() const;

@@ -343,9 +324,6 @@ public:
    /// Returns the latest camera status from the controller
    const CameraState& GetCamera() const;

-    /// Returns the latest ringcon force sensor value
-    RingSensorForce GetRingSensorForce() const;
-
    /// Returns the latest ntag status from the controller
    const NfcState& GetNfc() const;

@@ -364,9 +342,9 @@ public:
    /**
     * Sets the desired data to be polled from a controller
     * @param polling_mode type of input desired buttons, gyro, nfc, ir, etc.
-     * @return driver result from this command
+     * @return true if SetPollingMode was successfull
     */
-    Common::Input::DriverResult SetPollingMode(Common::Input::PollingMode polling_mode);
+    bool SetPollingMode(Common::Input::PollingMode polling_mode);

    /**
     * Sets the desired camera format to be polled from a controller
@@ -375,15 +353,6 @@ public:
     */
    bool SetCameraFormat(Core::IrSensor::ImageTransferProcessorFormat camera_format);

-    // Returns the current mapped ring device
-    Common::ParamPackage GetRingParam() const;
-
-    /**
-     * Updates the current mapped ring device
-     * @param param ParamPackage with ring sensor data to be mapped
-     */
-    void SetRingParam(Common::ParamPackage param);
-
    /// Returns true if the device has nfc support
    bool HasNfc() const;

@@ -463,17 +432,10 @@ private:
     */
    void SetMotion(const Common::Input::CallbackStatus& callback, std::size_t index);

-    /**
-     * Updates the color status of the controller
-     * @param callback A CallbackStatus containing the color status
-     * @param index color ID of the to be updated
-     */
-    void SetColors(const Common::Input::CallbackStatus& callback, std::size_t index);
-
    /**
     * Updates the battery status of the controller
     * @param callback A CallbackStatus containing the battery status
-     * @param index battery ID of the to be updated
+     * @param index Button ID of the to be updated
     */
    void SetBattery(const Common::Input::CallbackStatus& callback, std::size_t index);

@@ -483,12 +445,6 @@ private:
     */
    void SetCamera(const Common::Input::CallbackStatus& callback);

-    /**
-     * Updates the ring analog sensor status of the ring controller
-     * @param callback A CallbackStatus containing the force status
-     */
-    void SetRingAnalog(const Common::Input::CallbackStatus& callback);
-
    /**
     * Updates the nfc status of the controller
     * @param callback A CallbackStatus containing the nfc status
@@ -528,9 +484,7 @@ private:
    ControllerMotionParams motion_params;
    TriggerParams trigger_params;
    BatteryParams battery_params;
-    ColorParams color_params;
    CameraParams camera_params;
-    RingAnalogParams ring_params;
    NfcParams nfc_params;
    OutputParams output_params;

@@ -539,9 +493,7 @@ private:
    ControllerMotionDevices motion_devices;
    TriggerDevices trigger_devices;
    BatteryDevices battery_devices;
-    ColorDevices color_devices;
    CameraDevices camera_devices;
-    RingAnalogDevices ring_analog_devices;
    NfcDevices nfc_devices;
    OutputDevices output_devices;

--- a/src/core/hid/emulated_devices.cpp
+++ b/src/core/hid/emulated_devices.cpp
@@ -14,6 +14,7 @@ EmulatedDevices::EmulatedDevices() = default;
 EmulatedDevices::~EmulatedDevices() = default;

 void EmulatedDevices::ReloadFromSettings() {
+    ring_params = Common::ParamPackage(Settings::values.ringcon_analogs);
    ReloadInput();
 }

@@ -65,6 +66,8 @@ void EmulatedDevices::ReloadInput() {
        key_index++;
    }

+    ring_analog_device = Common::Input::CreateInputDevice(ring_params);
+
    for (std::size_t index = 0; index < mouse_button_devices.size(); ++index) {
        if (!mouse_button_devices[index]) {
            continue;
@@ -119,6 +122,13 @@ void EmulatedDevices::ReloadInput() {
                },
        });
    }
+
+    if (ring_analog_device) {
+        ring_analog_device->SetCallback({
+            .on_change =
+                [this](const Common::Input::CallbackStatus& callback) { SetRingAnalog(callback); },
+        });
+    }
 }

 void EmulatedDevices::UnloadInput() {
@@ -135,6 +145,7 @@ void EmulatedDevices::UnloadInput() {
    for (auto& button : keyboard_modifier_devices) {
        button.reset();
    }
+    ring_analog_device.reset();
 }

 void EmulatedDevices::EnableConfiguration() {
@@ -154,6 +165,7 @@ void EmulatedDevices::SaveCurrentConfig() {
    if (!is_configuring) {
        return;
    }
+    Settings::values.ringcon_analogs = ring_params.Serialize();
 }

 void EmulatedDevices::RestoreConfig() {
@@ -163,6 +175,15 @@ void EmulatedDevices::RestoreConfig() {
    ReloadFromSettings();
 }

+Common::ParamPackage EmulatedDevices::GetRingParam() const {
+    return ring_params;
+}
+
+void EmulatedDevices::SetRingParam(Common::ParamPackage param) {
+    ring_params = std::move(param);
+    ReloadInput();
+}
+
 void EmulatedDevices::SetKeyboardButton(const Common::Input::CallbackStatus& callback,
                                        std::size_t index) {
    if (index >= device_status.keyboard_values.size()) {
@@ -409,6 +430,23 @@ void EmulatedDevices::SetMouseStick(const Common::Input::CallbackStatus& callbac
    TriggerOnChange(DeviceTriggerType::Mouse);
 }

+void EmulatedDevices::SetRingAnalog(const Common::Input::CallbackStatus& callback) {
+    std::lock_guard lock{mutex};
+    const auto force_value = TransformToStick(callback);
+
+    device_status.ring_analog_value = force_value.x;
+
+    if (is_configuring) {
+        device_status.ring_analog_value = {};
+        TriggerOnChange(DeviceTriggerType::RingController);
+        return;
+    }
+
+    device_status.ring_analog_state.force = force_value.x.value;
+
+    TriggerOnChange(DeviceTriggerType::RingController);
+}
+
 KeyboardValues EmulatedDevices::GetKeyboardValues() const {
    std::scoped_lock lock{mutex};
    return device_status.keyboard_values;
@@ -424,6 +462,10 @@ MouseButtonValues EmulatedDevices::GetMouseButtonsValues() const {
    return device_status.mouse_button_values;
 }

+RingAnalogValue EmulatedDevices::GetRingSensorValues() const {
+    return device_status.ring_analog_value;
+}
+
 KeyboardKey EmulatedDevices::GetKeyboard() const {
    std::scoped_lock lock{mutex};
    return device_status.keyboard_state;
@@ -449,6 +491,10 @@ AnalogStickState EmulatedDevices::GetMouseWheel() const {
    return device_status.mouse_wheel_state;
 }

+RingSensorForce EmulatedDevices::GetRingSensorForce() const {
+    return device_status.ring_analog_state;
+}
+
 void EmulatedDevices::TriggerOnChange(DeviceTriggerType type) {
    std::scoped_lock lock{callback_mutex};
    for (const auto& poller_pair : callback_list) {
--- a/src/core/hid/emulated_devices.h
+++ b/src/core/hid/emulated_devices.h
@@ -26,9 +26,11 @@ using MouseButtonDevices = std::array<std::unique_ptr<Common::Input::InputDevice
 using MouseAnalogDevices = std::array<std::unique_ptr<Common::Input::InputDevice>,
                                      Settings::NativeMouseWheel::NumMouseWheels>;
 using MouseStickDevice = std::unique_ptr<Common::Input::InputDevice>;
+using RingAnalogDevice = std::unique_ptr<Common::Input::InputDevice>;

 using MouseButtonParams =
    std::array<Common::ParamPackage, Settings::NativeMouseButton::NumMouseButtons>;
+using RingAnalogParams = Common::ParamPackage;

 using KeyboardValues =
    std::array<Common::Input::ButtonStatus, Settings::NativeKeyboard::NumKeyboardKeys>;
@@ -39,12 +41,17 @@ using MouseButtonValues =
 using MouseAnalogValues =
    std::array<Common::Input::AnalogStatus, Settings::NativeMouseWheel::NumMouseWheels>;
 using MouseStickValue = Common::Input::TouchStatus;
+using RingAnalogValue = Common::Input::AnalogStatus;

 struct MousePosition {
    f32 x;
    f32 y;
 };

+struct RingSensorForce {
+    f32 force;
+};
+
 struct DeviceStatus {
    // Data from input_common
    KeyboardValues keyboard_values{};
@@ -52,6 +59,7 @@ struct DeviceStatus {
    MouseButtonValues mouse_button_values{};
    MouseAnalogValues mouse_analog_values{};
    MouseStickValue mouse_stick_value{};
+    RingAnalogValue ring_analog_value{};

    // Data for HID serices
    KeyboardKey keyboard_state{};
@@ -59,6 +67,7 @@ struct DeviceStatus {
    MouseButton mouse_button_state{};
    MousePosition mouse_position_state{};
    AnalogStickState mouse_wheel_state{};
+    RingSensorForce ring_analog_state{};
 };

 enum class DeviceTriggerType {
@@ -129,6 +138,9 @@ public:
    /// Returns the latest status of button input from the mouse with parameters
    MouseButtonValues GetMouseButtonsValues() const;

+    /// Returns the latest status of analog input from the ring sensor with parameters
+    RingAnalogValue GetRingSensorValues() const;
+
    /// Returns the latest status of button input from the keyboard
    KeyboardKey GetKeyboard() const;

@@ -144,6 +156,9 @@ public:
    /// Returns the latest mouse wheel change
    AnalogStickState GetMouseWheel() const;

+    /// Returns the latest ringcon force sensor value
+    RingSensorForce GetRingSensorForce() const;
+
    /**
     * Adds a callback to the list of events
     * @param update_callback InterfaceUpdateCallback that will be triggered
@@ -209,11 +224,14 @@ private:

    bool is_configuring{false};

+    RingAnalogParams ring_params;
+
    KeyboardDevices keyboard_devices;
    KeyboardModifierDevices keyboard_modifier_devices;
    MouseButtonDevices mouse_button_devices;
    MouseAnalogDevices mouse_analog_devices;
    MouseStickDevice mouse_stick_device;
+    RingAnalogDevice ring_analog_device;

    mutable std::mutex mutex;
    mutable std::mutex callback_mutex;
--- a/src/core/hid/input_converter.cpp
+++ b/src/core/hid/input_converter.cpp
@@ -304,18 +304,6 @@ Common::Input::NfcStatus TransformToNfc(const Common::Input::CallbackStatus& cal
    return nfc;
 }

-Common::Input::BodyColorStatus TransformToColor(const Common::Input::CallbackStatus& callback) {
-    switch (callback.type) {
-    case Common::Input::InputType::Color:
-        return callback.color_status;
-        break;
-    default:
-        LOG_ERROR(Input, "Conversion from type {} to color not implemented", callback.type);
-        return {};
-        break;
-    }
-}
-
 void SanitizeAnalog(Common::Input::AnalogStatus& analog, bool clamp_value) {
    const auto& properties = analog.properties;
    float& raw_value = analog.raw_value;
--- a/src/core/hid/input_converter.h
+++ b/src/core/hid/input_converter.h
@@ -88,18 +88,10 @@ Common::Input::CameraStatus TransformToCamera(const Common::Input::CallbackStatu
 * Converts raw input data into a valid nfc status.
 *
 * @param callback Supported callbacks: Nfc.
- * @return A valid data tag vector.
+ * @return A valid CameraObject object.
 */
 Common::Input::NfcStatus TransformToNfc(const Common::Input::CallbackStatus& callback);

-/**
- * Converts raw input data into a valid color status.
- *
- * @param callback Supported callbacks: Color.
- * @return A valid Color object.
- */
-Common::Input::BodyColorStatus TransformToColor(const Common::Input::CallbackStatus& callback);
-
 /**
 * Converts raw analog data into a valid analog value
 * @param analog An analog object containing raw data and properties