12 files changed, 178 insertions, 154 deletions

diff --git a/src/core/hid/emulated_console.cpp b/src/core/hid/emulated_console.cpp
index d1d4a5355..c259de0f1 100644
--- a/src/core/hid/emulated_console.cpp
+++ b/src/core/hid/emulated_console.cpp
@@ -55,21 +55,21 @@ void EmulatedConsole::SetTouchParams() {
 
 void EmulatedConsole::ReloadInput() {
     SetTouchParams();
-    motion_devices = Input::CreateDevice<Input::InputDevice>(motion_params);
+    motion_devices = Common::Input::CreateDevice<Common::Input::InputDevice>(motion_params);
     if (motion_devices) {
-        Input::InputCallback motion_callback{
-            [this](Input::CallbackStatus callback) { SetMotion(callback); }};
+        Common::Input::InputCallback motion_callback{
+            [this](Common::Input::CallbackStatus callback) { SetMotion(callback); }};
         motion_devices->SetCallback(motion_callback);
     }
 
     std::size_t index = 0;
     for (auto& touch_device : touch_devices) {
-        touch_device = Input::CreateDevice<Input::InputDevice>(touch_params[index]);
+        touch_device = Common::Input::CreateDevice<Common::Input::InputDevice>(touch_params[index]);
         if (!touch_device) {
             continue;
         }
-        Input::InputCallback touch_callback{
-            [this, index](Input::CallbackStatus callback) { SetTouch(callback, index); }};
+        Common::Input::InputCallback touch_callback{
+            [this, index](Common::Input::CallbackStatus callback) { SetTouch(callback, index); }};
         touch_device->SetCallback(touch_callback);
         index++;
     }
@@ -117,7 +117,7 @@ void EmulatedConsole::SetMotionParam(Common::ParamPackage param) {
     ReloadInput();
 }
 
-void EmulatedConsole::SetMotion(Input::CallbackStatus callback) {
+void EmulatedConsole::SetMotion(Common::Input::CallbackStatus callback) {
     std::lock_guard lock{mutex};
     auto& raw_status = console.motion_values.raw_status;
     auto& emulated = console.motion_values.emulated;
@@ -152,7 +152,8 @@ void EmulatedConsole::SetMotion(Input::CallbackStatus callback) {
     TriggerOnChange(ConsoleTriggerType::Motion);
 }
 
-void EmulatedConsole::SetTouch(Input::CallbackStatus callback, [[maybe_unused]] std::size_t index) {
+void EmulatedConsole::SetTouch(Common::Input::CallbackStatus callback,
+                               [[maybe_unused]] std::size_t index) {
     if (index >= console.touch_values.size()) {
         return;
     }
diff --git a/src/core/hid/emulated_console.h b/src/core/hid/emulated_console.h
index f26f24f2e..9aec482a6 100644
--- a/src/core/hid/emulated_console.h
+++ b/src/core/hid/emulated_console.h
@@ -4,10 +4,13 @@
 
 #pragma once
 
+#include <array>
 #include <functional>
+#include <memory>
 #include <mutex>
 #include <unordered_map>
 
+#include "common/common_types.h"
 #include "common/input.h"
 #include "common/param_package.h"
 #include "common/point.h"
@@ -20,18 +23,18 @@
 namespace Core::HID {
 
 struct ConsoleMotionInfo {
-    Input::MotionStatus raw_status{};
+    Common::Input::MotionStatus raw_status{};
     MotionInput emulated{};
 };
 
-using ConsoleMotionDevices = std::unique_ptr<Input::InputDevice>;
-using TouchDevices = std::array<std::unique_ptr<Input::InputDevice>, 16>;
+using ConsoleMotionDevices = std::unique_ptr<Common::Input::InputDevice>;
+using TouchDevices = std::array<std::unique_ptr<Common::Input::InputDevice>, 16>;
 
 using ConsoleMotionParams = Common::ParamPackage;
 using TouchParams = std::array<Common::ParamPackage, 16>;
 
 using ConsoleMotionValues = ConsoleMotionInfo;
-using TouchValues = std::array<Input::TouchStatus, 16>;
+using TouchValues = std::array<Common::Input::TouchStatus, 16>;
 
 struct TouchFinger {
     u64 last_touch{};
@@ -151,14 +154,14 @@ private:
      * Updates the motion status of the console
      * @param A CallbackStatus containing gyro and accelerometer data
      */
-    void SetMotion(Input::CallbackStatus callback);
+    void SetMotion(Common::Input::CallbackStatus callback);
 
     /**
      * Updates the touch status of the console
      * @param callback: A CallbackStatus containing the touch position
      * @param index: Finger ID to be updated
      */
-    void SetTouch(Input::CallbackStatus callback, std::size_t index);
+    void SetTouch(Common::Input::CallbackStatus callback, std::size_t index);
 
     /**
      * Triggers a callback that something has changed on the console status
diff --git a/src/core/hid/emulated_controller.cpp b/src/core/hid/emulated_controller.cpp
index 69568f4e9..49893cdbd 100644
--- a/src/core/hid/emulated_controller.cpp
+++ b/src/core/hid/emulated_controller.cpp
@@ -110,25 +110,25 @@ void EmulatedController::LoadDevices() {
 
     std::transform(button_params.begin() + Settings::NativeButton::BUTTON_HID_BEGIN,
                    button_params.begin() + Settings::NativeButton::BUTTON_NS_END,
-                   button_devices.begin(), Input::CreateDevice<Input::InputDevice>);
+                   button_devices.begin(), Common::Input::CreateDevice<Common::Input::InputDevice>);
     std::transform(stick_params.begin() + Settings::NativeAnalog::STICK_HID_BEGIN,
                    stick_params.begin() + Settings::NativeAnalog::STICK_HID_END,
-                   stick_devices.begin(), Input::CreateDevice<Input::InputDevice>);
+                   stick_devices.begin(), Common::Input::CreateDevice<Common::Input::InputDevice>);
     std::transform(motion_params.begin() + Settings::NativeMotion::MOTION_HID_BEGIN,
                    motion_params.begin() + Settings::NativeMotion::MOTION_HID_END,
-                   motion_devices.begin(), Input::CreateDevice<Input::InputDevice>);
+                   motion_devices.begin(), Common::Input::CreateDevice<Common::Input::InputDevice>);
     std::transform(trigger_params.begin(), trigger_params.end(), trigger_devices.begin(),
-                   Input::CreateDevice<Input::InputDevice>);
+                   Common::Input::CreateDevice<Common::Input::InputDevice>);
     std::transform(battery_params.begin(), battery_params.begin(), battery_devices.end(),
-                   Input::CreateDevice<Input::InputDevice>);
+                   Common::Input::CreateDevice<Common::Input::InputDevice>);
     std::transform(output_params.begin(), output_params.end(), output_devices.begin(),
-                   Input::CreateDevice<Input::OutputDevice>);
+                   Common::Input::CreateDevice<Common::Input::OutputDevice>);
 
     // Initialize TAS devices
     std::transform(tas_button_params.begin(), tas_button_params.end(), tas_button_devices.begin(),
-                   Input::CreateDevice<Input::InputDevice>);
+                   Common::Input::CreateDevice<Common::Input::InputDevice>);
     std::transform(tas_stick_params.begin(), tas_stick_params.end(), tas_stick_devices.begin(),
-                   Input::CreateDevice<Input::InputDevice>);
+                   Common::Input::CreateDevice<Common::Input::InputDevice>);
 }
 
 void EmulatedController::LoadTASParams() {
@@ -178,8 +178,8 @@ void EmulatedController::ReloadInput() {
         if (!button_devices[index]) {
             continue;
         }
-        Input::InputCallback button_callback{
-            [this, index](Input::CallbackStatus callback) { SetButton(callback, index); }};
+        Common::Input::InputCallback button_callback{
+            [this, index](Common::Input::CallbackStatus callback) { SetButton(callback, index); }};
         button_devices[index]->SetCallback(button_callback);
         button_devices[index]->ForceUpdate();
     }
@@ -188,8 +188,8 @@ void EmulatedController::ReloadInput() {
         if (!stick_devices[index]) {
             continue;
         }
-        Input::InputCallback stick_callback{
-            [this, index](Input::CallbackStatus callback) { SetStick(callback, index); }};
+        Common::Input::InputCallback stick_callback{
+            [this, index](Common::Input::CallbackStatus callback) { SetStick(callback, index); }};
         stick_devices[index]->SetCallback(stick_callback);
         stick_devices[index]->ForceUpdate();
     }
@@ -198,8 +198,8 @@ void EmulatedController::ReloadInput() {
         if (!trigger_devices[index]) {
             continue;
         }
-        Input::InputCallback trigger_callback{
-            [this, index](Input::CallbackStatus callback) { SetTrigger(callback, index); }};
+        Common::Input::InputCallback trigger_callback{
+            [this, index](Common::Input::CallbackStatus callback) { SetTrigger(callback, index); }};
         trigger_devices[index]->SetCallback(trigger_callback);
         trigger_devices[index]->ForceUpdate();
     }
@@ -208,8 +208,8 @@ void EmulatedController::ReloadInput() {
         if (!battery_devices[index]) {
             continue;
         }
-        Input::InputCallback battery_callback{
-            [this, index](Input::CallbackStatus callback) { SetBattery(callback, index); }};
+        Common::Input::InputCallback battery_callback{
+            [this, index](Common::Input::CallbackStatus callback) { SetBattery(callback, index); }};
         battery_devices[index]->SetCallback(battery_callback);
         battery_devices[index]->ForceUpdate();
     }
@@ -218,8 +218,8 @@ void EmulatedController::ReloadInput() {
         if (!motion_devices[index]) {
             continue;
         }
-        Input::InputCallback motion_callback{
-            [this, index](Input::CallbackStatus callback) { SetMotion(callback, index); }};
+        Common::Input::InputCallback motion_callback{
+            [this, index](Common::Input::CallbackStatus callback) { SetMotion(callback, index); }};
         motion_devices[index]->SetCallback(motion_callback);
         motion_devices[index]->ForceUpdate();
     }
@@ -229,8 +229,8 @@ void EmulatedController::ReloadInput() {
         if (!tas_button_devices[index]) {
             continue;
         }
-        Input::InputCallback button_callback{
-            [this, index](Input::CallbackStatus callback) { SetButton(callback, index); }};
+        Common::Input::InputCallback button_callback{
+            [this, index](Common::Input::CallbackStatus callback) { SetButton(callback, index); }};
         tas_button_devices[index]->SetCallback(button_callback);
     }
 
@@ -238,8 +238,8 @@ void EmulatedController::ReloadInput() {
         if (!tas_stick_devices[index]) {
             continue;
         }
-        Input::InputCallback stick_callback{
-            [this, index](Input::CallbackStatus callback) { SetStick(callback, index); }};
+        Common::Input::InputCallback stick_callback{
+            [this, index](Common::Input::CallbackStatus callback) { SetStick(callback, index); }};
         tas_stick_devices[index]->SetCallback(stick_callback);
     }
 }
@@ -418,7 +418,7 @@ void EmulatedController::SetMotionParam(std::size_t index, Common::ParamPackage
     ReloadInput();
 }
 
-void EmulatedController::SetButton(Input::CallbackStatus callback, std::size_t index) {
+void EmulatedController::SetButton(Common::Input::CallbackStatus callback, std::size_t index) {
     if (index >= controller.button_values.size()) {
         return;
     }
@@ -548,7 +548,7 @@ void EmulatedController::SetButton(Input::CallbackStatus callback, std::size_t i
     TriggerOnChange(ControllerTriggerType::Button, true);
 }
 
-void EmulatedController::SetStick(Input::CallbackStatus callback, std::size_t index) {
+void EmulatedController::SetStick(Common::Input::CallbackStatus callback, std::size_t index) {
     if (index >= controller.stick_values.size()) {
         return;
     }
@@ -587,7 +587,7 @@ void EmulatedController::SetStick(Input::CallbackStatus callback, std::size_t in
     TriggerOnChange(ControllerTriggerType::Stick, true);
 }
 
-void EmulatedController::SetTrigger(Input::CallbackStatus callback, std::size_t index) {
+void EmulatedController::SetTrigger(Common::Input::CallbackStatus callback, std::size_t index) {
     if (index >= controller.trigger_values.size()) {
         return;
     }
@@ -618,7 +618,7 @@ void EmulatedController::SetTrigger(Input::CallbackStatus callback, std::size_t
     TriggerOnChange(ControllerTriggerType::Trigger, true);
 }
 
-void EmulatedController::SetMotion(Input::CallbackStatus callback, std::size_t index) {
+void EmulatedController::SetMotion(Common::Input::CallbackStatus callback, std::size_t index) {
     if (index >= controller.motion_values.size()) {
         return;
     }
@@ -655,7 +655,7 @@ void EmulatedController::SetMotion(Input::CallbackStatus callback, std::size_t i
     TriggerOnChange(ControllerTriggerType::Motion, true);
 }
 
-void EmulatedController::SetBattery(Input::CallbackStatus callback, std::size_t index) {
+void EmulatedController::SetBattery(Common::Input::CallbackStatus callback, std::size_t index) {
     if (index >= controller.battery_values.size()) {
         return;
     }
@@ -671,25 +671,25 @@ void EmulatedController::SetBattery(Input::CallbackStatus callback, std::size_t
     bool is_powered = false;
     BatteryLevel battery_level = 0;
     switch (controller.battery_values[index]) {
-    case Input::BatteryLevel::Charging:
+    case Common::Input::BatteryLevel::Charging:
         is_charging = true;
         is_powered = true;
         battery_level = 6;
         break;
-    case Input::BatteryLevel::Medium:
+    case Common::Input::BatteryLevel::Medium:
         battery_level = 6;
         break;
-    case Input::BatteryLevel::Low:
+    case Common::Input::BatteryLevel::Low:
         battery_level = 4;
         break;
-    case Input::BatteryLevel::Critical:
+    case Common::Input::BatteryLevel::Critical:
         battery_level = 2;
         break;
-    case Input::BatteryLevel::Empty:
+    case Common::Input::BatteryLevel::Empty:
         battery_level = 0;
         break;
-    case Input::BatteryLevel::None:
-    case Input::BatteryLevel::Full:
+    case Common::Input::BatteryLevel::None:
+    case Common::Input::BatteryLevel::Full:
     default:
         is_powered = true;
         battery_level = 8;
@@ -739,18 +739,19 @@ bool EmulatedController::SetVibration(std::size_t device_index, VibrationValue v
 
     // Exponential amplification is too strong at low amplitudes. Switch to a linear
     // amplification if strength is set below 0.7f
-    const Input::VibrationAmplificationType type =
-        strength > 0.7f ? Input::VibrationAmplificationType::Exponential
-                        : Input::VibrationAmplificationType::Linear;
+    const Common::Input::VibrationAmplificationType type =
+        strength > 0.7f ? Common::Input::VibrationAmplificationType::Exponential
+                        : Common::Input::VibrationAmplificationType::Linear;
 
-    const Input::VibrationStatus status = {
+    const Common::Input::VibrationStatus status = {
         .low_amplitude = std::min(vibration.low_amplitude * strength, 1.0f),
         .low_frequency = vibration.low_frequency,
         .high_amplitude = std::min(vibration.high_amplitude * strength, 1.0f),
         .high_frequency = vibration.high_frequency,
         .type = type,
     };
-    return output_devices[device_index]->SetVibration(status) == Input::VibrationError::None;
+    return output_devices[device_index]->SetVibration(status) ==
+           Common::Input::VibrationError::None;
 }
 
 bool EmulatedController::TestVibration(std::size_t device_index) {
@@ -762,14 +763,15 @@ bool EmulatedController::TestVibration(std::size_t device_index) {
     }
 
     // Send a slight vibration to test for rumble support
-    constexpr Input::VibrationStatus status = {
+    constexpr Common::Input::VibrationStatus status = {
         .low_amplitude = 0.001f,
         .low_frequency = 160.0f,
         .high_amplitude = 0.001f,
         .high_frequency = 320.0f,
-        .type = Input::VibrationAmplificationType::Linear,
+        .type = Common::Input::VibrationAmplificationType::Linear,
     };
-    return output_devices[device_index]->SetVibration(status) == Input::VibrationError::None;
+    return output_devices[device_index]->SetVibration(status) ==
+           Common::Input::VibrationError::None;
 }
 
 void EmulatedController::SetLedPattern() {
@@ -779,7 +781,7 @@ void EmulatedController::SetLedPattern() {
         }
 
         const LedPattern pattern = GetLedPattern();
-        const Input::LedStatus status = {
+        const Common::Input::LedStatus status = {
             .led_1 = pattern.position1 != 0,
             .led_2 = pattern.position2 != 0,
             .led_3 = pattern.position3 != 0,
diff --git a/src/core/hid/emulated_controller.h b/src/core/hid/emulated_controller.h
index fea401365..dd9a93364 100644
--- a/src/core/hid/emulated_controller.h
+++ b/src/core/hid/emulated_controller.h
@@ -4,10 +4,13 @@
 
 #pragma once
 
+#include <array>
 #include <functional>
+#include <memory>
 #include <mutex>
 #include <unordered_map>
 
+#include "common/common_types.h"
 #include "common/input.h"
 #include "common/param_package.h"
 #include "common/point.h"
@@ -20,20 +23,22 @@
 namespace Core::HID {
 const std::size_t max_emulated_controllers = 2;
 struct ControllerMotionInfo {
-    Input::MotionStatus raw_status{};
+    Common::Input::MotionStatus raw_status{};
     MotionInput emulated{};
 };
 
 using ButtonDevices =
-    std::array<std::unique_ptr<Input::InputDevice>, Settings::NativeButton::NumButtons>;
+    std::array<std::unique_ptr<Common::Input::InputDevice>, Settings::NativeButton::NumButtons>;
 using StickDevices =
-    std::array<std::unique_ptr<Input::InputDevice>, Settings::NativeAnalog::NumAnalogs>;
+    std::array<std::unique_ptr<Common::Input::InputDevice>, Settings::NativeAnalog::NumAnalogs>;
 using ControllerMotionDevices =
-    std::array<std::unique_ptr<Input::InputDevice>, Settings::NativeMotion::NumMotions>;
+    std::array<std::unique_ptr<Common::Input::InputDevice>, Settings::NativeMotion::NumMotions>;
 using TriggerDevices =
-    std::array<std::unique_ptr<Input::InputDevice>, Settings::NativeTrigger::NumTriggers>;
-using BatteryDevices = std::array<std::unique_ptr<Input::InputDevice>, max_emulated_controllers>;
-using OutputDevices = std::array<std::unique_ptr<Input::OutputDevice>, max_emulated_controllers>;
+    std::array<std::unique_ptr<Common::Input::InputDevice>, Settings::NativeTrigger::NumTriggers>;
+using BatteryDevices =
+    std::array<std::unique_ptr<Common::Input::InputDevice>, max_emulated_controllers>;
+using OutputDevices =
+    std::array<std::unique_ptr<Common::Input::OutputDevice>, max_emulated_controllers>;
 
 using ButtonParams = std::array<Common::ParamPackage, Settings::NativeButton::NumButtons>;
 using StickParams = std::array<Common::ParamPackage, Settings::NativeAnalog::NumAnalogs>;
@@ -42,13 +47,14 @@ using TriggerParams = std::array<Common::ParamPackage, Settings::NativeTrigger::
 using BatteryParams = std::array<Common::ParamPackage, max_emulated_controllers>;
 using OutputParams = std::array<Common::ParamPackage, max_emulated_controllers>;
 
-using ButtonValues = std::array<Input::ButtonStatus, Settings::NativeButton::NumButtons>;
-using SticksValues = std::array<Input::StickStatus, Settings::NativeAnalog::NumAnalogs>;
-using TriggerValues = std::array<Input::TriggerStatus, Settings::NativeTrigger::NumTriggers>;
+using ButtonValues = std::array<Common::Input::ButtonStatus, Settings::NativeButton::NumButtons>;
+using SticksValues = std::array<Common::Input::StickStatus, Settings::NativeAnalog::NumAnalogs>;
+using TriggerValues =
+    std::array<Common::Input::TriggerStatus, Settings::NativeTrigger::NumTriggers>;
 using ControllerMotionValues = std::array<ControllerMotionInfo, Settings::NativeMotion::NumMotions>;
-using ColorValues = std::array<Input::BodyColorStatus, max_emulated_controllers>;
-using BatteryValues = std::array<Input::BatteryStatus, max_emulated_controllers>;
-using VibrationValues = std::array<Input::VibrationStatus, max_emulated_controllers>;
+using ColorValues = std::array<Common::Input::BodyColorStatus, max_emulated_controllers>;
+using BatteryValues = std::array<Common::Input::BatteryStatus, max_emulated_controllers>;
+using VibrationValues = std::array<Common::Input::VibrationStatus, max_emulated_controllers>;
 
 struct AnalogSticks {
     AnalogStickState left{};
@@ -307,35 +313,35 @@ private:
      * @param callback: A CallbackStatus containing the button status
      * @param index: Button ID of the to be updated
      */
-    void SetButton(Input::CallbackStatus callback, std::size_t index);
+    void SetButton(Common::Input::CallbackStatus callback, std::size_t index);
 
     /**
      * Updates the analog stick status of the controller
      * @param callback: A CallbackStatus containing the analog stick status
      * @param index: stick ID of the to be updated
      */
-    void SetStick(Input::CallbackStatus callback, std::size_t index);
+    void SetStick(Common::Input::CallbackStatus callback, std::size_t index);
 
     /**
      * Updates the trigger status of the controller
      * @param callback: A CallbackStatus containing the trigger status
      * @param index: trigger ID of the to be updated
      */
-    void SetTrigger(Input::CallbackStatus callback, std::size_t index);
+    void SetTrigger(Common::Input::CallbackStatus callback, std::size_t index);
 
     /**
      * Updates the motion status of the controller
      * @param callback: A CallbackStatus containing gyro and accelerometer data
      * @param index: motion ID of the to be updated
      */
-    void SetMotion(Input::CallbackStatus callback, std::size_t index);
+    void SetMotion(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: Button ID of the to be updated
      */
-    void SetBattery(Input::CallbackStatus callback, std::size_t index);
+    void SetBattery(Common::Input::CallbackStatus callback, std::size_t index);
 
     /**
      * Triggers a callback that something has changed on the controller status
diff --git a/src/core/hid/emulated_devices.cpp b/src/core/hid/emulated_devices.cpp
index eb59c310c..c76a86b6c 100644
--- a/src/core/hid/emulated_devices.cpp
+++ b/src/core/hid/emulated_devices.cpp
@@ -2,6 +2,7 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included
 
+#include <algorithm>
 #include <fmt/format.h>
 
 #include "core/hid/emulated_devices.h"
@@ -25,21 +26,25 @@ void EmulatedDevices::ReloadFromSettings() {
 void EmulatedDevices::ReloadInput() {
     std::transform(mouse_button_params.begin() + Settings::NativeMouseButton::MOUSE_HID_BEGIN,
                    mouse_button_params.begin() + Settings::NativeMouseButton::MOUSE_HID_END,
-                   mouse_button_devices.begin(), Input::CreateDevice<Input::InputDevice>);
+                   mouse_button_devices.begin(),
+                   Common::Input::CreateDevice<Common::Input::InputDevice>);
 
     std::transform(Settings::values.keyboard_keys.begin(), Settings::values.keyboard_keys.end(),
-                   keyboard_devices.begin(), Input::CreateDeviceFromString<Input::InputDevice>);
+                   keyboard_devices.begin(),
+                   Common::Input::CreateDeviceFromString<Common::Input::InputDevice>);
 
     std::transform(Settings::values.keyboard_mods.begin(), Settings::values.keyboard_mods.end(),
                    keyboard_modifier_devices.begin(),
-                   Input::CreateDeviceFromString<Input::InputDevice>);
+                   Common::Input::CreateDeviceFromString<Common::Input::InputDevice>);
 
     for (std::size_t index = 0; index < mouse_button_devices.size(); ++index) {
         if (!mouse_button_devices[index]) {
             continue;
         }
-        Input::InputCallback button_callback{
-            [this, index](Input::CallbackStatus callback) { SetMouseButton(callback, index); }};
+        Common::Input::InputCallback button_callback{
+            [this, index](Common::Input::CallbackStatus callback) {
+                SetMouseButton(callback, index);
+            }};
         mouse_button_devices[index]->SetCallback(button_callback);
     }
 
@@ -47,8 +52,10 @@ void EmulatedDevices::ReloadInput() {
         if (!keyboard_devices[index]) {
             continue;
         }
-        Input::InputCallback button_callback{
-            [this, index](Input::CallbackStatus callback) { SetKeyboardButton(callback, index); }};
+        Common::Input::InputCallback button_callback{
+            [this, index](Common::Input::CallbackStatus callback) {
+                SetKeyboardButton(callback, index);
+            }};
         keyboard_devices[index]->SetCallback(button_callback);
     }
 
@@ -56,9 +63,10 @@ void EmulatedDevices::ReloadInput() {
         if (!keyboard_modifier_devices[index]) {
             continue;
         }
-        Input::InputCallback button_callback{[this, index](Input::CallbackStatus callback) {
-            SetKeyboardModifier(callback, index);
-        }};
+        Common::Input::InputCallback button_callback{
+            [this, index](Common::Input::CallbackStatus callback) {
+                SetKeyboardModifier(callback, index);
+            }};
         keyboard_modifier_devices[index]->SetCallback(button_callback);
     }
 }
@@ -122,7 +130,7 @@ void EmulatedDevices::SetMouseButtonParam(std::size_t index, Common::ParamPackag
     ReloadInput();
 }
 
-void EmulatedDevices::SetKeyboardButton(Input::CallbackStatus callback, std::size_t index) {
+void EmulatedDevices::SetKeyboardButton(Common::Input::CallbackStatus callback, std::size_t index) {
     if (index >= device_status.keyboard_values.size()) {
         return;
     }
@@ -170,7 +178,7 @@ void EmulatedDevices::SetKeyboardButton(Input::CallbackStatus callback, std::siz
 void EmulatedDevices::UpdateKey(std::size_t key_index, bool status) {
     constexpr u8 KEYS_PER_BYTE = 8;
     auto& entry = device_status.keyboard_state.key[key_index / KEYS_PER_BYTE];
-    const u8 mask = 1 << (key_index % KEYS_PER_BYTE);
+    const u8 mask = static_cast<u8>(1 << (key_index % KEYS_PER_BYTE));
     if (status) {
         entry = entry | mask;
     } else {
@@ -178,7 +186,8 @@ void EmulatedDevices::UpdateKey(std::size_t key_index, bool status) {
     }
 }
 
-void EmulatedDevices::SetKeyboardModifier(Input::CallbackStatus callback, std::size_t index) {
+void EmulatedDevices::SetKeyboardModifier(Common::Input::CallbackStatus callback,
+                                          std::size_t index) {
     if (index >= device_status.keyboard_moddifier_values.size()) {
         return;
     }
@@ -247,7 +256,7 @@ void EmulatedDevices::SetKeyboardModifier(Input::CallbackStatus callback, std::s
     TriggerOnChange(DeviceTriggerType::KeyboardModdifier);
 }
 
-void EmulatedDevices::SetMouseButton(Input::CallbackStatus callback, std::size_t index) {
+void EmulatedDevices::SetMouseButton(Common::Input::CallbackStatus callback, std::size_t index) {
     if (index >= device_status.mouse_button_values.size()) {
         return;
     }
diff --git a/src/core/hid/emulated_devices.h b/src/core/hid/emulated_devices.h
index 7ed95eac6..418b2f9b5 100644
--- a/src/core/hid/emulated_devices.h
+++ b/src/core/hid/emulated_devices.h
@@ -4,10 +4,13 @@
 
 #pragma once
 
+#include <array>
 #include <functional>
+#include <memory>
 #include <mutex>
 #include <unordered_map>
 
+#include "common/common_types.h"
 #include "common/input.h"
 #include "common/param_package.h"
 #include "common/settings.h"
@@ -16,21 +19,22 @@
 
 namespace Core::HID {
 
-using KeyboardDevices =
-    std::array<std::unique_ptr<Input::InputDevice>, Settings::NativeKeyboard::NumKeyboardKeys>;
-using KeyboardModifierDevices =
-    std::array<std::unique_ptr<Input::InputDevice>, Settings::NativeKeyboard::NumKeyboardMods>;
-using MouseButtonDevices =
-    std::array<std::unique_ptr<Input::InputDevice>, Settings::NativeMouseButton::NumMouseButtons>;
+using KeyboardDevices = std::array<std::unique_ptr<Common::Input::InputDevice>,
+                                   Settings::NativeKeyboard::NumKeyboardKeys>;
+using KeyboardModifierDevices = std::array<std::unique_ptr<Common::Input::InputDevice>,
+                                           Settings::NativeKeyboard::NumKeyboardMods>;
+using MouseButtonDevices = std::array<std::unique_ptr<Common::Input::InputDevice>,
+                                      Settings::NativeMouseButton::NumMouseButtons>;
 
 using MouseButtonParams =
     std::array<Common::ParamPackage, Settings::NativeMouseButton::NumMouseButtons>;
 
-using KeyboardValues = std::array<Input::ButtonStatus, Settings::NativeKeyboard::NumKeyboardKeys>;
+using KeyboardValues =
+    std::array<Common::Input::ButtonStatus, Settings::NativeKeyboard::NumKeyboardKeys>;
 using KeyboardModifierValues =
-    std::array<Input::ButtonStatus, Settings::NativeKeyboard::NumKeyboardMods>;
+    std::array<Common::Input::ButtonStatus, Settings::NativeKeyboard::NumKeyboardMods>;
 using MouseButtonValues =
-    std::array<Input::ButtonStatus, Settings::NativeMouseButton::NumMouseButtons>;
+    std::array<Common::Input::ButtonStatus, Settings::NativeMouseButton::NumMouseButtons>;
 
 struct MousePosition {
     s32 x;
@@ -151,21 +155,21 @@ private:
      * @param callback: A CallbackStatus containing the key status
      * @param index: key ID to be updated
      */
-    void SetKeyboardButton(Input::CallbackStatus callback, std::size_t index);
+    void SetKeyboardButton(Common::Input::CallbackStatus callback, std::size_t index);
 
     /**
      * Updates the touch status of the console
      * @param callback: A CallbackStatus containing the modifier key status
      * @param index: modifier key ID to be updated
      */
-    void SetKeyboardModifier(Input::CallbackStatus callback, std::size_t index);
+    void SetKeyboardModifier(Common::Input::CallbackStatus callback, std::size_t index);
 
     /**
      * Updates the touch status of the console
      * @param callback: A CallbackStatus containing the button status
      * @param index: Button ID of the to be updated
      */
-    void SetMouseButton(Input::CallbackStatus callback, std::size_t index);
+    void SetMouseButton(Common::Input::CallbackStatus callback, std::size_t index);
 
     /**
      * Triggers a callback that something has changed on the device status
diff --git a/src/core/hid/input_converter.cpp b/src/core/hid/input_converter.cpp
index e2598f367..14204917e 100644
--- a/src/core/hid/input_converter.cpp
+++ b/src/core/hid/input_converter.cpp
@@ -9,35 +9,35 @@
 
 namespace Core::HID {
 
-Input::BatteryStatus TransformToBattery(const Input::CallbackStatus& callback) {
-    Input::BatteryStatus battery{Input::BatteryStatus::None};
+Common::Input::BatteryStatus TransformToBattery(const Common::Input::CallbackStatus& callback) {
+    Common::Input::BatteryStatus battery{Common::Input::BatteryStatus::None};
     switch (callback.type) {
-    case Input::InputType::Analog:
-    case Input::InputType::Trigger: {
+    case Common::Input::InputType::Analog:
+    case Common::Input::InputType::Trigger: {
         const auto value = TransformToTrigger(callback).analog.value;
-        battery = Input::BatteryLevel::Empty;
+        battery = Common::Input::BatteryLevel::Empty;
         if (value > 0.2f) {
-            battery = Input::BatteryLevel::Critical;
+            battery = Common::Input::BatteryLevel::Critical;
         }
         if (value > 0.4f) {
-            battery = Input::BatteryLevel::Low;
+            battery = Common::Input::BatteryLevel::Low;
         }
         if (value > 0.6f) {
-            battery = Input::BatteryLevel::Medium;
+            battery = Common::Input::BatteryLevel::Medium;
         }
         if (value > 0.8f) {
-            battery = Input::BatteryLevel::Full;
+            battery = Common::Input::BatteryLevel::Full;
         }
         if (value >= 1.0f) {
-            battery = Input::BatteryLevel::Charging;
+            battery = Common::Input::BatteryLevel::Charging;
         }
         break;
     }
-    case Input::InputType::Button:
-        battery = callback.button_status.value ? Input::BatteryLevel::Charging
-                                               : Input::BatteryLevel::Critical;
+    case Common::Input::InputType::Button:
+        battery = callback.button_status.value ? Common::Input::BatteryLevel::Charging
+                                               : Common::Input::BatteryLevel::Critical;
         break;
-    case Input::InputType::Battery:
+    case Common::Input::InputType::Battery:
         battery = callback.battery_status;
         break;
     default:
@@ -48,14 +48,14 @@ Input::BatteryStatus TransformToBattery(const Input::CallbackStatus& callback) {
     return battery;
 }
 
-Input::ButtonStatus TransformToButton(const Input::CallbackStatus& callback) {
-    Input::ButtonStatus status{};
+Common::Input::ButtonStatus TransformToButton(const Common::Input::CallbackStatus& callback) {
+    Common::Input::ButtonStatus status{};
     switch (callback.type) {
-    case Input::InputType::Analog:
-    case Input::InputType::Trigger:
+    case Common::Input::InputType::Analog:
+    case Common::Input::InputType::Trigger:
         status.value = TransformToTrigger(callback).pressed;
         break;
-    case Input::InputType::Button:
+    case Common::Input::InputType::Button:
         status = callback.button_status;
         break;
     default:
@@ -70,15 +70,15 @@ Input::ButtonStatus TransformToButton(const Input::CallbackStatus& callback) {
     return status;
 }
 
-Input::MotionStatus TransformToMotion(const Input::CallbackStatus& callback) {
-    Input::MotionStatus status{};
+Common::Input::MotionStatus TransformToMotion(const Common::Input::CallbackStatus& callback) {
+    Common::Input::MotionStatus status{};
     switch (callback.type) {
-    case Input::InputType::Button: {
+    case Common::Input::InputType::Button: {
         if (TransformToButton(callback).value) {
             std::random_device device;
             std::mt19937 gen(device());
             std::uniform_int_distribution<s16> distribution(-1000, 1000);
-            Input::AnalogProperties properties{
+            Common::Input::AnalogProperties properties{
                 .deadzone = 0.0,
                 .range = 1.0f,
                 .offset = 0.0,
@@ -116,7 +116,7 @@ Input::MotionStatus TransformToMotion(const Input::CallbackStatus& callback) {
         }
         break;
     }
-    case Input::InputType::Motion:
+    case Common::Input::InputType::Motion:
         status = callback.motion_status;
         break;
     default:
@@ -133,11 +133,11 @@ Input::MotionStatus TransformToMotion(const Input::CallbackStatus& callback) {
     return status;
 }
 
-Input::StickStatus TransformToStick(const Input::CallbackStatus& callback) {
-    Input::StickStatus status{};
+Common::Input::StickStatus TransformToStick(const Common::Input::CallbackStatus& callback) {
+    Common::Input::StickStatus status{};
 
     switch (callback.type) {
-    case Input::InputType::Stick:
+    case Common::Input::InputType::Stick:
         status = callback.stick_status;
         break;
     default:
@@ -160,11 +160,11 @@ Input::StickStatus TransformToStick(const Input::CallbackStatus& callback) {
     return status;
 }
 
-Input::TouchStatus TransformToTouch(const Input::CallbackStatus& callback) {
-    Input::TouchStatus status{};
+Common::Input::TouchStatus TransformToTouch(const Common::Input::CallbackStatus& callback) {
+    Common::Input::TouchStatus status{};
 
     switch (callback.type) {
-    case Input::InputType::Touch:
+    case Common::Input::InputType::Touch:
         status = callback.touch_status;
         break;
     default:
@@ -192,22 +192,22 @@ Input::TouchStatus TransformToTouch(const Input::CallbackStatus& callback) {
     return status;
 }
 
-Input::TriggerStatus TransformToTrigger(const Input::CallbackStatus& callback) {
-    Input::TriggerStatus status{};
+Common::Input::TriggerStatus TransformToTrigger(const Common::Input::CallbackStatus& callback) {
+    Common::Input::TriggerStatus status{};
     float& raw_value = status.analog.raw_value;
     bool calculate_button_value = true;
 
     switch (callback.type) {
-    case Input::InputType::Analog:
+    case Common::Input::InputType::Analog:
         status.analog.properties = callback.analog_status.properties;
         raw_value = callback.analog_status.raw_value;
         break;
-    case Input::InputType::Button:
+    case Common::Input::InputType::Button:
         status.analog.properties.range = 1.0f;
         status.analog.properties.inverted = callback.button_status.inverted;
         raw_value = callback.button_status.value ? 1.0f : 0.0f;
         break;
-    case Input::InputType::Trigger:
+    case Common::Input::InputType::Trigger:
         status = callback.trigger_status;
         calculate_button_value = false;
         break;
@@ -234,7 +234,7 @@ Input::TriggerStatus TransformToTrigger(const Input::CallbackStatus& callback) {
     return status;
 }
 
-void SanitizeAnalog(Input::AnalogStatus& analog, bool clamp_value) {
+void SanitizeAnalog(Common::Input::AnalogStatus& analog, bool clamp_value) {
     const auto& properties = analog.properties;
     float& raw_value = analog.raw_value;
     float& value = analog.value;
@@ -274,7 +274,8 @@ void SanitizeAnalog(Input::AnalogStatus& analog, bool clamp_value) {
     }
 }
 
-void SanitizeStick(Input::AnalogStatus& analog_x, Input::AnalogStatus& analog_y, bool clamp_value) {
+void SanitizeStick(Common::Input::AnalogStatus& analog_x, Common::Input::AnalogStatus& analog_y,
+                   bool clamp_value) {
     const auto& properties_x = analog_x.properties;
     const auto& properties_y = analog_y.properties;
     float& raw_x = analog_x.raw_value;
diff --git a/src/core/hid/input_converter.h b/src/core/hid/input_converter.h
index 3cc32e26a..b38e657b0 100644
--- a/src/core/hid/input_converter.h
+++ b/src/core/hid/input_converter.h
@@ -16,7 +16,7 @@ namespace Core::HID {
  * @param Supported callbacks: Analog, Battery, Trigger.
  * @return A valid BatteryStatus object.
  */
-Input::BatteryStatus TransformToBattery(const Input::CallbackStatus& callback);
+Common::Input::BatteryStatus TransformToBattery(const Common::Input::CallbackStatus& callback);
 
 /**
  * Converts raw input data into a valid button status. Applies invert properties to the output.
@@ -24,7 +24,7 @@ Input::BatteryStatus TransformToBattery(const Input::CallbackStatus& callback);
  * @param Supported callbacks: Analog, Button, Trigger.
  * @return A valid TouchStatus object.
  */
-Input::ButtonStatus TransformToButton(const Input::CallbackStatus& callback);
+Common::Input::ButtonStatus TransformToButton(const Common::Input::CallbackStatus& callback);
 
 /**
  * Converts raw input data into a valid motion status.
@@ -32,7 +32,7 @@ Input::ButtonStatus TransformToButton(const Input::CallbackStatus& callback);
  * @param Supported callbacks: Motion.
  * @return A valid TouchStatus object.
  */
-Input::MotionStatus TransformToMotion(const Input::CallbackStatus& callback);
+Common::Input::MotionStatus TransformToMotion(const Common::Input::CallbackStatus& callback);
 
 /**
  * Converts raw input data into a valid stick status. Applies offset, deadzone, range and invert
@@ -41,7 +41,7 @@ Input::MotionStatus TransformToMotion(const Input::CallbackStatus& callback);
  * @param Supported callbacks: Stick.
  * @return A valid StickStatus object.
  */
-Input::StickStatus TransformToStick(const Input::CallbackStatus& callback);
+Common::Input::StickStatus TransformToStick(const Common::Input::CallbackStatus& callback);
 
 /**
  * Converts raw input data into a valid touch status.
@@ -49,7 +49,7 @@ Input::StickStatus TransformToStick(const Input::CallbackStatus& callback);
  * @param Supported callbacks: Touch.
  * @return A valid TouchStatus object.
  */
-Input::TouchStatus TransformToTouch(const Input::CallbackStatus& callback);
+Common::Input::TouchStatus TransformToTouch(const Common::Input::CallbackStatus& callback);
 
 /**
  * Converts raw input data into a valid trigger status. Applies offset, deadzone, range and
@@ -58,20 +58,21 @@ Input::TouchStatus TransformToTouch(const Input::CallbackStatus& callback);
  * @param Supported callbacks: Analog, Button, Trigger.
  * @return A valid TriggerStatus object.
  */
-Input::TriggerStatus TransformToTrigger(const Input::CallbackStatus& callback);
+Common::Input::TriggerStatus TransformToTrigger(const Common::Input::CallbackStatus& callback);
 
 /**
  * Converts raw analog data into a valid analog value
  * @param An analog object containing raw data and properties, bool that determines if the value
  * needs to be clamped between -1.0f and 1.0f.
  */
-void SanitizeAnalog(Input::AnalogStatus& analog, bool clamp_value);
+void SanitizeAnalog(Common::Input::AnalogStatus& analog, bool clamp_value);
 
 /**
  * Converts raw stick data into a valid stick value
  * @param Two analog objects containing raw data and properties, bool that determines if the value
  * needs to be clamped into the unit circle.
  */
-void SanitizeStick(Input::AnalogStatus& analog_x, Input::AnalogStatus& analog_y, bool clamp_value);
+void SanitizeStick(Common::Input::AnalogStatus& analog_x, Common::Input::AnalogStatus& analog_y,
+                   bool clamp_value);
 
 } // namespace Core::HID
diff --git a/src/core/hle/service/hid/controllers/debug_pad.cpp b/src/core/hle/service/hid/controllers/debug_pad.cpp
index 345134357..b009ed086 100644
--- a/src/core/hle/service/hid/controllers/debug_pad.cpp
+++ b/src/core/hle/service/hid/controllers/debug_pad.cpp
@@ -13,9 +13,6 @@
 
 namespace Service::HID {
 constexpr std::size_t SHARED_MEMORY_OFFSET = 0x00000;
-constexpr s32 HID_JOYSTICK_MAX = 0x7fff;
-[[maybe_unused]] constexpr s32 HID_JOYSTICK_MIN = -0x7fff;
-enum class JoystickId : std::size_t { Joystick_Left, Joystick_Right };
 
 Controller_DebugPad::Controller_DebugPad(Core::System& system_) : ControllerBase{system_} {
     controller = system.HIDCore().GetEmulatedController(Core::HID::NpadIdType::Other);
diff --git a/src/core/hle/service/hid/controllers/keyboard.cpp b/src/core/hle/service/hid/controllers/keyboard.cpp
index f4d49965f..60dc62f2c 100644
--- a/src/core/hle/service/hid/controllers/keyboard.cpp
+++ b/src/core/hle/service/hid/controllers/keyboard.cpp
@@ -12,7 +12,6 @@
 
 namespace Service::HID {
 constexpr std::size_t SHARED_MEMORY_OFFSET = 0x3800;
-constexpr u8 KEYS_PER_BYTE = 8;
 
 Controller_Keyboard::Controller_Keyboard(Core::System& system_) : ControllerBase{system_} {
     emulated_devices = system.HIDCore().GetEmulatedDevices();
diff --git a/src/core/hle/service/hid/controllers/npad.h b/src/core/hle/service/hid/controllers/npad.h
index af4934c55..4a9c9cc1a 100644
--- a/src/core/hle/service/hid/controllers/npad.h
+++ b/src/core/hle/service/hid/controllers/npad.h
@@ -403,8 +403,7 @@ private:
         AppletFooterUiType type;
         INSERT_PADDING_BYTES(0x5B); // Reserved
     };
-    static_assert(sizeof(AppletFooterUi) == 0x60,
-                  "AppletFooterUi is an invalid size");
+    static_assert(sizeof(AppletFooterUi) == 0x60, "AppletFooterUi is an invalid size");
 
     // This is nn::hid::NpadLarkType
     enum class NpadLarkType : u32 {
diff --git a/src/core/hle/service/hid/ring_lifo.h b/src/core/hle/service/hid/ring_lifo.h
index 382350a2d..6209ed0d1 100644
--- a/src/core/hle/service/hid/ring_lifo.h
+++ b/src/core/hle/service/hid/ring_lifo.h
@@ -4,6 +4,8 @@
 
 #pragma once
 
+#include <array>
+
 #include "common/common_types.h"
 #include "common/swap.h"
 
@@ -29,10 +31,10 @@ struct Lifo {
     }
 
     const AtomicStorage<State>& ReadPreviousEntry() const {
-        return entries[GetPreviuousEntryIndex()];
+        return entries[GetPreviousEntryIndex()];
     }
 
-    std::size_t GetPreviuousEntryIndex() const {
+    std::size_t GetPreviousEntryIndex() const {
         return (buffer_tail + total_buffer_count - 1) % total_buffer_count;
     }