Joystick hotplug support (#4141)

* use SDL_PollEvent instead of SDL_JoystickUpdate

Register hot plugged controller by GUID if they were configured in a previous session

* Move SDL_PollEvent into its own thread

* Don't store SDLJoystick pointer in Input Device; Get pointer on each GetStatus call

* Fix that joystick_list gets cleared after SDL_Quit

* Add VirtualJoystick for InputDevices thats never nullptr

* fixup! Add VirtualJoystick for InputDevices thats never nullptr

* fixup! fixup! Add VirtualJoystick for InputDevices thats never nullptr

* Remove SDL_GameController, make SDL_Joystick* unique_ptr

* fixup! Remove SDL_GameController, make SDL_Joystick* unique_ptr

* Adressed feedback; fixed handling of same guid reconnects

* fixup! Adressed feedback; fixed handling of same guid reconnects

* merge the two joystick_lists into one

* make SDLJoystick a member of VirtualJoystick

* fixup! make SDLJoystick a member of VirtualJoystick

* fixup! make SDLJoystick a member of VirtualJoystick

* fixup! fixup! make SDLJoystick a member of VirtualJoystick

src/citra/emu_window/emu_window_sdl2.cpp

@@ -17,6 +17,7 @@
 #include "input_common/keyboard.h"
 #include "input_common/main.h"
 #include "input_common/motion_emu.h"
+#include "input_common/sdl/sdl.h"
 #include "network/network.h"
 
 void EmuWindow_SDL2::OnMouseMotion(s32 x, s32 y) {
@@ -86,7 +87,7 @@ EmuWindow_SDL2::EmuWindow_SDL2(bool fullscreen) {
     SDL_SetMainReady();
 
     // Initialize the window
-    if (SDL_Init(SDL_INIT_VIDEO) < 0) {
+    if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_JOYSTICK) < 0) {
         LOG_CRITICAL(Frontend, "Failed to initialize SDL2! Exiting...");
         exit(1);
     }
@@ -142,6 +143,7 @@ EmuWindow_SDL2::EmuWindow_SDL2(bool fullscreen) {
 }
 
 EmuWindow_SDL2::~EmuWindow_SDL2() {
+    InputCommon::SDL::CloseSDLJoysticks();
     SDL_GL_DeleteContext(gl_context);
     SDL_Quit();
 
@@ -187,6 +189,8 @@ void EmuWindow_SDL2::PollEvents() {
         case SDL_QUIT:
             is_open = false;
             break;
+        default:
+            InputCommon::SDL::HandleGameControllerEvent(event);
         }
     }
 }

src/citra_qt/bootmanager.cpp

@@ -108,6 +108,7 @@ GRenderWindow::GRenderWindow(QWidget* parent, EmuThread* emu_thread)
     setWindowTitle(QString::fromStdString(window_title));
 
     InputCommon::Init();
+    InputCommon::StartJoystickEventHandler();
 }
 
 GRenderWindow::~GRenderWindow() {

src/citra_qt/configuration/configure_input.cpp

@@ -1,4 +1,4 @@
-// Copyright 2016 Citra Emulator Project
+// Copyright 2016 Citra Emulator Project
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
@@ -53,19 +53,18 @@ static QString ButtonToText(const Common::ParamPackage& param) {
     } else if (param.Get("engine", "") == "keyboard") {
         return getKeyName(param.Get("code", 0));
     } else if (param.Get("engine", "") == "sdl") {
-        QString text = QString(QObject::tr("Joystick %1")).arg(param.Get("joystick", "").c_str());
         if (param.Has("hat")) {
-            text += QString(QObject::tr(" Hat %1 %2"))
+            return QString(QObject::tr("Hat %1 %2"))
                 .arg(param.Get("hat", "").c_str(), param.Get("direction", "").c_str());
         }
         if (param.Has("axis")) {
-            text += QString(QObject::tr(" Axis %1%2"))
+            return QString(QObject::tr("Axis %1%2"))
                 .arg(param.Get("axis", "").c_str(), param.Get("direction", "").c_str());
         }
         if (param.Has("button")) {
-            text += QString(QObject::tr(" Button %1")).arg(param.Get("button", "").c_str());
+            return QString(QObject::tr("Button %1")).arg(param.Get("button", "").c_str());
         }
-        return text;
+        return QString();
     } else {
         return QObject::tr("[unknown]");
     }
@@ -81,13 +80,12 @@ static QString AnalogToText(const Common::ParamPackage& param, const std::string
             return QString(QObject::tr("[unused]"));
         }
 
-        QString text = QString(QObject::tr("Joystick %1")).arg(param.Get("joystick", "").c_str());
         if (dir == "left" || dir == "right") {
-            text += QString(QObject::tr(" Axis %1")).arg(param.Get("axis_x", "").c_str());
+            return QString(QObject::tr("Axis %1")).arg(param.Get("axis_x", "").c_str());
         } else if (dir == "up" || dir == "down") {
-            text += QString(QObject::tr(" Axis %1")).arg(param.Get("axis_y", "").c_str());
+            return QString(QObject::tr("Axis %1")).arg(param.Get("axis_y", "").c_str());
         }
-        return text;
+        return QString();
     } else {
         return QObject::tr("[unknown]");
     }

src/input_common/main.cpp

@@ -3,6 +3,7 @@
 // Refer to the license.txt file included.
 
 #include <memory>
+#include <thread>
 #include "common/param_package.h"
 #include "input_common/analog_from_button.h"
 #include "input_common/keyboard.h"
@@ -19,6 +20,10 @@ static std::shared_ptr<Keyboard> keyboard;
 static std::shared_ptr<MotionEmu> motion_emu;
 static std::unique_ptr<CemuhookUDP::State> udp;
 
+#ifdef HAVE_SDL2
+static std::thread poll_thread;
+#endif
+
 void Init() {
     keyboard = std::make_shared<Keyboard>();
     Input::RegisterFactory<Input::ButtonDevice>("keyboard", keyboard);
@@ -34,6 +39,12 @@ void Init() {
     udp = CemuhookUDP::Init();
 }
 
+void StartJoystickEventHandler() {
+#ifdef HAVE_SDL2
+    poll_thread = std::thread(SDL::PollLoop);
+#endif
+}
+
 void Shutdown() {
     Input::UnregisterFactory<Input::ButtonDevice>("keyboard");
     keyboard.reset();
@@ -43,6 +54,7 @@ void Shutdown() {
 
 #ifdef HAVE_SDL2
     SDL::Shutdown();
+    poll_thread.join();
 #endif
 }
 

src/input_common/main.h

@@ -20,6 +20,8 @@ void Init();
 /// Deregisters all built-in input device factories and shuts them down.
 void Shutdown();
 
+void StartJoystickEventHandler();
+
 class Keyboard;
 
 /// Gets the keyboard button device factory.

src/input_common/sdl/sdl.cpp

@@ -2,15 +2,23 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
+#include <atomic>
 #include <cmath>
+#include <functional>
+#include <iterator>
+#include <mutex>
 #include <string>
+#include <thread>
 #include <tuple>
 #include <unordered_map>
 #include <utility>
+#include <vector>
 #include <SDL.h>
+#include "common/assert.h"
 #include "common/logging/log.h"
 #include "common/math_util.h"
 #include "common/param_package.h"
+#include "common/threadsafe_queue.h"
 #include "input_common/main.h"
 #include "input_common/sdl/sdl.h"
 
@@ -21,33 +29,53 @@ namespace SDL {
 class SDLJoystick;
 class SDLButtonFactory;
 class SDLAnalogFactory;
-static std::unordered_map<int, std::weak_ptr<SDLJoystick>> joystick_list;
+
+/// Map of GUID of a list of corresponding vurtual Joysticks
+static std::unordered_map<std::string, std::vector<std::shared_ptr<SDLJoystick>>> joystick_map;
+static std::mutex joystick_map_mutex;
+
 static std::shared_ptr<SDLButtonFactory> button_factory;
 static std::shared_ptr<SDLAnalogFactory> analog_factory;
 
-static bool initialized = false;
+/// Used by the Pollers during config
+static std::atomic<bool> polling;
+static Common::SPSCQueue<SDL_Event> event_queue;
+
+static std::atomic<bool> initialized = false;
+
+static std::string GetGUID(SDL_Joystick* joystick) {
+    SDL_JoystickGUID guid = SDL_JoystickGetGUID(joystick);
+    char guid_str[33];
+    SDL_JoystickGetGUIDString(guid, guid_str, sizeof(guid_str));
+    return guid_str;
+}
 
 class SDLJoystick {
 public:
-    explicit SDLJoystick(int joystick_index)
+    SDLJoystick(const std::string& guid_, int port_, SDL_Joystick* joystick,
-        : joystick{SDL_JoystickOpen(joystick_index), SDL_JoystickClose} {
+                decltype(&SDL_JoystickClose) deleter = &SDL_JoystickClose)
-        if (!joystick) {
+        : guid{guid_}, port{port_}, sdl_joystick{joystick, deleter} {}
-            LOG_ERROR(Input, "failed to open joystick {}", joystick_index);
+
-        }
+    ~SDLJoystick() = default;
+
+    void SetButton(int button, bool value) {
+        std::lock_guard<std::mutex> lock(mutex);
+        state.buttons[button] = value;
     }
 
     bool GetButton(int button) const {
-        if (!joystick)
+        std::lock_guard<std::mutex> lock(mutex);
-            return {};
+        return state.buttons.at(button);
-        SDL_JoystickUpdate();
+    }
-        return SDL_JoystickGetButton(joystick.get(), button) == 1;
+
+    void SetAxis(int axis, Sint16 value) {
+        std::lock_guard<std::mutex> lock(mutex);
+        state.axes[axis] = value;
     }
 
     float GetAxis(int axis) const {
-        if (!joystick)
+        std::lock_guard<std::mutex> lock(mutex);
-            return {};
+        return state.axes.at(axis) / 32767.0f;
-        SDL_JoystickUpdate();
-        return SDL_JoystickGetAxis(joystick.get(), axis) / 32767.0f;
     }
 
     std::tuple<float, float> GetAnalog(int axis_x, int axis_y) const {
@@ -67,18 +95,216 @@ public:
         return std::make_tuple(x, y);
     }
 
-    bool GetHatDirection(int hat, Uint8 direction) const {
+    void SetHat(int hat, Uint8 direction) {
-        return (SDL_JoystickGetHat(joystick.get(), hat) & direction) != 0;
+        std::lock_guard<std::mutex> lock(mutex);
+        state.hats[hat] = direction;
     }
 
-    SDL_JoystickID GetJoystickID() const {
+    bool GetHatDirection(int hat, Uint8 direction) const {
-        return SDL_JoystickInstanceID(joystick.get());
+        std::lock_guard<std::mutex> lock(mutex);
+        return (state.hats.at(hat) & direction) != 0;
+    }
+    /**
+     * The guid of the joystick
+     */
+    const std::string& GetGUID() const {
+        return guid;
+    }
+
+    /**
+     * The number of joystick from the same type that were connected before this joystick
+     */
+    int GetPort() const {
+        return port;
+    }
+
+    SDL_Joystick* GetSDLJoystick() const {
+        return sdl_joystick.get();
+    }
+
+    void SetSDLJoystick(SDL_Joystick* joystick,
+                        decltype(&SDL_JoystickClose) deleter = &SDL_JoystickClose) {
+        sdl_joystick =
+            std::unique_ptr<SDL_Joystick, decltype(&SDL_JoystickClose)>(joystick, deleter);
     }
 
 private:
-    std::unique_ptr<SDL_Joystick, decltype(&SDL_JoystickClose)> joystick;
+    struct State {
+        std::unordered_map<int, bool> buttons;
+        std::unordered_map<int, Sint16> axes;
+        std::unordered_map<int, Uint8> hats;
+    } state;
+    const std::string guid;
+    const int port;
+    std::unique_ptr<SDL_Joystick, decltype(&SDL_JoystickClose)> sdl_joystick;
+    mutable std::mutex mutex;
 };
 
+/**
+ * Get the nth joystick with the corresponding GUID
+ */
+static std::shared_ptr<SDLJoystick> GetSDLJoystickByGUID(const std::string& guid, int port) {
+    std::lock_guard<std::mutex> lock(joystick_map_mutex);
+    const auto& it = joystick_map.find(guid);
+    if (it != joystick_map.end()) {
+        while (it->second.size() <= port) {
+            auto joystick = std::make_shared<SDLJoystick>(guid, it->second.size(), nullptr,
+                                                          [](SDL_Joystick*) {});
+            it->second.emplace_back(joystick);
+        }
+        return it->second[port];
+    }
+    auto joystick = std::make_shared<SDLJoystick>(guid, 0, nullptr, [](SDL_Joystick*) {});
+    joystick_map[guid].emplace_back(joystick);
+    return joystick;
+}
+
+/**
+ * Check how many identical joysticks (by guid) were connected before the one with sdl_id and so tie
+ * it to a SDLJoystick with the same guid and that port
+ */
+static std::shared_ptr<SDLJoystick> GetSDLJoystickBySDLID(SDL_JoystickID sdl_id) {
+    std::lock_guard<std::mutex> lock(joystick_map_mutex);
+    auto sdl_joystick = SDL_JoystickFromInstanceID(sdl_id);
+    const std::string guid = GetGUID(sdl_joystick);
+    auto map_it = joystick_map.find(guid);
+    if (map_it != joystick_map.end()) {
+        auto vec_it = std::find_if(map_it->second.begin(), map_it->second.end(),
+                                   [&sdl_joystick](const std::shared_ptr<SDLJoystick>& joystick) {
+                                       return sdl_joystick == joystick->GetSDLJoystick();
+                                   });
+        if (vec_it != map_it->second.end()) {
+            // This is the common case: There is already an existing SDLJoystick maped to a
+            // SDLJoystick. return the SDLJoystick
+            return *vec_it;
+        }
+        // Search for a SDLJoystick without a mapped SDLJoystick...
+        auto nullptr_it = std::find_if(map_it->second.begin(), map_it->second.end(),
+                                       [](const std::shared_ptr<SDLJoystick>& joystick) {
+                                           return !joystick->GetSDLJoystick();
+                                       });
+        if (nullptr_it != map_it->second.end()) {
+            // ... and map it
+            (*nullptr_it)->SetSDLJoystick(sdl_joystick);
+            return *nullptr_it;
+        }
+        // There is no SDLJoystick without a mapped SDLJoystick
+        auto joystick = std::make_shared<SDLJoystick>(guid, map_it->second.size(), sdl_joystick);
+        map_it->second.emplace_back(joystick);
+        return joystick;
+    }
+    auto joystick = std::make_shared<SDLJoystick>(guid, 0, sdl_joystick);
+    joystick_map[guid].emplace_back(joystick);
+    return joystick;
+}
+
+void InitJoystick(int joystick_index) {
+    std::lock_guard<std::mutex> lock(joystick_map_mutex);
+    SDL_Joystick* sdl_joystick = SDL_JoystickOpen(joystick_index);
+    if (!sdl_joystick) {
+        LOG_ERROR(Input, "failed to open joystick {}", joystick_index);
+        return;
+    }
+    std::string guid = GetGUID(sdl_joystick);
+    if (joystick_map.find(guid) == joystick_map.end()) {
+        auto joystick = std::make_shared<SDLJoystick>(guid, 0, sdl_joystick);
+        joystick_map[guid].emplace_back(joystick);
+        return;
+    }
+    auto& joystick_guid_list = joystick_map[guid];
+    const auto& it = std::find_if(
+        joystick_guid_list.begin(), joystick_guid_list.end(),
+        [](const std::shared_ptr<SDLJoystick>& joystick) { return !joystick->GetSDLJoystick(); });
+    if (it != joystick_guid_list.end()) {
+        (*it)->SetSDLJoystick(sdl_joystick);
+        return;
+    }
+    auto joystick = std::make_shared<SDLJoystick>(guid, joystick_guid_list.size(), sdl_joystick);
+    joystick_guid_list.emplace_back(joystick);
+}
+
+void CloseJoystick(SDL_Joystick* sdl_joystick) {
+    std::lock_guard<std::mutex> lock(joystick_map_mutex);
+    std::string guid = GetGUID(sdl_joystick);
+    // This call to guid is save since the joystick is guranteed to be in that map
+    auto& joystick_guid_list = joystick_map[guid];
+    const auto& joystick_it =
+        std::find_if(joystick_guid_list.begin(), joystick_guid_list.end(),
+                     [&sdl_joystick](const std::shared_ptr<SDLJoystick>& joystick) {
+                         return joystick->GetSDLJoystick() == sdl_joystick;
+                     });
+    (*joystick_it)->SetSDLJoystick(nullptr, [](SDL_Joystick*) {});
+    return;
+}
+
+void HandleGameControllerEvent(const SDL_Event& event) {
+    switch (event.type) {
+    case SDL_JOYBUTTONUP: {
+        auto joystick = GetSDLJoystickBySDLID(event.jbutton.which);
+        if (joystick) {
+            joystick->SetButton(event.jbutton.button, false);
+        }
+        break;
+    }
+    case SDL_JOYBUTTONDOWN: {
+        auto joystick = GetSDLJoystickBySDLID(event.jbutton.which);
+        if (joystick) {
+            joystick->SetButton(event.jbutton.button, true);
+        }
+        break;
+    }
+    case SDL_JOYHATMOTION: {
+        auto joystick = GetSDLJoystickBySDLID(event.jhat.which);
+        if (joystick) {
+            joystick->SetHat(event.jhat.hat, event.jhat.value);
+        }
+        break;
+    }
+    case SDL_JOYAXISMOTION: {
+        auto joystick = GetSDLJoystickBySDLID(event.jaxis.which);
+        if (joystick) {
+            joystick->SetAxis(event.jaxis.axis, event.jaxis.value);
+        }
+        break;
+    }
+    case SDL_JOYDEVICEREMOVED:
+        LOG_DEBUG(Input, "Controller removed with Instance_ID {}", event.jdevice.which);
+        CloseJoystick(SDL_JoystickFromInstanceID(event.jdevice.which));
+        break;
+    case SDL_JOYDEVICEADDED:
+        LOG_DEBUG(Input, "Controller connected with device index {}", event.jdevice.which);
+        InitJoystick(event.jdevice.which);
+        break;
+    }
+}
+
+void CloseSDLJoysticks() {
+    std::lock_guard<std::mutex> lock(joystick_map_mutex);
+    joystick_map.clear();
+}
+
+void PollLoop() {
+    if (SDL_Init(SDL_INIT_JOYSTICK) < 0) {
+        LOG_CRITICAL(Input, "SDL_Init(SDL_INIT_JOYSTICK) failed with: {}", SDL_GetError());
+        return;
+    }
+
+    SDL_Event event;
+    while (initialized) {
+        // Wait for 10 ms or until an event happens
+        if (SDL_WaitEventTimeout(&event, 10)) {
+            // Don't handle the event if we are configuring
+            if (!polling) {
+                HandleGameControllerEvent(event);
+            } else {
+                event_queue.Push(event);
+            }
+        }
+    }
+    CloseSDLJoysticks();
+    SDL_QuitSubSystem(SDL_INIT_JOYSTICK);
+}
+
 class SDLButton final : public Input::ButtonDevice {
 public:
     explicit SDLButton(std::shared_ptr<SDLJoystick> joystick_, int button_)
@@ -144,22 +370,14 @@ private:
     int axis_y;
 };
 
-static std::shared_ptr<SDLJoystick> GetJoystick(int joystick_index) {
-    std::shared_ptr<SDLJoystick> joystick = joystick_list[joystick_index].lock();
-    if (!joystick) {
-        joystick = std::make_shared<SDLJoystick>(joystick_index);
-        joystick_list[joystick_index] = joystick;
-    }
-    return joystick;
-}
-
 /// A button device factory that creates button devices from SDL joystick
 class SDLButtonFactory final : public Input::Factory<Input::ButtonDevice> {
 public:
     /**
      * Creates a button device from a joystick button
      * @param params contains parameters for creating the device:
-     *     - "joystick": the index of the joystick to bind
+     *     - "guid": the guid of the joystick to bind
+     *     - "port": the nth joystick of the same type to bind
      *     - "button"(optional): the index of the button to bind
      *     - "hat"(optional): the index of the hat to bind as direction buttons
      *     - "axis"(optional): the index of the axis to bind
@@ -167,12 +385,15 @@ public:
      *         "down", "left" or "right"
      *     - "threshold"(only used for axis): a float value in (-1.0, 1.0) which the button is
      *         triggered if the axis value crosses
-     *     - "direction"(only used for axis): "+" means the button is triggered when the axis value
+     *     - "direction"(only used for axis): "+" means the button is triggered when the axis
-     *         is greater than the threshold; "-" means the button is triggered when the axis value
+     * value is greater than the threshold; "-" means the button is triggered when the axis
-     *         is smaller than the threshold
+     * value is smaller than the threshold
      */
     std::unique_ptr<Input::ButtonDevice> Create(const Common::ParamPackage& params) override {
-        const int joystick_index = params.Get("joystick", 0);
+        const std::string guid = params.Get("guid", "0");
+        const int port = params.Get("port", 0);
+
+        auto joystick = GetSDLJoystickByGUID(guid, port);
 
         if (params.Has("hat")) {
             const int hat = params.Get("hat", 0);
@@ -189,8 +410,9 @@ public:
             } else {
                 direction = 0;
             }
-            return std::make_unique<SDLDirectionButton>(GetJoystick(joystick_index), hat,
+            // This is necessary so accessing GetHat with hat won't crash
-                                                        direction);
+            joystick->SetHat(hat, SDL_HAT_CENTERED);
+            return std::make_unique<SDLDirectionButton>(joystick, hat, direction);
         }
 
         if (params.Has("axis")) {
@@ -206,12 +428,15 @@ public:
                 trigger_if_greater = true;
                 LOG_ERROR(Input, "Unknown direction {}", direction_name);
             }
-            return std::make_unique<SDLAxisButton>(GetJoystick(joystick_index), axis, threshold,
+            // This is necessary so accessing GetAxis with axis won't crash
-                                                   trigger_if_greater);
+            joystick->SetAxis(axis, 0);
+            return std::make_unique<SDLAxisButton>(joystick, axis, threshold, trigger_if_greater);
         }
 
         const int button = params.Get("button", 0);
-        return std::make_unique<SDLButton>(GetJoystick(joystick_index), button);
+        // This is necessary so accessing GetButton with button won't crash
+        joystick->SetButton(button, false);
+        return std::make_unique<SDLButton>(joystick, button);
     }
 };
 
@@ -221,27 +446,32 @@ public:
     /**
      * Creates analog device from joystick axes
      * @param params contains parameters for creating the device:
-     *     - "joystick": the index of the joystick to bind
+     *     - "guid": the guid of the joystick to bind
+     *     - "port": the nth joystick of the same type
      *     - "axis_x": the index of the axis to be bind as x-axis
      *     - "axis_y": the index of the axis to be bind as y-axis
      */
     std::unique_ptr<Input::AnalogDevice> Create(const Common::ParamPackage& params) override {
-        const int joystick_index = params.Get("joystick", 0);
+        const std::string guid = params.Get("guid", "0");
+        const int port = params.Get("port", 0);
         const int axis_x = params.Get("axis_x", 0);
         const int axis_y = params.Get("axis_y", 1);
-        return std::make_unique<SDLAnalog>(GetJoystick(joystick_index), axis_x, axis_y);
+
+        auto joystick = GetSDLJoystickByGUID(guid, port);
+
+        // This is necessary so accessing GetAxis with axis_x and axis_y won't crash
+        joystick->SetAxis(axis_x, 0);
+        joystick->SetAxis(axis_y, 0);
+        return std::make_unique<SDLAnalog>(joystick, axis_x, axis_y);
     }
 };
 
 void Init() {
-    if (SDL_Init(SDL_INIT_JOYSTICK) < 0) {
-        LOG_CRITICAL(Input, "SDL_Init(SDL_INIT_JOYSTICK) failed with: {}", SDL_GetError());
-    } else {
     using namespace Input;
     RegisterFactory<ButtonDevice>("sdl", std::make_shared<SDLButtonFactory>());
     RegisterFactory<AnalogDevice>("sdl", std::make_shared<SDLAnalogFactory>());
+    polling = false;
     initialized = true;
-    }
 }
 
 void Shutdown() {
@@ -249,30 +479,17 @@ void Shutdown() {
         using namespace Input;
         UnregisterFactory<ButtonDevice>("sdl");
         UnregisterFactory<AnalogDevice>("sdl");
-        SDL_QuitSubSystem(SDL_INIT_JOYSTICK);
+        initialized = false;
     }
 }
 
-/**
- * This function converts a joystick ID used in SDL events to the device index. This is necessary
- * because Citra opens joysticks using their indices, not their IDs.
- */
-static int JoystickIDToDeviceIndex(SDL_JoystickID id) {
-    int num_joysticks = SDL_NumJoysticks();
-    for (int i = 0; i < num_joysticks; i++) {
-        auto joystick = GetJoystick(i);
-        if (joystick->GetJoystickID() == id) {
-            return i;
-        }
-    }
-    return -1;
-}
-
 Common::ParamPackage SDLEventToButtonParamPackage(const SDL_Event& event) {
     Common::ParamPackage params({{"engine", "sdl"}});
     switch (event.type) {
-    case SDL_JOYAXISMOTION:
+    case SDL_JOYAXISMOTION: {
-        params.Set("joystick", JoystickIDToDeviceIndex(event.jaxis.which));
+        auto joystick = GetSDLJoystickBySDLID(event.jaxis.which);
+        params.Set("port", joystick->GetPort());
+        params.Set("guid", joystick->GetGUID());
         params.Set("axis", event.jaxis.axis);
         if (event.jaxis.value > 0) {
             params.Set("direction", "+");
@@ -282,12 +499,18 @@ Common::ParamPackage SDLEventToButtonParamPackage(const SDL_Event& event) {
             params.Set("threshold", "-0.5");
         }
         break;
-    case SDL_JOYBUTTONUP:
+    }
-        params.Set("joystick", JoystickIDToDeviceIndex(event.jbutton.which));
+    case SDL_JOYBUTTONUP: {
+        auto joystick = GetSDLJoystickBySDLID(event.jbutton.which);
+        params.Set("port", joystick->GetPort());
+        params.Set("guid", joystick->GetGUID());
         params.Set("button", event.jbutton.button);
         break;
-    case SDL_JOYHATMOTION:
+    }
-        params.Set("joystick", JoystickIDToDeviceIndex(event.jhat.which));
+    case SDL_JOYHATMOTION: {
+        auto joystick = GetSDLJoystickBySDLID(event.jhat.which);
+        params.Set("port", joystick->GetPort());
+        params.Set("guid", joystick->GetGUID());
         params.Set("hat", event.jhat.hat);
         switch (event.jhat.value) {
         case SDL_HAT_UP:
@@ -307,6 +530,7 @@ Common::ParamPackage SDLEventToButtonParamPackage(const SDL_Event& event) {
         }
         break;
     }
+    }
     return params;
 }
 
@@ -315,31 +539,20 @@ namespace Polling {
 class SDLPoller : public InputCommon::Polling::DevicePoller {
 public:
     void Start() override {
-        // SDL joysticks must be opened, otherwise they don't generate events
+        event_queue.Clear();
-        SDL_JoystickUpdate();
+        polling = true;
-        int num_joysticks = SDL_NumJoysticks();
-        for (int i = 0; i < num_joysticks; i++) {
-            joysticks_opened.emplace_back(GetJoystick(i));
-        }
-        // Empty event queue to get rid of old events. citra-qt doesn't use the queue
-        SDL_Event dummy;
-        while (SDL_PollEvent(&dummy)) {
-        }
     }
 
     void Stop() override {
-        joysticks_opened.clear();
+        polling = false;
     }
-
-private:
-    std::vector<std::shared_ptr<SDLJoystick>> joysticks_opened;
 };
 
 class SDLButtonPoller final : public SDLPoller {
 public:
     Common::ParamPackage GetNextInput() override {
         SDL_Event event;
-        while (SDL_PollEvent(&event)) {
+        while (event_queue.Pop(event)) {
             switch (event.type) {
             case SDL_JOYAXISMOTION:
                 if (std::abs(event.jaxis.value / 32767.0) < 0.5) {
@@ -367,7 +580,7 @@ public:
 
     Common::ParamPackage GetNextInput() override {
         SDL_Event event;
-        while (SDL_PollEvent(&event)) {
+        while (event_queue.Pop(event)) {
             if (event.type != SDL_JOYAXISMOTION || std::abs(event.jaxis.value / 32767.0) < 0.5) {
                 continue;
             }
@@ -384,8 +597,10 @@ public:
         }
         Common::ParamPackage params;
         if (analog_xaxis != -1 && analog_yaxis != -1) {
+            auto joystick = GetSDLJoystickBySDLID(event.jaxis.which);
             params.Set("engine", "sdl");
-            params.Set("joystick", JoystickIDToDeviceIndex(analog_axes_joystick));
+            params.Set("port", joystick->GetPort());
+            params.Set("guid", joystick->GetGUID());
             params.Set("axis_x", analog_xaxis);
             params.Set("axis_y", analog_yaxis);
             analog_xaxis = -1;

src/input_common/sdl/sdl.h

@@ -28,6 +28,15 @@ void Init();
 /// Unresisters SDL device factories and shut them down.
 void Shutdown();
 
+/// Needs to be called before SDL_QuitSubSystem.
+void CloseSDLJoysticks();
+
+/// Handle SDL_Events for joysticks from SDL_PollEvent
+void HandleGameControllerEvent(const SDL_Event& event);
+
+/// A Loop that calls HandleGameControllerEvent until Shutdown is called
+void PollLoop();
+
 /// Creates a ParamPackage from an SDL_Event that can directly be used to create a ButtonDevice
 Common::ParamPackage SDLEventToButtonParamPackage(const SDL_Event& event);