Adding upstream version 2:20.4+dfsg.upstream/2%20.4+dfsg

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

75 files changed, 7258 insertions, 0 deletions

diff --git a/xbmc/games/controllers/CMakeLists.txt b/xbmc/games/controllers/CMakeLists.txt
new file mode 100644
index 0000000..b54f5c0
--- /dev/null
+++ b/xbmc/games/controllers/CMakeLists.txt
@@ -0,0 +1,18 @@
+set(SOURCES Controller.cpp
+            ControllerLayout.cpp
+            ControllerManager.cpp
+            ControllerTranslator.cpp
+            DefaultController.cpp
+)
+
+set(HEADERS Controller.h
+            ControllerDefinitions.h
+            ControllerIDs.h
+            ControllerLayout.h
+            ControllerManager.h
+            ControllerTranslator.h
+            ControllerTypes.h
+            DefaultController.h
+)
+
+core_add_library(games_controller)
diff --git a/xbmc/games/controllers/Controller.cpp b/xbmc/games/controllers/Controller.cpp
new file mode 100644
index 0000000..e51af4e
--- /dev/null
+++ b/xbmc/games/controllers/Controller.cpp
@@ -0,0 +1,157 @@
+/*
+ *  Copyright (C) 2015-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#include "Controller.h"
+
+#include "ControllerDefinitions.h"
+#include "ControllerLayout.h"
+#include "URL.h"
+#include "addons/addoninfo/AddonType.h"
+#include "games/controllers/input/PhysicalTopology.h"
+#include "utils/XBMCTinyXML.h"
+#include "utils/XMLUtils.h"
+#include "utils/log.h"
+
+#include <algorithm>
+
+using namespace KODI;
+using namespace GAME;
+
+// --- FeatureTypeEqual --------------------------------------------------------
+
+struct FeatureTypeEqual
+{
+  FeatureTypeEqual(FEATURE_TYPE type, JOYSTICK::INPUT_TYPE inputType)
+    : type(type), inputType(inputType)
+  {
+  }
+
+  bool operator()(const CPhysicalFeature& feature) const
+  {
+    if (type == FEATURE_TYPE::UNKNOWN)
+      return true; // Match all feature types
+
+    if (type == FEATURE_TYPE::SCALAR && feature.Type() == FEATURE_TYPE::SCALAR)
+    {
+      if (inputType == JOYSTICK::INPUT_TYPE::UNKNOWN)
+        return true; // Match all input types
+
+      return inputType == feature.InputType();
+    }
+
+    return type == feature.Type();
+  }
+
+  const FEATURE_TYPE type;
+  const JOYSTICK::INPUT_TYPE inputType;
+};
+
+// --- CController -------------------------------------------------------------
+
+const ControllerPtr CController::EmptyPtr;
+
+CController::CController(const ADDON::AddonInfoPtr& addonInfo)
+  : CAddon(addonInfo, ADDON::AddonType::GAME_CONTROLLER), m_layout(new CControllerLayout)
+{
+}
+
+CController::~CController() = default;
+
+const CPhysicalFeature& CController::GetFeature(const std::string& name) const
+{
+  auto it =
+      std::find_if(m_features.begin(), m_features.end(),
+                   [&name](const CPhysicalFeature& feature) { return name == feature.Name(); });
+
+  if (it != m_features.end())
+    return *it;
+
+  static const CPhysicalFeature invalid{};
+  return invalid;
+}
+
+unsigned int CController::FeatureCount(
+    FEATURE_TYPE type /* = FEATURE_TYPE::UNKNOWN */,
+    JOYSTICK::INPUT_TYPE inputType /* = JOYSTICK::INPUT_TYPE::UNKNOWN */) const
+{
+  auto featureCount =
+      std::count_if(m_features.begin(), m_features.end(), FeatureTypeEqual(type, inputType));
+  return static_cast<unsigned int>(featureCount);
+}
+
+void CController::GetFeatures(std::vector<std::string>& features,
+                              FEATURE_TYPE type /* = FEATURE_TYPE::UNKNOWN */) const
+{
+  for (const CPhysicalFeature& feature : m_features)
+  {
+    if (type == FEATURE_TYPE::UNKNOWN || type == feature.Type())
+      features.push_back(feature.Name());
+  }
+}
+
+JOYSTICK::FEATURE_TYPE CController::FeatureType(const std::string& feature) const
+{
+  for (auto it = m_features.begin(); it != m_features.end(); ++it)
+  {
+    if (feature == it->Name())
+      return it->Type();
+  }
+  return JOYSTICK::FEATURE_TYPE::UNKNOWN;
+}
+
+JOYSTICK::INPUT_TYPE CController::GetInputType(const std::string& feature) const
+{
+  for (auto it = m_features.begin(); it != m_features.end(); ++it)
+  {
+    if (feature == it->Name())
+      return it->InputType();
+  }
+  return JOYSTICK::INPUT_TYPE::UNKNOWN;
+}
+
+bool CController::LoadLayout(void)
+{
+  if (!m_bLoaded)
+  {
+    std::string strLayoutXmlPath = LibPath();
+
+    CLog::Log(LOGINFO, "Loading controller layout: {}", CURL::GetRedacted(strLayoutXmlPath));
+
+    CXBMCTinyXML xmlDoc;
+    if (!xmlDoc.LoadFile(strLayoutXmlPath))
+    {
+      CLog::Log(LOGDEBUG, "Unable to load file: {} at line {}", xmlDoc.ErrorDesc(),
+                xmlDoc.ErrorRow());
+      return false;
+    }
+
+    TiXmlElement* pRootElement = xmlDoc.RootElement();
+    if (!pRootElement || pRootElement->NoChildren() || pRootElement->ValueStr() != LAYOUT_XML_ROOT)
+    {
+      CLog::Log(LOGERROR, "Can't find root <{}> tag", LAYOUT_XML_ROOT);
+      return false;
+    }
+
+    m_layout->Deserialize(pRootElement, this, m_features);
+    if (m_layout->IsValid(true))
+    {
+      m_bLoaded = true;
+    }
+    else
+    {
+      m_layout->Reset();
+    }
+  }
+
+  return m_bLoaded;
+}
+
+const CPhysicalTopology& CController::Topology() const
+{
+  return m_layout->Topology();
+}
diff --git a/xbmc/games/controllers/Controller.h b/xbmc/games/controllers/Controller.h
new file mode 100644
index 0000000..2dd7c18
--- /dev/null
+++ b/xbmc/games/controllers/Controller.h
@@ -0,0 +1,120 @@
+/*
+ *  Copyright (C) 2015-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#pragma once
+
+#include "ControllerTypes.h"
+#include "addons/Addon.h"
+#include "games/controllers/input/PhysicalFeature.h"
+#include "input/joysticks/JoystickTypes.h"
+
+#include <map>
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace KODI
+{
+namespace GAME
+{
+class CControllerLayout;
+class CPhysicalTopology;
+
+using JOYSTICK::FEATURE_TYPE;
+
+class CController : public ADDON::CAddon
+{
+public:
+  explicit CController(const ADDON::AddonInfoPtr& addonInfo);
+
+  ~CController() override;
+
+  static const ControllerPtr EmptyPtr;
+
+  /*!
+   * \brief Get all controller features
+   *
+   * \return The features
+   */
+  const std::vector<CPhysicalFeature>& Features(void) const { return m_features; }
+
+  /*!
+   * \brief Get a feature by its name
+   *
+   * \param name The feature name
+   *
+   * \return The feature, or a feature of type FEATURE_TYPE::UNKNOWN if the name is invalid
+   */
+  const CPhysicalFeature& GetFeature(const std::string& name) const;
+
+  /*!
+   * \brief Get the count of controller features matching the specified types
+   *
+   * \param type The feature type, or FEATURE_TYPE::UNKNOWN to match all feature types
+   * \param inputType The input type, or INPUT_TYPE::UNKNOWN to match all input types
+   *
+   * \return The feature count
+   */
+  unsigned int FeatureCount(FEATURE_TYPE type = FEATURE_TYPE::UNKNOWN,
+                            JOYSTICK::INPUT_TYPE inputType = JOYSTICK::INPUT_TYPE::UNKNOWN) const;
+
+  /*!
+   * \brief Get the features matching the specified type
+   *
+   * \param type The feature type, or FEATURE_TYPE::UNKNOWN to get all features
+   */
+  void GetFeatures(std::vector<std::string>& features,
+                   FEATURE_TYPE type = FEATURE_TYPE::UNKNOWN) const;
+
+  /*!
+   * \brief Get the type of the specified feature
+   *
+   * \param feature The feature name to look up
+   *
+   * \return The feature type, or FEATURE_TYPE::UNKNOWN if an invalid feature was specified
+   */
+  FEATURE_TYPE FeatureType(const std::string& feature) const;
+
+  /*!
+   * \brief Get the input type of the specified feature
+   *
+   * \param feature The feature name to look up
+   *
+   * \return The input type of the feature, or INPUT_TYPE::UNKNOWN if unknown
+   */
+  JOYSTICK::INPUT_TYPE GetInputType(const std::string& feature) const;
+
+  /*!
+   * \brief Load the controller layout
+   *
+   * \return true if the layout is loaded or was already loaded, false otherwise
+   */
+  bool LoadLayout(void);
+
+  /*!
+   * \brief Get the controller layout
+   */
+  const CControllerLayout& Layout(void) const { return *m_layout; }
+
+  /*!
+   * \brief Get the controller's physical topology
+   *
+   * This defines how controllers physically connect to each other.
+   *
+   * \return The physical topology of the controller
+   */
+  const CPhysicalTopology& Topology() const;
+
+private:
+  std::unique_ptr<CControllerLayout> m_layout;
+  std::vector<CPhysicalFeature> m_features;
+  bool m_bLoaded = false;
+};
+
+} // namespace GAME
+} // namespace KODI
diff --git a/xbmc/games/controllers/ControllerDefinitions.h b/xbmc/games/controllers/ControllerDefinitions.h
new file mode 100644
index 0000000..517eb50
--- /dev/null
+++ b/xbmc/games/controllers/ControllerDefinitions.h
@@ -0,0 +1,55 @@
+/*
+ *  Copyright (C) 2015-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#pragma once
+
+// XML definitions
+#define LAYOUT_XML_ROOT "layout"
+#define LAYOUT_XML_ELM_CATEGORY "category"
+#define LAYOUT_XML_ELM_BUTTON "button"
+#define LAYOUT_XML_ELM_ANALOG_STICK "analogstick"
+#define LAYOUT_XML_ELM_ACCELEROMETER "accelerometer"
+#define LAYOUT_XML_ELM_MOTOR "motor"
+#define LAYOUT_XML_ELM_RELPOINTER "relpointer"
+#define LAYOUT_XML_ELM_ABSPOINTER "abspointer"
+#define LAYOUT_XML_ELM_WHEEL "wheel"
+#define LAYOUT_XML_ELM_THROTTLE "throttle"
+#define LAYOUT_XML_ELM_KEY "key"
+#define LAYOUT_XML_ELM_TOPOLOGY "physicaltopology"
+#define LAYOUT_XML_ELM_PORT "port"
+#define LAYOUT_XML_ELM_ACCEPTS "accepts"
+#define LAYOUT_XML_ATTR_LAYOUT_LABEL "label"
+#define LAYOUT_XML_ATTR_LAYOUT_ICON "icon"
+#define LAYOUT_XML_ATTR_LAYOUT_IMAGE "image"
+#define LAYOUT_XML_ATTR_CATEGORY_NAME "name"
+#define LAYOUT_XML_ATTR_CATEGORY_LABEL "label"
+#define LAYOUT_XML_ATTR_FEATURE_NAME "name"
+#define LAYOUT_XML_ATTR_FEATURE_LABEL "label"
+#define LAYOUT_XML_ATTR_INPUT_TYPE "type"
+#define LAYOUT_XML_ATTR_KEY_SYMBOL "symbol"
+#define LAYOUT_XML_ATTR_PROVIDES_INPUT "providesinput"
+#define LAYOUT_XML_ATTR_PORT_ID "id"
+#define LAYOUT_XML_ATTR_CONTROLLER "controller"
+
+// Controller definitions
+#define FEATURE_CATEGORY_FACE "face"
+#define FEATURE_CATEGORY_SHOULDER "shoulder"
+#define FEATURE_CATEGORY_TRIGGER "triggers"
+#define FEATURE_CATEGORY_ANALOG_STICK "analogsticks"
+#define FEATURE_CATEGORY_ACCELEROMETER "accelerometer"
+#define FEATURE_CATEGORY_HAPTICS "haptics"
+#define FEATURE_CATEGORY_MOUSE_BUTTON "mouse"
+#define FEATURE_CATEGORY_POINTER "pointer"
+#define FEATURE_CATEGORY_LIGHTGUN "lightgun"
+#define FEATURE_CATEGORY_OFFSCREEN "offscreen"
+#define FEATURE_CATEGORY_KEY "keys"
+#define FEATURE_CATEGORY_KEYPAD "keypad"
+#define FEATURE_CATEGORY_HARDWARE "hardware"
+#define FEATURE_CATEGORY_WHEEL "wheel"
+#define FEATURE_CATEGORY_JOYSTICK "joysticks"
+#define FEATURE_CATEGORY_PADDLE "paddles"
diff --git a/xbmc/games/controllers/ControllerIDs.h b/xbmc/games/controllers/ControllerIDs.h
new file mode 100644
index 0000000..a9254e0
--- /dev/null
+++ b/xbmc/games/controllers/ControllerIDs.h
@@ -0,0 +1,15 @@
+/*
+ *  Copyright (C) 2017-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#pragma once
+
+// Default controller IDs
+#define DEFAULT_CONTROLLER_ID "game.controller.default"
+#define DEFAULT_KEYBOARD_ID "game.controller.keyboard"
+#define DEFAULT_MOUSE_ID "game.controller.mouse"
+#define DEFAULT_REMOTE_ID "game.controller.remote"
diff --git a/xbmc/games/controllers/ControllerLayout.cpp b/xbmc/games/controllers/ControllerLayout.cpp
new file mode 100644
index 0000000..85816c1
--- /dev/null
+++ b/xbmc/games/controllers/ControllerLayout.cpp
@@ -0,0 +1,159 @@
+/*
+ *  Copyright (C) 2015-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#include "ControllerLayout.h"
+
+#include "Controller.h"
+#include "ControllerDefinitions.h"
+#include "ControllerTranslator.h"
+#include "games/controllers/input/PhysicalTopology.h"
+#include "guilib/LocalizeStrings.h"
+#include "utils/URIUtils.h"
+#include "utils/XMLUtils.h"
+#include "utils/log.h"
+
+#include <sstream>
+
+using namespace KODI;
+using namespace GAME;
+
+CControllerLayout::CControllerLayout() : m_topology(new CPhysicalTopology)
+{
+}
+
+CControllerLayout::CControllerLayout(const CControllerLayout& other)
+  : m_controller(other.m_controller),
+    m_labelId(other.m_labelId),
+    m_icon(other.m_icon),
+    m_strImage(other.m_strImage),
+    m_topology(new CPhysicalTopology(*other.m_topology))
+{
+}
+
+CControllerLayout::~CControllerLayout() = default;
+
+void CControllerLayout::Reset(void)
+{
+  m_controller = nullptr;
+  m_labelId = -1;
+  m_icon.clear();
+  m_strImage.clear();
+  m_topology->Reset();
+}
+
+bool CControllerLayout::IsValid(bool bLog) const
+{
+  if (m_labelId < 0)
+  {
+    if (bLog)
+      CLog::Log(LOGERROR, "<{}> tag has no \"{}\" attribute", LAYOUT_XML_ROOT,
+                LAYOUT_XML_ATTR_LAYOUT_LABEL);
+    return false;
+  }
+
+  if (m_strImage.empty())
+  {
+    if (bLog)
+      CLog::Log(LOGDEBUG, "<{}> tag has no \"{}\" attribute", LAYOUT_XML_ROOT,
+                LAYOUT_XML_ATTR_LAYOUT_IMAGE);
+    return false;
+  }
+
+  return true;
+}
+
+std::string CControllerLayout::Label(void) const
+{
+  std::string label;
+
+  if (m_labelId >= 0 && m_controller != nullptr)
+    label = g_localizeStrings.GetAddonString(m_controller->ID(), m_labelId);
+
+  return label;
+}
+
+std::string CControllerLayout::ImagePath(void) const
+{
+  std::string path;
+
+  if (!m_strImage.empty() && m_controller != nullptr)
+    return URIUtils::AddFileToFolder(URIUtils::GetDirectory(m_controller->LibPath()), m_strImage);
+
+  return path;
+}
+
+void CControllerLayout::Deserialize(const TiXmlElement* pElement,
+                                    const CController* controller,
+                                    std::vector<CPhysicalFeature>& features)
+{
+  if (pElement == nullptr || controller == nullptr)
+    return;
+
+  // Controller (used for string lookup and path translation)
+  m_controller = controller;
+
+  // Label
+  std::string strLabel = XMLUtils::GetAttribute(pElement, LAYOUT_XML_ATTR_LAYOUT_LABEL);
+  if (!strLabel.empty())
+    std::istringstream(strLabel) >> m_labelId;
+
+  // Icon
+  std::string icon = XMLUtils::GetAttribute(pElement, LAYOUT_XML_ATTR_LAYOUT_ICON);
+  if (!icon.empty())
+    m_icon = icon;
+
+  // Fallback icon, use add-on icon
+  if (m_icon.empty())
+    m_icon = controller->Icon();
+
+  // Image
+  std::string image = XMLUtils::GetAttribute(pElement, LAYOUT_XML_ATTR_LAYOUT_IMAGE);
+  if (!image.empty())
+    m_strImage = image;
+
+  for (const TiXmlElement* pChild = pElement->FirstChildElement(); pChild != nullptr;
+       pChild = pChild->NextSiblingElement())
+  {
+    if (pChild->ValueStr() == LAYOUT_XML_ELM_CATEGORY)
+    {
+      // Category
+      std::string strCategory = XMLUtils::GetAttribute(pChild, LAYOUT_XML_ATTR_CATEGORY_NAME);
+      JOYSTICK::FEATURE_CATEGORY category =
+          CControllerTranslator::TranslateFeatureCategory(strCategory);
+
+      // Category label
+      int categoryLabelId = -1;
+
+      std::string strCategoryLabelId =
+          XMLUtils::GetAttribute(pChild, LAYOUT_XML_ATTR_CATEGORY_LABEL);
+      if (!strCategoryLabelId.empty())
+        std::istringstream(strCategoryLabelId) >> categoryLabelId;
+
+      // Features
+      for (const TiXmlElement* pFeature = pChild->FirstChildElement(); pFeature != nullptr;
+           pFeature = pFeature->NextSiblingElement())
+      {
+        CPhysicalFeature feature;
+
+        if (feature.Deserialize(pFeature, controller, category, categoryLabelId))
+          features.push_back(feature);
+      }
+    }
+    else if (pChild->ValueStr() == LAYOUT_XML_ELM_TOPOLOGY)
+    {
+      // Topology
+      CPhysicalTopology topology;
+      if (topology.Deserialize(pChild))
+        *m_topology = std::move(topology);
+    }
+    else
+    {
+      CLog::Log(LOGDEBUG, "Ignoring <{}> tag", pChild->ValueStr());
+    }
+  }
+}
diff --git a/xbmc/games/controllers/ControllerLayout.h b/xbmc/games/controllers/ControllerLayout.h
new file mode 100644
index 0000000..1589837
--- /dev/null
+++ b/xbmc/games/controllers/ControllerLayout.h
@@ -0,0 +1,92 @@
+/*
+ *  Copyright (C) 2015-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#pragma once
+
+#include <memory>
+#include <string>
+#include <vector>
+
+class TiXmlElement;
+
+namespace KODI
+{
+namespace GAME
+{
+class CController;
+class CPhysicalFeature;
+class CPhysicalTopology;
+
+class CControllerLayout
+{
+public:
+  CControllerLayout();
+  CControllerLayout(const CControllerLayout& other);
+  ~CControllerLayout();
+
+  void Reset(void);
+
+  int LabelID(void) const { return m_labelId; }
+  const std::string& Icon(void) const { return m_icon; }
+  const std::string& Image(void) const { return m_strImage; }
+
+  /*!
+   * \brief Ensures the layout was deserialized correctly, and optionally logs if not
+   *
+   * \param bLog If true, output the cause of invalidness to the log
+   *
+   * \return True if the layout is valid and can be used in the GUI, false otherwise
+   */
+  bool IsValid(bool bLog) const;
+
+  /*!
+   * \brief Get the label of the primary layout used when mapping the controller
+   *
+   * \return The label, or empty if unknown
+   */
+  std::string Label(void) const;
+
+  /*!
+   * \brief Get the image path of the primary layout used when mapping the controller
+   *
+   * \return The image path, or empty if unknown
+   */
+  std::string ImagePath(void) const;
+
+  /*!
+   * \brief Get the physical topology of this controller
+   *
+   * The topology of a controller defines its ports and which controllers can
+   * physically be connected to them. Also, the topology defines if the
+   * controller can provide player input, which is false in the case of hubs.
+   *
+   * \return The physical topology of the controller
+   */
+  const CPhysicalTopology& Topology(void) const { return *m_topology; }
+
+  /*!
+   * \brief Deserialize the specified XML element
+   *
+   * \param pLayoutElement The XML element
+   * \param controller The controller, used to obtain read-only properties
+   * \param features The deserialized features, if any
+   */
+  void Deserialize(const TiXmlElement* pLayoutElement,
+                   const CController* controller,
+                   std::vector<CPhysicalFeature>& features);
+
+private:
+  const CController* m_controller = nullptr;
+  int m_labelId = -1;
+  std::string m_icon;
+  std::string m_strImage;
+  std::unique_ptr<CPhysicalTopology> m_topology;
+};
+
+} // namespace GAME
+} // namespace KODI
diff --git a/xbmc/games/controllers/ControllerManager.cpp b/xbmc/games/controllers/ControllerManager.cpp
new file mode 100644
index 0000000..707733b
--- /dev/null
+++ b/xbmc/games/controllers/ControllerManager.cpp
@@ -0,0 +1,122 @@
+/*
+ *  Copyright (C) 2017-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#include "ControllerManager.h"
+
+#include "Controller.h"
+#include "ControllerIDs.h"
+#include "addons/AddonEvents.h"
+#include "addons/AddonManager.h"
+#include "addons/addoninfo/AddonType.h"
+
+#include <mutex>
+
+using namespace KODI;
+using namespace GAME;
+
+CControllerManager::CControllerManager(ADDON::CAddonMgr& addonManager)
+  : m_addonManager(addonManager)
+{
+  m_addonManager.Events().Subscribe(this, &CControllerManager::OnEvent);
+}
+
+CControllerManager::~CControllerManager()
+{
+  m_addonManager.Events().Unsubscribe(this);
+}
+
+ControllerPtr CControllerManager::GetController(const std::string& controllerId)
+{
+  using namespace ADDON;
+
+  std::lock_guard<CCriticalSection> lock(m_mutex);
+
+  ControllerPtr& cachedController = m_cache[controllerId];
+
+  if (!cachedController && m_failedControllers.find(controllerId) == m_failedControllers.end())
+  {
+    AddonPtr addon;
+    if (m_addonManager.GetAddon(controllerId, addon, AddonType::GAME_CONTROLLER,
+                                OnlyEnabled::CHOICE_NO))
+      cachedController = LoadController(addon);
+  }
+
+  return cachedController;
+}
+
+ControllerPtr CControllerManager::GetDefaultController()
+{
+  return GetController(DEFAULT_CONTROLLER_ID);
+}
+
+ControllerPtr CControllerManager::GetDefaultKeyboard()
+{
+  return GetController(DEFAULT_KEYBOARD_ID);
+}
+
+ControllerPtr CControllerManager::GetDefaultMouse()
+{
+  return GetController(DEFAULT_MOUSE_ID);
+}
+
+ControllerVector CControllerManager::GetControllers()
+{
+  using namespace ADDON;
+
+  ControllerVector controllers;
+
+  std::lock_guard<CCriticalSection> lock(m_mutex);
+
+  VECADDONS addons;
+  if (m_addonManager.GetInstalledAddons(addons, AddonType::GAME_CONTROLLER))
+  {
+    for (auto& addon : addons)
+    {
+      ControllerPtr& cachedController = m_cache[addon->ID()];
+      if (!cachedController && m_failedControllers.find(addon->ID()) == m_failedControllers.end())
+        cachedController = LoadController(addon);
+
+      if (cachedController)
+        controllers.emplace_back(cachedController);
+    }
+  }
+
+  return controllers;
+}
+
+void CControllerManager::OnEvent(const ADDON::AddonEvent& event)
+{
+  if (typeid(event) == typeid(ADDON::AddonEvents::Enabled) || // Also called on install
+      typeid(event) == typeid(ADDON::AddonEvents::ReInstalled))
+  {
+    std::lock_guard<CCriticalSection> lock(m_mutex);
+
+    const std::string& addonId = event.addonId;
+
+    // Clear caches for add-on
+    auto it = m_cache.find(addonId);
+    if (it != m_cache.end())
+      m_cache.erase(it);
+
+    auto it2 = m_failedControllers.find(addonId);
+    if (it2 != m_failedControllers.end())
+      m_failedControllers.erase(it2);
+  }
+}
+
+ControllerPtr CControllerManager::LoadController(const ADDON::AddonPtr& addon)
+{
+  ControllerPtr controller = std::static_pointer_cast<CController>(addon);
+  if (!controller->LoadLayout())
+  {
+    m_failedControllers.insert(addon->ID());
+    controller.reset();
+  }
+
+  return controller;
+}
diff --git a/xbmc/games/controllers/ControllerManager.h b/xbmc/games/controllers/ControllerManager.h
new file mode 100644
index 0000000..25ffe0f
--- /dev/null
+++ b/xbmc/games/controllers/ControllerManager.h
@@ -0,0 +1,93 @@
+/*
+ *  Copyright (C) 2017-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#pragma once
+
+#include "ControllerTypes.h"
+#include "addons/IAddon.h"
+#include "threads/CriticalSection.h"
+
+#include <map>
+#include <set>
+#include <string>
+
+namespace ADDON
+{
+struct AddonEvent;
+} // namespace ADDON
+
+namespace KODI
+{
+namespace GAME
+{
+class CControllerManager
+{
+public:
+  CControllerManager(ADDON::CAddonMgr& addonManager);
+  ~CControllerManager();
+
+  /*!
+   * \brief Get a controller
+   *
+   * A cache is used to avoid reloading controllers each time they are
+   * requested.
+   *
+   * \param controllerId The controller's ID
+   *
+   * \return The controller, or empty if the controller isn't installed or
+   *         can't be loaded
+   */
+  ControllerPtr GetController(const std::string& controllerId);
+
+  /*!
+   * \brief Get the default controller
+   *
+   * \return The default controller, or empty if the controller failed to load
+   */
+  ControllerPtr GetDefaultController();
+
+  /*!
+   * \brief Get the default keyboard
+   *
+   * \return The keyboard controller, or empty if the controller failed to load
+   */
+  ControllerPtr GetDefaultKeyboard();
+
+  /*!
+   * \brief Get the default mouse
+   *
+   * \return The mouse controller, or empty if the controller failed to load
+   */
+  ControllerPtr GetDefaultMouse();
+
+  /*!
+   * \brief Get installed controllers
+   *
+   * \return The installed controllers that loaded successfully
+   */
+  ControllerVector GetControllers();
+
+private:
+  // Add-on event handler
+  void OnEvent(const ADDON::AddonEvent& event);
+
+  // Utility functions
+  ControllerPtr LoadController(const ADDON::AddonPtr& addon);
+
+  // Construction parameters
+  ADDON::CAddonMgr& m_addonManager;
+
+  // Controller state
+  std::map<std::string, ControllerPtr> m_cache;
+  std::set<std::string> m_failedControllers; // Controllers that failed to load
+
+  // Synchronization parameters
+  CCriticalSection m_mutex;
+};
+} // namespace GAME
+} // namespace KODI
diff --git a/xbmc/games/controllers/ControllerTranslator.cpp b/xbmc/games/controllers/ControllerTranslator.cpp
new file mode 100644
index 0000000..df8641b
--- /dev/null
+++ b/xbmc/games/controllers/ControllerTranslator.cpp
@@ -0,0 +1,744 @@
+/*
+ *  Copyright (C) 2015-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#include "ControllerTranslator.h"
+
+#include "ControllerDefinitions.h"
+
+using namespace KODI;
+using namespace GAME;
+using namespace JOYSTICK;
+
+const char* CControllerTranslator::TranslateFeatureType(FEATURE_TYPE type)
+{
+  switch (type)
+  {
+    case FEATURE_TYPE::SCALAR:
+      return LAYOUT_XML_ELM_BUTTON;
+    case FEATURE_TYPE::ANALOG_STICK:
+      return LAYOUT_XML_ELM_ANALOG_STICK;
+    case FEATURE_TYPE::ACCELEROMETER:
+      return LAYOUT_XML_ELM_ACCELEROMETER;
+    case FEATURE_TYPE::MOTOR:
+      return LAYOUT_XML_ELM_MOTOR;
+    case FEATURE_TYPE::RELPOINTER:
+      return LAYOUT_XML_ELM_RELPOINTER;
+    case FEATURE_TYPE::ABSPOINTER:
+      return LAYOUT_XML_ELM_ABSPOINTER;
+    case FEATURE_TYPE::WHEEL:
+      return LAYOUT_XML_ELM_WHEEL;
+    case FEATURE_TYPE::THROTTLE:
+      return LAYOUT_XML_ELM_THROTTLE;
+    case FEATURE_TYPE::KEY:
+      return LAYOUT_XML_ELM_KEY;
+    default:
+      break;
+  }
+  return "";
+}
+
+FEATURE_TYPE CControllerTranslator::TranslateFeatureType(const std::string& strType)
+{
+  if (strType == LAYOUT_XML_ELM_BUTTON)
+    return FEATURE_TYPE::SCALAR;
+  if (strType == LAYOUT_XML_ELM_ANALOG_STICK)
+    return FEATURE_TYPE::ANALOG_STICK;
+  if (strType == LAYOUT_XML_ELM_ACCELEROMETER)
+    return FEATURE_TYPE::ACCELEROMETER;
+  if (strType == LAYOUT_XML_ELM_MOTOR)
+    return FEATURE_TYPE::MOTOR;
+  if (strType == LAYOUT_XML_ELM_RELPOINTER)
+    return FEATURE_TYPE::RELPOINTER;
+  if (strType == LAYOUT_XML_ELM_ABSPOINTER)
+    return FEATURE_TYPE::ABSPOINTER;
+  if (strType == LAYOUT_XML_ELM_WHEEL)
+    return FEATURE_TYPE::WHEEL;
+  if (strType == LAYOUT_XML_ELM_THROTTLE)
+    return FEATURE_TYPE::THROTTLE;
+  if (strType == LAYOUT_XML_ELM_KEY)
+    return FEATURE_TYPE::KEY;
+
+  return FEATURE_TYPE::UNKNOWN;
+}
+
+const char* CControllerTranslator::TranslateFeatureCategory(FEATURE_CATEGORY category)
+{
+  switch (category)
+  {
+    case FEATURE_CATEGORY::FACE:
+      return FEATURE_CATEGORY_FACE;
+    case FEATURE_CATEGORY::SHOULDER:
+      return FEATURE_CATEGORY_SHOULDER;
+    case FEATURE_CATEGORY::TRIGGER:
+      return FEATURE_CATEGORY_TRIGGER;
+    case FEATURE_CATEGORY::ANALOG_STICK:
+      return FEATURE_CATEGORY_ANALOG_STICK;
+    case FEATURE_CATEGORY::ACCELEROMETER:
+      return FEATURE_CATEGORY_ACCELEROMETER;
+    case FEATURE_CATEGORY::HAPTICS:
+      return FEATURE_CATEGORY_HAPTICS;
+    case FEATURE_CATEGORY::MOUSE_BUTTON:
+      return FEATURE_CATEGORY_MOUSE_BUTTON;
+    case FEATURE_CATEGORY::POINTER:
+      return FEATURE_CATEGORY_POINTER;
+    case FEATURE_CATEGORY::LIGHTGUN:
+      return FEATURE_CATEGORY_LIGHTGUN;
+    case FEATURE_CATEGORY::OFFSCREEN:
+      return FEATURE_CATEGORY_OFFSCREEN;
+    case FEATURE_CATEGORY::KEY:
+      return FEATURE_CATEGORY_KEY;
+    case FEATURE_CATEGORY::KEYPAD:
+      return FEATURE_CATEGORY_KEYPAD;
+    case FEATURE_CATEGORY::HARDWARE:
+      return FEATURE_CATEGORY_HARDWARE;
+    case FEATURE_CATEGORY::WHEEL:
+      return FEATURE_CATEGORY_WHEEL;
+    case FEATURE_CATEGORY::JOYSTICK:
+      return FEATURE_CATEGORY_JOYSTICK;
+    case FEATURE_CATEGORY::PADDLE:
+      return FEATURE_CATEGORY_PADDLE;
+    default:
+      break;
+  }
+  return "";
+}
+
+FEATURE_CATEGORY CControllerTranslator::TranslateFeatureCategory(const std::string& strCategory)
+{
+  if (strCategory == FEATURE_CATEGORY_FACE)
+    return FEATURE_CATEGORY::FACE;
+  if (strCategory == FEATURE_CATEGORY_SHOULDER)
+    return FEATURE_CATEGORY::SHOULDER;
+  if (strCategory == FEATURE_CATEGORY_TRIGGER)
+    return FEATURE_CATEGORY::TRIGGER;
+  if (strCategory == FEATURE_CATEGORY_ANALOG_STICK)
+    return FEATURE_CATEGORY::ANALOG_STICK;
+  if (strCategory == FEATURE_CATEGORY_ACCELEROMETER)
+    return FEATURE_CATEGORY::ACCELEROMETER;
+  if (strCategory == FEATURE_CATEGORY_HAPTICS)
+    return FEATURE_CATEGORY::HAPTICS;
+  if (strCategory == FEATURE_CATEGORY_MOUSE_BUTTON)
+    return FEATURE_CATEGORY::MOUSE_BUTTON;
+  if (strCategory == FEATURE_CATEGORY_POINTER)
+    return FEATURE_CATEGORY::POINTER;
+  if (strCategory == FEATURE_CATEGORY_LIGHTGUN)
+    return FEATURE_CATEGORY::LIGHTGUN;
+  if (strCategory == FEATURE_CATEGORY_OFFSCREEN)
+    return FEATURE_CATEGORY::OFFSCREEN;
+  if (strCategory == FEATURE_CATEGORY_KEY)
+    return FEATURE_CATEGORY::KEY;
+  if (strCategory == FEATURE_CATEGORY_KEYPAD)
+    return FEATURE_CATEGORY::KEYPAD;
+  if (strCategory == FEATURE_CATEGORY_HARDWARE)
+    return FEATURE_CATEGORY::HARDWARE;
+  if (strCategory == FEATURE_CATEGORY_WHEEL)
+    return FEATURE_CATEGORY::WHEEL;
+  if (strCategory == FEATURE_CATEGORY_JOYSTICK)
+    return FEATURE_CATEGORY::JOYSTICK;
+  if (strCategory == FEATURE_CATEGORY_PADDLE)
+    return FEATURE_CATEGORY::PADDLE;
+
+  return FEATURE_CATEGORY::UNKNOWN;
+}
+
+const char* CControllerTranslator::TranslateInputType(INPUT_TYPE type)
+{
+  switch (type)
+  {
+    case INPUT_TYPE::DIGITAL:
+      return "digital";
+    case INPUT_TYPE::ANALOG:
+      return "analog";
+    default:
+      break;
+  }
+  return "";
+}
+
+INPUT_TYPE CControllerTranslator::TranslateInputType(const std::string& strType)
+{
+  if (strType == "digital")
+    return INPUT_TYPE::DIGITAL;
+  if (strType == "analog")
+    return INPUT_TYPE::ANALOG;
+
+  return INPUT_TYPE::UNKNOWN;
+}
+
+KEYBOARD::KeySymbol CControllerTranslator::TranslateKeysym(const std::string& symbol)
+{
+  if (symbol == "backspace")
+    return XBMCK_BACKSPACE;
+  if (symbol == "tab")
+    return XBMCK_TAB;
+  if (symbol == "clear")
+    return XBMCK_CLEAR;
+  if (symbol == "enter")
+    return XBMCK_RETURN;
+  if (symbol == "pause")
+    return XBMCK_PAUSE;
+  if (symbol == "escape")
+    return XBMCK_ESCAPE;
+  if (symbol == "space")
+    return XBMCK_SPACE;
+  if (symbol == "exclaim")
+    return XBMCK_EXCLAIM;
+  if (symbol == "doublequote")
+    return XBMCK_QUOTEDBL;
+  if (symbol == "hash")
+    return XBMCK_HASH;
+  if (symbol == "dollar")
+    return XBMCK_DOLLAR;
+  if (symbol == "ampersand")
+    return XBMCK_AMPERSAND;
+  if (symbol == "quote")
+    return XBMCK_QUOTE;
+  if (symbol == "leftparen")
+    return XBMCK_LEFTPAREN;
+  if (symbol == "rightparen")
+    return XBMCK_RIGHTPAREN;
+  if (symbol == "asterisk")
+    return XBMCK_ASTERISK;
+  if (symbol == "plus")
+    return XBMCK_PLUS;
+  if (symbol == "comma")
+    return XBMCK_COMMA;
+  if (symbol == "minus")
+    return XBMCK_MINUS;
+  if (symbol == "period")
+    return XBMCK_PERIOD;
+  if (symbol == "slash")
+    return XBMCK_SLASH;
+  if (symbol == "0")
+    return XBMCK_0;
+  if (symbol == "1")
+    return XBMCK_1;
+  if (symbol == "2")
+    return XBMCK_2;
+  if (symbol == "3")
+    return XBMCK_3;
+  if (symbol == "4")
+    return XBMCK_4;
+  if (symbol == "5")
+    return XBMCK_5;
+  if (symbol == "6")
+    return XBMCK_6;
+  if (symbol == "7")
+    return XBMCK_7;
+  if (symbol == "8")
+    return XBMCK_8;
+  if (symbol == "9")
+    return XBMCK_9;
+  if (symbol == "colon")
+    return XBMCK_COLON;
+  if (symbol == "semicolon")
+    return XBMCK_SEMICOLON;
+  if (symbol == "less")
+    return XBMCK_LESS;
+  if (symbol == "equals")
+    return XBMCK_EQUALS;
+  if (symbol == "greater")
+    return XBMCK_GREATER;
+  if (symbol == "question")
+    return XBMCK_QUESTION;
+  if (symbol == "at")
+    return XBMCK_AT;
+  if (symbol == "leftbracket")
+    return XBMCK_LEFTBRACKET;
+  if (symbol == "backslash")
+    return XBMCK_BACKSLASH;
+  if (symbol == "rightbracket")
+    return XBMCK_RIGHTBRACKET;
+  if (symbol == "caret")
+    return XBMCK_CARET;
+  if (symbol == "underscore")
+    return XBMCK_UNDERSCORE;
+  if (symbol == "grave")
+    return XBMCK_BACKQUOTE;
+  if (symbol == "a")
+    return XBMCK_a;
+  if (symbol == "b")
+    return XBMCK_b;
+  if (symbol == "c")
+    return XBMCK_c;
+  if (symbol == "d")
+    return XBMCK_d;
+  if (symbol == "e")
+    return XBMCK_e;
+  if (symbol == "f")
+    return XBMCK_f;
+  if (symbol == "g")
+    return XBMCK_g;
+  if (symbol == "h")
+    return XBMCK_h;
+  if (symbol == "i")
+    return XBMCK_i;
+  if (symbol == "j")
+    return XBMCK_j;
+  if (symbol == "k")
+    return XBMCK_k;
+  if (symbol == "l")
+    return XBMCK_l;
+  if (symbol == "m")
+    return XBMCK_m;
+  if (symbol == "n")
+    return XBMCK_n;
+  if (symbol == "o")
+    return XBMCK_o;
+  if (symbol == "p")
+    return XBMCK_p;
+  if (symbol == "q")
+    return XBMCK_q;
+  if (symbol == "r")
+    return XBMCK_r;
+  if (symbol == "s")
+    return XBMCK_s;
+  if (symbol == "t")
+    return XBMCK_t;
+  if (symbol == "u")
+    return XBMCK_u;
+  if (symbol == "v")
+    return XBMCK_v;
+  if (symbol == "w")
+    return XBMCK_w;
+  if (symbol == "x")
+    return XBMCK_x;
+  if (symbol == "y")
+    return XBMCK_y;
+  if (symbol == "z")
+    return XBMCK_z;
+  if (symbol == "leftbrace")
+    return XBMCK_LEFTBRACE;
+  if (symbol == "bar")
+    return XBMCK_PIPE;
+  if (symbol == "rightbrace")
+    return XBMCK_RIGHTBRACE;
+  if (symbol == "tilde")
+    return XBMCK_TILDE;
+  if (symbol == "delete")
+    return XBMCK_DELETE;
+  if (symbol == "kp0")
+    return XBMCK_KP0;
+  if (symbol == "kp1")
+    return XBMCK_KP1;
+  if (symbol == "kp2")
+    return XBMCK_KP2;
+  if (symbol == "kp3")
+    return XBMCK_KP3;
+  if (symbol == "kp4")
+    return XBMCK_KP4;
+  if (symbol == "kp5")
+    return XBMCK_KP5;
+  if (symbol == "kp6")
+    return XBMCK_KP6;
+  if (symbol == "kp7")
+    return XBMCK_KP7;
+  if (symbol == "kp8")
+    return XBMCK_KP8;
+  if (symbol == "kp9")
+    return XBMCK_KP9;
+  if (symbol == "kpperiod")
+    return XBMCK_KP_PERIOD;
+  if (symbol == "kpdivide")
+    return XBMCK_KP_DIVIDE;
+  if (symbol == "kpmultiply")
+    return XBMCK_KP_MULTIPLY;
+  if (symbol == "kpminus")
+    return XBMCK_KP_MINUS;
+  if (symbol == "kpplus")
+    return XBMCK_KP_PLUS;
+  if (symbol == "kpenter")
+    return XBMCK_KP_ENTER;
+  if (symbol == "kpequals")
+    return XBMCK_KP_EQUALS;
+  if (symbol == "up")
+    return XBMCK_UP;
+  if (symbol == "down")
+    return XBMCK_DOWN;
+  if (symbol == "right")
+    return XBMCK_RIGHT;
+  if (symbol == "left")
+    return XBMCK_LEFT;
+  if (symbol == "insert")
+    return XBMCK_INSERT;
+  if (symbol == "home")
+    return XBMCK_HOME;
+  if (symbol == "end")
+    return XBMCK_END;
+  if (symbol == "pageup")
+    return XBMCK_PAGEUP;
+  if (symbol == "pagedown")
+    return XBMCK_PAGEDOWN;
+  if (symbol == "f1")
+    return XBMCK_F1;
+  if (symbol == "f2")
+    return XBMCK_F2;
+  if (symbol == "f3")
+    return XBMCK_F3;
+  if (symbol == "f4")
+    return XBMCK_F4;
+  if (symbol == "f5")
+    return XBMCK_F5;
+  if (symbol == "f6")
+    return XBMCK_F6;
+  if (symbol == "f7")
+    return XBMCK_F7;
+  if (symbol == "f8")
+    return XBMCK_F8;
+  if (symbol == "f9")
+    return XBMCK_F9;
+  if (symbol == "f10")
+    return XBMCK_F10;
+  if (symbol == "f11")
+    return XBMCK_F11;
+  if (symbol == "f12")
+    return XBMCK_F12;
+  if (symbol == "f13")
+    return XBMCK_F13;
+  if (symbol == "f14")
+    return XBMCK_F14;
+  if (symbol == "f15")
+    return XBMCK_F15;
+  if (symbol == "numlock")
+    return XBMCK_NUMLOCK;
+  if (symbol == "capslock")
+    return XBMCK_CAPSLOCK;
+  if (symbol == "scrolllock")
+    return XBMCK_SCROLLOCK;
+  if (symbol == "leftshift")
+    return XBMCK_LSHIFT;
+  if (symbol == "rightshift")
+    return XBMCK_RSHIFT;
+  if (symbol == "leftctrl")
+    return XBMCK_LCTRL;
+  if (symbol == "rightctrl")
+    return XBMCK_RCTRL;
+  if (symbol == "leftalt")
+    return XBMCK_LALT;
+  if (symbol == "rightalt")
+    return XBMCK_RALT;
+  if (symbol == "leftmeta")
+    return XBMCK_LMETA;
+  if (symbol == "rightmeta")
+    return XBMCK_RMETA;
+  if (symbol == "leftsuper")
+    return XBMCK_LSUPER;
+  if (symbol == "rightsuper")
+    return XBMCK_RSUPER;
+  if (symbol == "mode")
+    return XBMCK_MODE;
+  if (symbol == "compose")
+    return XBMCK_COMPOSE;
+  if (symbol == "help")
+    return XBMCK_HELP;
+  if (symbol == "printscreen")
+    return XBMCK_PRINT;
+  if (symbol == "sysreq")
+    return XBMCK_SYSREQ;
+  if (symbol == "break")
+    return XBMCK_BREAK;
+  if (symbol == "menu")
+    return XBMCK_MENU;
+  if (symbol == "power")
+    return XBMCK_POWER;
+  if (symbol == "euro")
+    return XBMCK_EURO;
+  if (symbol == "undo")
+    return XBMCK_UNDO;
+
+  return XBMCK_UNKNOWN;
+}
+
+const char* CControllerTranslator::TranslateKeycode(KEYBOARD::KeySymbol keycode)
+{
+  switch (keycode)
+  {
+    case XBMCK_BACKSPACE:
+      return "backspace";
+    case XBMCK_TAB:
+      return "tab";
+    case XBMCK_CLEAR:
+      return "clear";
+    case XBMCK_RETURN:
+      return "enter";
+    case XBMCK_PAUSE:
+      return "pause";
+    case XBMCK_ESCAPE:
+      return "escape";
+    case XBMCK_SPACE:
+      return "space";
+    case XBMCK_EXCLAIM:
+      return "exclaim";
+    case XBMCK_QUOTEDBL:
+      return "doublequote";
+    case XBMCK_HASH:
+      return "hash";
+    case XBMCK_DOLLAR:
+      return "dollar";
+    case XBMCK_AMPERSAND:
+      return "ampersand";
+    case XBMCK_QUOTE:
+      return "quote";
+    case XBMCK_LEFTPAREN:
+      return "leftparen";
+    case XBMCK_RIGHTPAREN:
+      return "rightparen";
+    case XBMCK_ASTERISK:
+      return "asterisk";
+    case XBMCK_PLUS:
+      return "plus";
+    case XBMCK_COMMA:
+      return "comma";
+    case XBMCK_MINUS:
+      return "minus";
+    case XBMCK_PERIOD:
+      return "period";
+    case XBMCK_SLASH:
+      return "slash";
+    case XBMCK_0:
+      return "0";
+    case XBMCK_1:
+      return "1";
+    case XBMCK_2:
+      return "2";
+    case XBMCK_3:
+      return "3";
+    case XBMCK_4:
+      return "4";
+    case XBMCK_5:
+      return "5";
+    case XBMCK_6:
+      return "6";
+    case XBMCK_7:
+      return "7";
+    case XBMCK_8:
+      return "8";
+    case XBMCK_9:
+      return "9";
+    case XBMCK_COLON:
+      return "colon";
+    case XBMCK_SEMICOLON:
+      return "semicolon";
+    case XBMCK_LESS:
+      return "less";
+    case XBMCK_EQUALS:
+      return "equals";
+    case XBMCK_GREATER:
+      return "greater";
+    case XBMCK_QUESTION:
+      return "question";
+    case XBMCK_AT:
+      return "at";
+    case XBMCK_LEFTBRACKET:
+      return "leftbracket";
+    case XBMCK_BACKSLASH:
+      return "backslash";
+    case XBMCK_RIGHTBRACKET:
+      return "rightbracket";
+    case XBMCK_CARET:
+      return "caret";
+    case XBMCK_UNDERSCORE:
+      return "underscore";
+    case XBMCK_BACKQUOTE:
+      return "grave";
+    case XBMCK_a:
+      return "a";
+    case XBMCK_b:
+      return "b";
+    case XBMCK_c:
+      return "c";
+    case XBMCK_d:
+      return "d";
+    case XBMCK_e:
+      return "e";
+    case XBMCK_f:
+      return "f";
+    case XBMCK_g:
+      return "g";
+    case XBMCK_h:
+      return "h";
+    case XBMCK_i:
+      return "i";
+    case XBMCK_j:
+      return "j";
+    case XBMCK_k:
+      return "k";
+    case XBMCK_l:
+      return "l";
+    case XBMCK_m:
+      return "m";
+    case XBMCK_n:
+      return "n";
+    case XBMCK_o:
+      return "o";
+    case XBMCK_p:
+      return "p";
+    case XBMCK_q:
+      return "q";
+    case XBMCK_r:
+      return "r";
+    case XBMCK_s:
+      return "s";
+    case XBMCK_t:
+      return "t";
+    case XBMCK_u:
+      return "u";
+    case XBMCK_v:
+      return "v";
+    case XBMCK_w:
+      return "w";
+    case XBMCK_x:
+      return "x";
+    case XBMCK_y:
+      return "y";
+    case XBMCK_z:
+      return "z";
+    case XBMCK_LEFTBRACE:
+      return "leftbrace";
+    case XBMCK_PIPE:
+      return "bar";
+    case XBMCK_RIGHTBRACE:
+      return "rightbrace";
+    case XBMCK_TILDE:
+      return "tilde";
+    case XBMCK_DELETE:
+      return "delete";
+    case XBMCK_KP0:
+      return "kp0";
+    case XBMCK_KP1:
+      return "kp1";
+    case XBMCK_KP2:
+      return "kp2";
+    case XBMCK_KP3:
+      return "kp3";
+    case XBMCK_KP4:
+      return "kp4";
+    case XBMCK_KP5:
+      return "kp5";
+    case XBMCK_KP6:
+      return "kp6";
+    case XBMCK_KP7:
+      return "kp7";
+    case XBMCK_KP8:
+      return "kp8";
+    case XBMCK_KP9:
+      return "kp9";
+    case XBMCK_KP_PERIOD:
+      return "kpperiod";
+    case XBMCK_KP_DIVIDE:
+      return "kpdivide";
+    case XBMCK_KP_MULTIPLY:
+      return "kpmultiply";
+    case XBMCK_KP_MINUS:
+      return "kpminus";
+    case XBMCK_KP_PLUS:
+      return "kpplus";
+    case XBMCK_KP_ENTER:
+      return "kpenter";
+    case XBMCK_KP_EQUALS:
+      return "kpequals";
+    case XBMCK_UP:
+      return "up";
+    case XBMCK_DOWN:
+      return "down";
+    case XBMCK_RIGHT:
+      return "right";
+    case XBMCK_LEFT:
+      return "left";
+    case XBMCK_INSERT:
+      return "insert";
+    case XBMCK_HOME:
+      return "home";
+    case XBMCK_END:
+      return "end";
+    case XBMCK_PAGEUP:
+      return "pageup";
+    case XBMCK_PAGEDOWN:
+      return "pagedown";
+    case XBMCK_F1:
+      return "f1";
+    case XBMCK_F2:
+      return "f2";
+    case XBMCK_F3:
+      return "f3";
+    case XBMCK_F4:
+      return "f4";
+    case XBMCK_F5:
+      return "f5";
+    case XBMCK_F6:
+      return "f6";
+    case XBMCK_F7:
+      return "f7";
+    case XBMCK_F8:
+      return "f8";
+    case XBMCK_F9:
+      return "f9";
+    case XBMCK_F10:
+      return "f10";
+    case XBMCK_F11:
+      return "f11";
+    case XBMCK_F12:
+      return "f12";
+    case XBMCK_F13:
+      return "f13";
+    case XBMCK_F14:
+      return "f14";
+    case XBMCK_F15:
+      return "f15";
+    case XBMCK_NUMLOCK:
+      return "numlock";
+    case XBMCK_CAPSLOCK:
+      return "capslock";
+    case XBMCK_SCROLLOCK:
+      return "scrolllock";
+    case XBMCK_LSHIFT:
+      return "leftshift";
+    case XBMCK_RSHIFT:
+      return "rightshift";
+    case XBMCK_LCTRL:
+      return "leftctrl";
+    case XBMCK_RCTRL:
+      return "rightctrl";
+    case XBMCK_LALT:
+      return "leftalt";
+    case XBMCK_RALT:
+      return "rightalt";
+    case XBMCK_LMETA:
+      return "leftmeta";
+    case XBMCK_RMETA:
+      return "rightmeta";
+    case XBMCK_LSUPER:
+      return "leftsuper";
+    case XBMCK_RSUPER:
+      return "rightsuper";
+    case XBMCK_MODE:
+      return "mode";
+    case XBMCK_COMPOSE:
+      return "compose";
+    case XBMCK_HELP:
+      return "help";
+    case XBMCK_PRINT:
+      return "printscreen";
+    case XBMCK_SYSREQ:
+      return "sysreq";
+    case XBMCK_BREAK:
+      return "break";
+    case XBMCK_MENU:
+      return "menu";
+    case XBMCK_POWER:
+      return "power";
+    case XBMCK_EURO:
+      return "euro";
+    case XBMCK_UNDO:
+      return "undo";
+    default:
+      break;
+  }
+
+  return "";
+}
diff --git a/xbmc/games/controllers/ControllerTranslator.h b/xbmc/games/controllers/ControllerTranslator.h
new file mode 100644
index 0000000..0bf4bf1
--- /dev/null
+++ b/xbmc/games/controllers/ControllerTranslator.h
@@ -0,0 +1,53 @@
+/*
+ *  Copyright (C) 2015-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#pragma once
+
+#include "input/joysticks/JoystickTypes.h"
+#include "input/keyboard/KeyboardTypes.h"
+
+#include <string>
+
+namespace KODI
+{
+namespace GAME
+{
+
+class CControllerTranslator
+{
+public:
+  static const char* TranslateFeatureType(JOYSTICK::FEATURE_TYPE type);
+  static JOYSTICK::FEATURE_TYPE TranslateFeatureType(const std::string& strType);
+
+  static const char* TranslateFeatureCategory(JOYSTICK::FEATURE_CATEGORY category);
+  static JOYSTICK::FEATURE_CATEGORY TranslateFeatureCategory(const std::string& strCategory);
+
+  static const char* TranslateInputType(JOYSTICK::INPUT_TYPE type);
+  static JOYSTICK::INPUT_TYPE TranslateInputType(const std::string& strType);
+
+  /*!
+   * \brief Translate a keyboard symbol to a Kodi key code
+   *
+   * \param symbol The key's symbol, defined in the kodi-game-controllers project
+   *
+   * \return The layout-independent keycode associated with the key
+   */
+  static KEYBOARD::KeySymbol TranslateKeysym(const std::string& symbol);
+
+  /*!
+   * \brief Translate a Kodi key code to a keyboard symbol
+   *
+   * \param keycode The Kodi key code
+   *
+   * \return The key's symbol, or an empty string if no symbol is defined for the keycode
+   */
+  static const char* TranslateKeycode(KEYBOARD::KeySymbol keycode);
+};
+
+} // namespace GAME
+} // namespace KODI
diff --git a/xbmc/games/controllers/ControllerTypes.h b/xbmc/games/controllers/ControllerTypes.h
new file mode 100644
index 0000000..838a07d
--- /dev/null
+++ b/xbmc/games/controllers/ControllerTypes.h
@@ -0,0 +1,33 @@
+/*
+ *  Copyright (C) 2015-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#pragma once
+
+#include <memory>
+#include <vector>
+
+namespace KODI
+{
+namespace GAME
+{
+class CController;
+using ControllerPtr = std::shared_ptr<CController>;
+using ControllerVector = std::vector<ControllerPtr>;
+
+/*!
+ * \brief Type of input provided by a hardware or controller port
+ */
+enum class PORT_TYPE
+{
+  UNKNOWN,
+  KEYBOARD,
+  MOUSE,
+  CONTROLLER,
+};
+} // namespace GAME
+} // namespace KODI
diff --git a/xbmc/games/controllers/DefaultController.cpp b/xbmc/games/controllers/DefaultController.cpp
new file mode 100644
index 0000000..58bb464
--- /dev/null
+++ b/xbmc/games/controllers/DefaultController.cpp
@@ -0,0 +1,34 @@
+/*
+ *  Copyright (C) 2024 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#include "DefaultController.h"
+
+using namespace KODI;
+using namespace GAME;
+
+const char* CDefaultController::FEATURE_A = "a";
+const char* CDefaultController::FEATURE_B = "b";
+const char* CDefaultController::FEATURE_X = "x";
+const char* CDefaultController::FEATURE_Y = "y";
+const char* CDefaultController::FEATURE_START = "start";
+const char* CDefaultController::FEATURE_BACK = "back";
+const char* CDefaultController::FEATURE_GUIDE = "guide";
+const char* CDefaultController::FEATURE_UP = "up";
+const char* CDefaultController::FEATURE_RIGHT = "right";
+const char* CDefaultController::FEATURE_DOWN = "down";
+const char* CDefaultController::FEATURE_LEFT = "left";
+const char* CDefaultController::FEATURE_LEFT_THUMB = "leftthumb";
+const char* CDefaultController::FEATURE_RIGHT_THUMB = "rightthumb";
+const char* CDefaultController::FEATURE_LEFT_BUMPER = "leftbumper";
+const char* CDefaultController::FEATURE_RIGHT_BUMPER = "rightbumper";
+const char* CDefaultController::FEATURE_LEFT_TRIGGER = "lefttrigger";
+const char* CDefaultController::FEATURE_RIGHT_TRIGGER = "righttrigger";
+const char* CDefaultController::FEATURE_LEFT_STICK = "leftstick";
+const char* CDefaultController::FEATURE_RIGHT_STICK = "rightstick";
+const char* CDefaultController::FEATURE_LEFT_MOTOR = "leftmotor";
+const char* CDefaultController::FEATURE_RIGHT_MOTOR = "rightmotor";
diff --git a/xbmc/games/controllers/DefaultController.h b/xbmc/games/controllers/DefaultController.h
new file mode 100644
index 0000000..f82ce49
--- /dev/null
+++ b/xbmc/games/controllers/DefaultController.h
@@ -0,0 +1,50 @@
+/*
+ *  Copyright (C) 2024 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#pragma once
+
+namespace KODI
+{
+namespace GAME
+{
+class CDefaultController
+{
+public:
+  // Face buttons
+  static const char* FEATURE_A;
+  static const char* FEATURE_B;
+  static const char* FEATURE_X;
+  static const char* FEATURE_Y;
+  static const char* FEATURE_START;
+  static const char* FEATURE_BACK;
+  static const char* FEATURE_GUIDE;
+  static const char* FEATURE_UP;
+  static const char* FEATURE_RIGHT;
+  static const char* FEATURE_DOWN;
+  static const char* FEATURE_LEFT;
+  static const char* FEATURE_LEFT_THUMB;
+  static const char* FEATURE_RIGHT_THUMB;
+
+  // Shoulder buttons
+  static const char* FEATURE_LEFT_BUMPER;
+  static const char* FEATURE_RIGHT_BUMPER;
+
+  // Triggers
+  static const char* FEATURE_LEFT_TRIGGER;
+  static const char* FEATURE_RIGHT_TRIGGER;
+
+  // Analog sticks
+  static const char* FEATURE_LEFT_STICK;
+  static const char* FEATURE_RIGHT_STICK;
+
+  // Haptics
+  static const char* FEATURE_LEFT_MOTOR;
+  static const char* FEATURE_RIGHT_MOTOR;
+};
+} // namespace GAME
+} // namespace KODI
diff --git a/xbmc/games/controllers/dialogs/CMakeLists.txt b/xbmc/games/controllers/dialogs/CMakeLists.txt
new file mode 100644
index 0000000..e40e60e
--- /dev/null
+++ b/xbmc/games/controllers/dialogs/CMakeLists.txt
@@ -0,0 +1,15 @@
+set(SOURCES ControllerInstaller.cpp
+            ControllerSelect.cpp
+            GUIDialogAxisDetection.cpp
+            GUIDialogButtonCapture.cpp
+            GUIDialogIgnoreInput.cpp
+)
+
+set(HEADERS ControllerInstaller.h
+            ControllerSelect.h
+            GUIDialogAxisDetection.h
+            GUIDialogButtonCapture.h
+            GUIDialogIgnoreInput.h
+)
+
+core_add_library(games_controller_dialogs)
diff --git a/xbmc/games/controllers/dialogs/ControllerInstaller.cpp b/xbmc/games/controllers/dialogs/ControllerInstaller.cpp
new file mode 100644
index 0000000..9b0fe6f
--- /dev/null
+++ b/xbmc/games/controllers/dialogs/ControllerInstaller.cpp
@@ -0,0 +1,138 @@
+/*
+ *  Copyright (C) 2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#include "ControllerInstaller.h"
+
+#include "FileItem.h"
+#include "ServiceBroker.h"
+#include "addons/Addon.h"
+#include "addons/AddonInstaller.h"
+#include "addons/AddonManager.h"
+#include "addons/addoninfo/AddonType.h"
+#include "dialogs/GUIDialogProgress.h"
+#include "dialogs/GUIDialogSelect.h"
+#include "guilib/GUIComponent.h"
+#include "guilib/GUIWindowManager.h"
+#include "guilib/LocalizeStrings.h"
+#include "guilib/WindowIDs.h"
+#include "messaging/helpers/DialogOKHelper.h"
+#include "utils/StringUtils.h"
+#include "utils/log.h"
+
+using namespace KODI;
+using namespace GAME;
+
+CControllerInstaller::CControllerInstaller() : CThread("ControllerInstaller")
+{
+}
+
+void CControllerInstaller::Process()
+{
+  CGUIComponent* gui = CServiceBroker::GetGUI();
+  if (gui == nullptr)
+    return;
+
+  CGUIWindowManager& windowManager = gui->GetWindowManager();
+
+  auto pSelectDialog = windowManager.GetWindow<CGUIDialogSelect>(WINDOW_DIALOG_SELECT);
+  if (pSelectDialog == nullptr)
+    return;
+
+  auto pProgressDialog = windowManager.GetWindow<CGUIDialogProgress>(WINDOW_DIALOG_PROGRESS);
+  if (pProgressDialog == nullptr)
+    return;
+
+  ADDON::VECADDONS installableAddons;
+  CServiceBroker::GetAddonMgr().GetInstallableAddons(installableAddons,
+                                                     ADDON::AddonType::GAME_CONTROLLER);
+  if (installableAddons.empty())
+  {
+    // "Controller profiles"
+    // "All available controller profiles are installed."
+    MESSAGING::HELPERS::ShowOKDialogText(CVariant{35050}, CVariant{35062});
+    return;
+  }
+
+  CLog::Log(LOGDEBUG, "Controller installer: Found {} controller add-ons",
+            installableAddons.size());
+
+  CFileItemList items;
+  for (const auto& addon : installableAddons)
+  {
+    CFileItemPtr item(new CFileItem(addon->Name()));
+    item->SetArt("icon", addon->Icon());
+    items.Add(std::move(item));
+  }
+
+  pSelectDialog->Reset();
+  pSelectDialog->SetHeading(39020); // "The following additional add-ons will be installed"
+  pSelectDialog->SetUseDetails(true);
+  pSelectDialog->EnableButton(true, 186); // "OK""
+  for (const auto& it : items)
+    pSelectDialog->Add(*it);
+  pSelectDialog->Open();
+
+  if (!pSelectDialog->IsButtonPressed())
+  {
+    CLog::Log(LOGDEBUG, "Controller installer: User cancelled installation dialog");
+    return;
+  }
+
+  CLog::Log(LOGDEBUG, "Controller installer: Installing {} controller add-ons",
+            installableAddons.size());
+
+  pProgressDialog->SetHeading(CVariant{24086}); // "Installing add-on..."
+  pProgressDialog->SetLine(0, CVariant{""});
+  pProgressDialog->SetLine(1, CVariant{""});
+  pProgressDialog->SetLine(2, CVariant{""});
+
+  pProgressDialog->Open();
+
+  unsigned int installedCount = 0;
+  while (installedCount < installableAddons.size())
+  {
+    const auto& addon = installableAddons[installedCount];
+
+    // Set dialog text
+    const std::string& progressTemplate = g_localizeStrings.Get(24057); // "Installing {0:s}..."
+    const std::string progressText = StringUtils::Format(progressTemplate, addon->Name());
+    pProgressDialog->SetLine(0, CVariant{progressText});
+
+    // Set dialog percentage
+    const unsigned int percentage =
+        100 * (installedCount + 1) / static_cast<unsigned int>(installableAddons.size());
+    pProgressDialog->SetPercentage(percentage);
+
+    if (!ADDON::CAddonInstaller::GetInstance().InstallOrUpdate(
+            addon->ID(), ADDON::BackgroundJob::CHOICE_NO, ADDON::ModalJob::CHOICE_NO))
+    {
+      CLog::Log(LOGERROR, "Controller installer: Failed to install {}", addon->ID());
+      // "Error"
+      // "Failed to install add-on."
+      MESSAGING::HELPERS::ShowOKDialogText(257, 35256);
+      break;
+    }
+
+    if (pProgressDialog->IsCanceled())
+    {
+      CLog::Log(LOGDEBUG, "Controller installer: User cancelled add-on installation");
+      break;
+    }
+
+    if (windowManager.GetActiveWindowOrDialog() != WINDOW_DIALOG_PROGRESS)
+    {
+      CLog::Log(LOGDEBUG, "Controller installer: Progress dialog is hidden, cancelling");
+      break;
+    }
+
+    installedCount++;
+  }
+
+  CLog::Log(LOGDEBUG, "Controller window: Installed {} controller add-ons", installedCount);
+  pProgressDialog->Close();
+}
diff --git a/xbmc/games/controllers/dialogs/ControllerInstaller.h b/xbmc/games/controllers/dialogs/ControllerInstaller.h
new file mode 100644
index 0000000..9863e27
--- /dev/null
+++ b/xbmc/games/controllers/dialogs/ControllerInstaller.h
@@ -0,0 +1,28 @@
+/*
+ *  Copyright (C) 2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#pragma once
+
+#include "threads/Thread.h"
+
+namespace KODI
+{
+namespace GAME
+{
+class CControllerInstaller : public CThread
+{
+public:
+  CControllerInstaller();
+  ~CControllerInstaller() override = default;
+
+protected:
+  // implementation of CThread
+  void Process() override;
+};
+} // namespace GAME
+} // namespace KODI
diff --git a/xbmc/games/controllers/dialogs/ControllerSelect.cpp b/xbmc/games/controllers/dialogs/ControllerSelect.cpp
new file mode 100644
index 0000000..2ef9941
--- /dev/null
+++ b/xbmc/games/controllers/dialogs/ControllerSelect.cpp
@@ -0,0 +1,133 @@
+/*
+ *  Copyright (C) 2021 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#include "ControllerSelect.h"
+
+#include "FileItem.h"
+#include "ServiceBroker.h"
+#include "dialogs/GUIDialogSelect.h"
+#include "games/controllers/Controller.h"
+#include "games/controllers/ControllerLayout.h"
+#include "games/controllers/ControllerTypes.h"
+#include "guilib/GUIComponent.h"
+#include "guilib/GUIWindowManager.h"
+#include "guilib/LocalizeStrings.h"
+#include "guilib/WindowIDs.h"
+#include "utils/Variant.h"
+#include "utils/log.h"
+
+using namespace KODI;
+using namespace GAME;
+
+CControllerSelect::CControllerSelect() : CThread("ControllerSelect")
+{
+}
+
+CControllerSelect::~CControllerSelect() = default;
+
+void CControllerSelect::Initialize(ControllerVector controllers,
+                                   ControllerPtr defaultController,
+                                   bool showDisconnect,
+                                   const std::function<void(ControllerPtr)>& callback)
+{
+  // Validate parameters
+  if (!callback)
+    return;
+
+  // Stop thread and reset state
+  Deinitialize();
+
+  // Initialize state
+  m_controllers = std::move(controllers);
+  m_defaultController = std::move(defaultController);
+  m_showDisconnect = showDisconnect;
+  m_callback = callback;
+
+  // Create thread
+  Create(false);
+}
+
+void CControllerSelect::Deinitialize()
+{
+  // Stop thread
+  StopThread(true);
+
+  // Reset state
+  m_controllers.clear();
+  m_defaultController.reset();
+  m_showDisconnect = true;
+  m_callback = nullptr;
+}
+
+void CControllerSelect::Process()
+{
+  // Select first controller by default
+  unsigned int initialSelected = 0;
+
+  CGUIComponent* gui = CServiceBroker::GetGUI();
+  if (gui == nullptr)
+    return;
+
+  CGUIWindowManager& windowManager = gui->GetWindowManager();
+
+  auto pSelectDialog = windowManager.GetWindow<CGUIDialogSelect>(WINDOW_DIALOG_SELECT);
+  if (pSelectDialog == nullptr)
+    return;
+
+  CLog::Log(LOGDEBUG, "Controller select: Showing dialog for {} controllers", m_controllers.size());
+
+  CFileItemList items;
+  for (const ControllerPtr& controller : m_controllers)
+  {
+    CFileItemPtr item(new CFileItem(controller->Layout().Label()));
+    item->SetArt("icon", controller->Layout().ImagePath());
+    items.Add(std::move(item));
+
+    // Check if a specified controller should be selected by default
+    if (m_defaultController && m_defaultController->ID() == controller->ID())
+      initialSelected = items.Size() - 1;
+  }
+
+  if (m_showDisconnect)
+  {
+    // Add a button to disconnect the port
+    CFileItemPtr item(new CFileItem(g_localizeStrings.Get(13298))); // "Disconnected"
+    item->SetArt("icon", "DefaultAddonNone.png");
+    items.Add(std::move(item));
+
+    // Check if the disconnect button should be selected by default
+    if (!m_defaultController)
+      initialSelected = items.Size() - 1;
+  }
+
+  pSelectDialog->Reset();
+  pSelectDialog->SetHeading(CVariant{35113}); // "Select a Controller"
+  pSelectDialog->SetUseDetails(true);
+  pSelectDialog->EnableButton(false, 186); // "OK""
+  pSelectDialog->SetButtonFocus(false);
+  for (const auto& it : items)
+    pSelectDialog->Add(*it);
+  pSelectDialog->SetSelected(static_cast<int>(initialSelected));
+  pSelectDialog->Open();
+
+  // If the thread was stopped, exit early
+  if (m_bStop)
+    return;
+
+  if (pSelectDialog->IsConfirmed())
+  {
+    ControllerPtr resultController;
+
+    const int selected = pSelectDialog->GetSelectedItem();
+    if (0 <= selected && selected < static_cast<int>(m_controllers.size()))
+      resultController = m_controllers.at(selected);
+
+    // Fire a callback with the result
+    m_callback(resultController);
+  }
+}
diff --git a/xbmc/games/controllers/dialogs/ControllerSelect.h b/xbmc/games/controllers/dialogs/ControllerSelect.h
new file mode 100644
index 0000000..83a1b41
--- /dev/null
+++ b/xbmc/games/controllers/dialogs/ControllerSelect.h
@@ -0,0 +1,44 @@
+/*
+ *  Copyright (C) 2021 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#pragma once
+
+#include "games/controllers/ControllerTypes.h"
+#include "threads/Thread.h"
+
+#include <functional>
+
+namespace KODI
+{
+namespace GAME
+{
+class CControllerSelect : public CThread
+{
+public:
+  CControllerSelect();
+  ~CControllerSelect() override;
+
+  void Initialize(ControllerVector controllers,
+                  ControllerPtr defaultController,
+                  bool showDisconnect,
+                  const std::function<void(ControllerPtr)>& callback);
+  void Deinitialize();
+
+protected:
+  // Implementation of CThread
+  void Process() override;
+
+private:
+  // State parameters
+  ControllerVector m_controllers;
+  ControllerPtr m_defaultController;
+  bool m_showDisconnect = true;
+  std::function<void(ControllerPtr)> m_callback;
+};
+} // namespace GAME
+} // namespace KODI
diff --git a/xbmc/games/controllers/dialogs/GUIDialogAxisDetection.cpp b/xbmc/games/controllers/dialogs/GUIDialogAxisDetection.cpp
new file mode 100644
index 0000000..2052a4c
--- /dev/null
+++ b/xbmc/games/controllers/dialogs/GUIDialogAxisDetection.cpp
@@ -0,0 +1,84 @@
+/*
+ *  Copyright (C) 2017-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#include "GUIDialogAxisDetection.h"
+
+#include "guilib/LocalizeStrings.h"
+#include "input/joysticks/DriverPrimitive.h"
+#include "input/joysticks/JoystickTranslator.h"
+#include "input/joysticks/interfaces/IButtonMap.h"
+#include "utils/StringUtils.h"
+
+#include <algorithm>
+
+using namespace KODI;
+using namespace GAME;
+
+std::string CGUIDialogAxisDetection::GetDialogText()
+{
+  // "Press all analog buttons now to detect them:[CR][CR]%s"
+  const std::string& dialogText = g_localizeStrings.Get(35020);
+
+  std::vector<std::string> primitives;
+
+  for (const auto& axisEntry : m_detectedAxes)
+  {
+    JOYSTICK::CDriverPrimitive axis(axisEntry.second, 0, JOYSTICK::SEMIAXIS_DIRECTION::POSITIVE, 1);
+    primitives.emplace_back(JOYSTICK::CJoystickTranslator::GetPrimitiveName(axis));
+  }
+
+  return StringUtils::Format(dialogText, StringUtils::Join(primitives, " | "));
+}
+
+std::string CGUIDialogAxisDetection::GetDialogHeader()
+{
+  return g_localizeStrings.Get(35058); // "Controller Configuration"
+}
+
+bool CGUIDialogAxisDetection::MapPrimitiveInternal(JOYSTICK::IButtonMap* buttonMap,
+                                                   IKeymap* keymap,
+                                                   const JOYSTICK::CDriverPrimitive& primitive)
+{
+  if (primitive.Type() == JOYSTICK::PRIMITIVE_TYPE::SEMIAXIS)
+    AddAxis(buttonMap->Location(), primitive.Index());
+
+  return true;
+}
+
+bool CGUIDialogAxisDetection::AcceptsPrimitive(JOYSTICK::PRIMITIVE_TYPE type) const
+{
+  switch (type)
+  {
+    case JOYSTICK::PRIMITIVE_TYPE::SEMIAXIS:
+      return true;
+    default:
+      break;
+  }
+
+  return false;
+}
+
+void CGUIDialogAxisDetection::OnLateAxis(const JOYSTICK::IButtonMap* buttonMap,
+                                         unsigned int axisIndex)
+{
+  AddAxis(buttonMap->Location(), axisIndex);
+}
+
+void CGUIDialogAxisDetection::AddAxis(const std::string& deviceLocation, unsigned int axisIndex)
+{
+  auto it = std::find_if(m_detectedAxes.begin(), m_detectedAxes.end(),
+                         [&deviceLocation, axisIndex](const AxisEntry& axis) {
+                           return axis.first == deviceLocation && axis.second == axisIndex;
+                         });
+
+  if (it == m_detectedAxes.end())
+  {
+    m_detectedAxes.emplace_back(std::make_pair(deviceLocation, axisIndex));
+    m_captureEvent.Set();
+  }
+}
diff --git a/xbmc/games/controllers/dialogs/GUIDialogAxisDetection.h b/xbmc/games/controllers/dialogs/GUIDialogAxisDetection.h
new file mode 100644
index 0000000..4ca0d27
--- /dev/null
+++ b/xbmc/games/controllers/dialogs/GUIDialogAxisDetection.h
@@ -0,0 +1,54 @@
+/*
+ *  Copyright (C) 2017-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#pragma once
+
+#include "GUIDialogButtonCapture.h"
+
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace KODI
+{
+namespace GAME
+{
+class CGUIDialogAxisDetection : public CGUIDialogButtonCapture
+{
+public:
+  CGUIDialogAxisDetection() = default;
+
+  ~CGUIDialogAxisDetection() override = default;
+
+  // specialization of IButtonMapper via CGUIDialogButtonCapture
+  bool AcceptsPrimitive(JOYSTICK::PRIMITIVE_TYPE type) const override;
+  void OnLateAxis(const JOYSTICK::IButtonMap* buttonMap, unsigned int axisIndex) override;
+
+protected:
+  // implementation of CGUIDialogButtonCapture
+  std::string GetDialogText() override;
+  std::string GetDialogHeader() override;
+  bool MapPrimitiveInternal(JOYSTICK::IButtonMap* buttonMap,
+                            IKeymap* keymap,
+                            const JOYSTICK::CDriverPrimitive& primitive) override;
+  void OnClose(bool bAccepted) override {}
+
+private:
+  void AddAxis(const std::string& deviceLocation, unsigned int axisIndex);
+
+  // Axis types
+  using DeviceName = std::string;
+  using AxisIndex = unsigned int;
+  using AxisEntry = std::pair<DeviceName, AxisIndex>;
+  using AxisVector = std::vector<AxisEntry>;
+
+  // Axis detection
+  AxisVector m_detectedAxes;
+};
+} // namespace GAME
+} // namespace KODI
diff --git a/xbmc/games/controllers/dialogs/GUIDialogButtonCapture.cpp b/xbmc/games/controllers/dialogs/GUIDialogButtonCapture.cpp
new file mode 100644
index 0000000..9bf8dbc
--- /dev/null
+++ b/xbmc/games/controllers/dialogs/GUIDialogButtonCapture.cpp
@@ -0,0 +1,130 @@
+/*
+ *  Copyright (C) 2016-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#include "GUIDialogButtonCapture.h"
+
+#include "ServiceBroker.h"
+#include "games/controllers/ControllerIDs.h"
+#include "input/IKeymap.h"
+#include "input/actions/ActionIDs.h"
+#include "input/joysticks/JoystickUtils.h"
+#include "input/joysticks/interfaces/IButtonMap.h"
+#include "messaging/helpers/DialogOKHelper.h"
+#include "peripherals/Peripherals.h"
+#include "utils/Variant.h"
+
+#include <algorithm>
+#include <iterator>
+
+using namespace KODI;
+using namespace GAME;
+using namespace KODI::MESSAGING;
+
+CGUIDialogButtonCapture::CGUIDialogButtonCapture() : CThread("ButtonCaptureDlg")
+{
+}
+
+std::string CGUIDialogButtonCapture::ControllerID(void) const
+{
+  return DEFAULT_CONTROLLER_ID;
+}
+
+void CGUIDialogButtonCapture::Show()
+{
+  if (!IsRunning())
+  {
+    InstallHooks();
+
+    Create();
+
+    bool bAccepted =
+        HELPERS::ShowOKDialogText(CVariant{GetDialogHeader()}, CVariant{GetDialogText()});
+
+    StopThread(false);
+
+    m_captureEvent.Set();
+
+    OnClose(bAccepted);
+
+    RemoveHooks();
+  }
+}
+
+void CGUIDialogButtonCapture::Process()
+{
+  while (!m_bStop)
+  {
+    m_captureEvent.Wait();
+
+    if (m_bStop)
+      break;
+
+    //! @todo Move to rendering thread when there is a rendering thread
+    HELPERS::UpdateOKDialogText(CVariant{35013}, CVariant{GetDialogText()});
+  }
+}
+
+bool CGUIDialogButtonCapture::MapPrimitive(JOYSTICK::IButtonMap* buttonMap,
+                                           IKeymap* keymap,
+                                           const JOYSTICK::CDriverPrimitive& primitive)
+{
+  if (m_bStop)
+    return false;
+
+  // First check to see if driver primitive closes the dialog
+  if (keymap && keymap->ControllerID() == buttonMap->ControllerID())
+  {
+    std::string feature;
+    if (buttonMap->GetFeature(primitive, feature))
+    {
+      const auto& actions =
+          keymap->GetActions(JOYSTICK::CJoystickUtils::MakeKeyName(feature)).actions;
+      if (!actions.empty())
+      {
+        switch (actions.begin()->actionId)
+        {
+          case ACTION_SELECT_ITEM:
+          case ACTION_NAV_BACK:
+          case ACTION_PREVIOUS_MENU:
+            return false;
+          default:
+            break;
+        }
+      }
+    }
+  }
+
+  return MapPrimitiveInternal(buttonMap, keymap, primitive);
+}
+
+void CGUIDialogButtonCapture::InstallHooks(void)
+{
+  CServiceBroker::GetPeripherals().RegisterJoystickButtonMapper(this);
+  CServiceBroker::GetPeripherals().RegisterObserver(this);
+}
+
+void CGUIDialogButtonCapture::RemoveHooks(void)
+{
+  CServiceBroker::GetPeripherals().UnregisterObserver(this);
+  CServiceBroker::GetPeripherals().UnregisterJoystickButtonMapper(this);
+}
+
+void CGUIDialogButtonCapture::Notify(const Observable& obs, const ObservableMessage msg)
+{
+  switch (msg)
+  {
+    case ObservableMessagePeripheralsChanged:
+    {
+      CServiceBroker::GetPeripherals().UnregisterJoystickButtonMapper(this);
+      CServiceBroker::GetPeripherals().RegisterJoystickButtonMapper(this);
+      break;
+    }
+    default:
+      break;
+  }
+}
diff --git a/xbmc/games/controllers/dialogs/GUIDialogButtonCapture.h b/xbmc/games/controllers/dialogs/GUIDialogButtonCapture.h
new file mode 100644
index 0000000..97795c6
--- /dev/null
+++ b/xbmc/games/controllers/dialogs/GUIDialogButtonCapture.h
@@ -0,0 +1,65 @@
+/*
+ *  Copyright (C) 2016-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#pragma once
+
+#include "input/joysticks/interfaces/IButtonMapper.h"
+#include "threads/Event.h"
+#include "threads/Thread.h"
+#include "utils/Observer.h"
+
+#include <string>
+#include <vector>
+
+namespace KODI
+{
+namespace GAME
+{
+class CGUIDialogButtonCapture : public JOYSTICK::IButtonMapper, public Observer, protected CThread
+{
+public:
+  CGUIDialogButtonCapture();
+
+  ~CGUIDialogButtonCapture() override = default;
+
+  // implementation of IButtonMapper
+  std::string ControllerID() const override;
+  bool NeedsCooldown() const override { return false; }
+  bool MapPrimitive(JOYSTICK::IButtonMap* buttonMap,
+                    IKeymap* keymap,
+                    const JOYSTICK::CDriverPrimitive& primitive) override;
+  void OnEventFrame(const JOYSTICK::IButtonMap* buttonMap, bool bMotion) override {}
+  void OnLateAxis(const JOYSTICK::IButtonMap* buttonMap, unsigned int axisIndex) override {}
+
+  // implementation of Observer
+  void Notify(const Observable& obs, const ObservableMessage msg) override;
+
+  /*!
+   * \brief Show the dialog
+   */
+  void Show();
+
+protected:
+  // implementation of CThread
+  void Process() override;
+
+  virtual std::string GetDialogText() = 0;
+  virtual std::string GetDialogHeader() = 0;
+  virtual bool MapPrimitiveInternal(JOYSTICK::IButtonMap* buttonMap,
+                                    IKeymap* keymap,
+                                    const JOYSTICK::CDriverPrimitive& primitive) = 0;
+  virtual void OnClose(bool bAccepted) = 0;
+
+  CEvent m_captureEvent;
+
+private:
+  void InstallHooks();
+  void RemoveHooks();
+};
+} // namespace GAME
+} // namespace KODI
diff --git a/xbmc/games/controllers/dialogs/GUIDialogIgnoreInput.cpp b/xbmc/games/controllers/dialogs/GUIDialogIgnoreInput.cpp
new file mode 100644
index 0000000..b5f28d6
--- /dev/null
+++ b/xbmc/games/controllers/dialogs/GUIDialogIgnoreInput.cpp
@@ -0,0 +1,132 @@
+/*
+ *  Copyright (C) 2017-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#include "GUIDialogIgnoreInput.h"
+
+#include "guilib/LocalizeStrings.h"
+#include "input/joysticks/JoystickTranslator.h"
+#include "input/joysticks/interfaces/IButtonMap.h"
+#include "input/joysticks/interfaces/IButtonMapCallback.h"
+#include "utils/StringUtils.h"
+#include "utils/log.h"
+
+#include <algorithm>
+#include <iterator>
+
+using namespace KODI;
+using namespace GAME;
+
+bool CGUIDialogIgnoreInput::AcceptsPrimitive(JOYSTICK::PRIMITIVE_TYPE type) const
+{
+  switch (type)
+  {
+    case JOYSTICK::PRIMITIVE_TYPE::BUTTON:
+    case JOYSTICK::PRIMITIVE_TYPE::SEMIAXIS:
+      return true;
+    default:
+      break;
+  }
+
+  return false;
+}
+
+std::string CGUIDialogIgnoreInput::GetDialogText()
+{
+  // "Some controllers have buttons and axes that interfere with mapping. Press
+  // these now to disable them:[CR]%s"
+  const std::string& dialogText = g_localizeStrings.Get(35014);
+
+  std::vector<std::string> primitives;
+
+  std::transform(m_capturedPrimitives.begin(), m_capturedPrimitives.end(),
+                 std::back_inserter(primitives), [](const JOYSTICK::CDriverPrimitive& primitive) {
+                   return JOYSTICK::CJoystickTranslator::GetPrimitiveName(primitive);
+                 });
+
+  return StringUtils::Format(dialogText, StringUtils::Join(primitives, " | "));
+}
+
+std::string CGUIDialogIgnoreInput::GetDialogHeader()
+{
+
+  return g_localizeStrings.Get(35019); // "Ignore input"
+}
+
+bool CGUIDialogIgnoreInput::MapPrimitiveInternal(JOYSTICK::IButtonMap* buttonMap,
+                                                 IKeymap* keymap,
+                                                 const JOYSTICK::CDriverPrimitive& primitive)
+{
+  // Check if we have already started capturing primitives for a device
+  const bool bHasDevice = !m_location.empty();
+
+  // If a primitive comes from a different device, ignore it
+  if (bHasDevice && m_location != buttonMap->Location())
+  {
+    CLog::Log(LOGDEBUG, "{}: ignoring input from device {}", buttonMap->ControllerID(),
+              buttonMap->Location());
+    return false;
+  }
+
+  if (!bHasDevice)
+  {
+    CLog::Log(LOGDEBUG, "{}: capturing input for device {}", buttonMap->ControllerID(),
+              buttonMap->Location());
+    m_location = buttonMap->Location();
+  }
+
+  if (AddPrimitive(primitive))
+  {
+    buttonMap->SetIgnoredPrimitives(m_capturedPrimitives);
+    m_captureEvent.Set();
+  }
+
+  return true;
+}
+
+void CGUIDialogIgnoreInput::OnClose(bool bAccepted)
+{
+  for (auto& callback : ButtonMapCallbacks())
+  {
+    if (bAccepted)
+    {
+      // See documentation of IButtonMapCallback::ResetIgnoredPrimitives()
+      // for why this call is needed
+      if (m_location.empty())
+        callback.second->ResetIgnoredPrimitives();
+
+      if (m_location.empty() || m_location == callback.first)
+        callback.second->SaveButtonMap();
+    }
+    else
+      callback.second->RevertButtonMap();
+  }
+}
+
+bool CGUIDialogIgnoreInput::AddPrimitive(const JOYSTICK::CDriverPrimitive& primitive)
+{
+  bool bValid = false;
+
+  if (primitive.Type() == JOYSTICK::PRIMITIVE_TYPE::BUTTON ||
+      primitive.Type() == JOYSTICK::PRIMITIVE_TYPE::SEMIAXIS)
+  {
+    auto PrimitiveMatch = [&primitive](const JOYSTICK::CDriverPrimitive& other) {
+      return primitive.Type() == other.Type() && primitive.Index() == other.Index();
+    };
+
+    bValid = std::find_if(m_capturedPrimitives.begin(), m_capturedPrimitives.end(),
+                          PrimitiveMatch) == m_capturedPrimitives.end();
+  }
+
+  if (bValid)
+  {
+    m_capturedPrimitives.emplace_back(primitive);
+    return true;
+  }
+
+  return false;
+}
diff --git a/xbmc/games/controllers/dialogs/GUIDialogIgnoreInput.h b/xbmc/games/controllers/dialogs/GUIDialogIgnoreInput.h
new file mode 100644
index 0000000..e1d3922
--- /dev/null
+++ b/xbmc/games/controllers/dialogs/GUIDialogIgnoreInput.h
@@ -0,0 +1,47 @@
+/*
+ *  Copyright (C) 2017-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#pragma once
+
+#include "GUIDialogButtonCapture.h"
+#include "input/joysticks/DriverPrimitive.h"
+
+#include <string>
+#include <vector>
+
+namespace KODI
+{
+namespace GAME
+{
+class CGUIDialogIgnoreInput : public CGUIDialogButtonCapture
+{
+public:
+  CGUIDialogIgnoreInput() = default;
+
+  ~CGUIDialogIgnoreInput() override = default;
+
+  // specialization of IButtonMapper via CGUIDialogButtonCapture
+  bool AcceptsPrimitive(JOYSTICK::PRIMITIVE_TYPE type) const override;
+
+protected:
+  // implementation of CGUIDialogButtonCapture
+  std::string GetDialogText() override;
+  std::string GetDialogHeader() override;
+  bool MapPrimitiveInternal(JOYSTICK::IButtonMap* buttonMap,
+                            IKeymap* keymap,
+                            const JOYSTICK::CDriverPrimitive& primitive) override;
+  void OnClose(bool bAccepted) override;
+
+private:
+  bool AddPrimitive(const JOYSTICK::CDriverPrimitive& primitive);
+
+  std::string m_location;
+  std::vector<JOYSTICK::CDriverPrimitive> m_capturedPrimitives;
+};
+} // namespace GAME
+} // namespace KODI
diff --git a/xbmc/games/controllers/guicontrols/CMakeLists.txt b/xbmc/games/controllers/guicontrols/CMakeLists.txt
new file mode 100644
index 0000000..e6babcc
--- /dev/null
+++ b/xbmc/games/controllers/guicontrols/CMakeLists.txt
@@ -0,0 +1,28 @@
+set(SOURCES GUICardinalFeatureButton.cpp
+            GUIControllerButton.cpp
+            GUIFeatureButton.cpp
+            GUIFeatureControls.cpp
+            GUIFeatureFactory.cpp
+            GUIFeatureTranslator.cpp
+            GUIGameController.cpp
+            GUIScalarFeatureButton.cpp
+            GUISelectKeyButton.cpp
+            GUIThrottleButton.cpp
+            GUIWheelButton.cpp
+)
+
+set(HEADERS GUICardinalFeatureButton.h
+            GUIControllerButton.h
+            GUIControlTypes.h
+            GUIFeatureButton.h
+            GUIFeatureControls.h
+            GUIFeatureFactory.h
+            GUIFeatureTranslator.h
+            GUIGameController.h
+            GUIScalarFeatureButton.h
+            GUISelectKeyButton.h
+            GUIThrottleButton.h
+            GUIWheelButton.h
+)
+
+core_add_library(games_controller_guicontrols)
diff --git a/xbmc/games/controllers/guicontrols/GUICardinalFeatureButton.cpp b/xbmc/games/controllers/guicontrols/GUICardinalFeatureButton.cpp
new file mode 100644
index 0000000..3c8732c
--- /dev/null
+++ b/xbmc/games/controllers/guicontrols/GUICardinalFeatureButton.cpp
@@ -0,0 +1,100 @@
+/*
+ *  Copyright (C) 2016-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#include "GUICardinalFeatureButton.h"
+
+#include "guilib/LocalizeStrings.h"
+
+#include <string>
+
+using namespace KODI;
+using namespace GAME;
+
+CGUICardinalFeatureButton::CGUICardinalFeatureButton(const CGUIButtonControl& buttonTemplate,
+                                                     IConfigurationWizard* wizard,
+                                                     const CPhysicalFeature& feature,
+                                                     unsigned int index)
+  : CGUIFeatureButton(buttonTemplate, wizard, feature, index)
+{
+  Reset();
+}
+
+bool CGUICardinalFeatureButton::PromptForInput(CEvent& waitEvent)
+{
+  using namespace JOYSTICK;
+
+  bool bInterrupted = false;
+
+  // Get the prompt for the current analog stick direction
+  std::string strPrompt;
+  std::string strWarn;
+  switch (m_state)
+  {
+    case STATE::CARDINAL_DIRECTION_UP:
+      strPrompt = g_localizeStrings.Get(35092); // "Move %s up"
+      strWarn = g_localizeStrings.Get(35093); // "Move %s up (%d)"
+      break;
+    case STATE::CARDINAL_DIRECTION_RIGHT:
+      strPrompt = g_localizeStrings.Get(35096); // "Move %s right"
+      strWarn = g_localizeStrings.Get(35097); // "Move %s right (%d)"
+      break;
+    case STATE::CARDINAL_DIRECTION_DOWN:
+      strPrompt = g_localizeStrings.Get(35094); // "Move %s down"
+      strWarn = g_localizeStrings.Get(35095); // "Move %s down (%d)"
+      break;
+    case STATE::CARDINAL_DIRECTION_LEFT:
+      strPrompt = g_localizeStrings.Get(35098); // "Move %s left"
+      strWarn = g_localizeStrings.Get(35099); // "Move %s left (%d)"
+      break;
+    default:
+      break;
+  }
+
+  if (!strPrompt.empty())
+  {
+    bInterrupted = DoPrompt(strPrompt, strWarn, m_feature.Label(), waitEvent);
+
+    if (!bInterrupted)
+      m_state = STATE::FINISHED; // Not interrupted, must have timed out
+    else
+      m_state = GetNextState(m_state); // Interrupted by input, proceed
+  }
+
+  return bInterrupted;
+}
+
+bool CGUICardinalFeatureButton::IsFinished(void) const
+{
+  return m_state >= STATE::FINISHED;
+}
+
+KODI::INPUT::CARDINAL_DIRECTION CGUICardinalFeatureButton::GetCardinalDirection(void) const
+{
+  using namespace INPUT;
+
+  switch (m_state)
+  {
+    case STATE::CARDINAL_DIRECTION_UP:
+      return CARDINAL_DIRECTION::UP;
+    case STATE::CARDINAL_DIRECTION_RIGHT:
+      return CARDINAL_DIRECTION::RIGHT;
+    case STATE::CARDINAL_DIRECTION_DOWN:
+      return CARDINAL_DIRECTION::DOWN;
+    case STATE::CARDINAL_DIRECTION_LEFT:
+      return CARDINAL_DIRECTION::LEFT;
+    default:
+      break;
+  }
+
+  return CARDINAL_DIRECTION::NONE;
+}
+
+void CGUICardinalFeatureButton::Reset(void)
+{
+  m_state = STATE::CARDINAL_DIRECTION_UP;
+}
diff --git a/xbmc/games/controllers/guicontrols/GUICardinalFeatureButton.h b/xbmc/games/controllers/guicontrols/GUICardinalFeatureButton.h
new file mode 100644
index 0000000..48eb0e8
--- /dev/null
+++ b/xbmc/games/controllers/guicontrols/GUICardinalFeatureButton.h
@@ -0,0 +1,49 @@
+/*
+ *  Copyright (C) 2016-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#pragma once
+
+#include "GUIFeatureButton.h"
+
+namespace KODI
+{
+namespace GAME
+{
+class CGUICardinalFeatureButton : public CGUIFeatureButton
+{
+public:
+  CGUICardinalFeatureButton(const CGUIButtonControl& buttonTemplate,
+                            IConfigurationWizard* wizard,
+                            const CPhysicalFeature& feature,
+                            unsigned int index);
+
+  ~CGUICardinalFeatureButton() override = default;
+
+  // implementation of IFeatureButton
+  bool PromptForInput(CEvent& waitEvent) override;
+  bool IsFinished() const override;
+  INPUT::CARDINAL_DIRECTION GetCardinalDirection() const override;
+  void Reset() override;
+
+private:
+  enum class STATE
+  {
+    CARDINAL_DIRECTION_UP,
+    CARDINAL_DIRECTION_RIGHT,
+    CARDINAL_DIRECTION_DOWN,
+    CARDINAL_DIRECTION_LEFT,
+    FINISHED,
+  };
+
+  STATE m_state;
+};
+
+using CGUIAnalogStickButton = CGUICardinalFeatureButton;
+using CGUIRelativePointerButton = CGUICardinalFeatureButton;
+} // namespace GAME
+} // namespace KODI
diff --git a/xbmc/games/controllers/guicontrols/GUIControlTypes.h b/xbmc/games/controllers/guicontrols/GUIControlTypes.h
new file mode 100644
index 0000000..bf91b6e
--- /dev/null
+++ b/xbmc/games/controllers/guicontrols/GUIControlTypes.h
@@ -0,0 +1,29 @@
+/*
+ *  Copyright (C) 2017-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#pragma once
+
+namespace KODI
+{
+namespace GAME
+{
+/*!
+ * \brief Types of button controls that can populate the feature list
+ */
+enum class BUTTON_TYPE
+{
+  UNKNOWN,
+  BUTTON,
+  ANALOG_STICK,
+  RELATIVE_POINTER,
+  WHEEL,
+  THROTTLE,
+  SELECT_KEY,
+};
+} // namespace GAME
+} // namespace KODI
diff --git a/xbmc/games/controllers/guicontrols/GUIControllerButton.cpp b/xbmc/games/controllers/guicontrols/GUIControllerButton.cpp
new file mode 100644
index 0000000..c8156ce
--- /dev/null
+++ b/xbmc/games/controllers/guicontrols/GUIControllerButton.cpp
@@ -0,0 +1,26 @@
+/*
+ *  Copyright (C) 2014-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#include "GUIControllerButton.h"
+
+#include "games/controllers/windows/GUIControllerDefines.h"
+
+using namespace KODI;
+using namespace GAME;
+
+CGUIControllerButton::CGUIControllerButton(const CGUIButtonControl& buttonControl,
+                                           const std::string& label,
+                                           unsigned int index)
+  : CGUIButtonControl(buttonControl)
+{
+  // Initialize CGUIButtonControl
+  SetLabel(label);
+  SetID(CONTROL_CONTROLLER_BUTTONS_START + index);
+  SetVisible(true);
+  AllocResources();
+}
diff --git a/xbmc/games/controllers/guicontrols/GUIControllerButton.h b/xbmc/games/controllers/guicontrols/GUIControllerButton.h
new file mode 100644
index 0000000..ebdc924
--- /dev/null
+++ b/xbmc/games/controllers/guicontrols/GUIControllerButton.h
@@ -0,0 +1,29 @@
+/*
+ *  Copyright (C) 2016-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#pragma once
+
+#include "guilib/GUIButtonControl.h"
+
+#include <string>
+
+namespace KODI
+{
+namespace GAME
+{
+class CGUIControllerButton : public CGUIButtonControl
+{
+public:
+  CGUIControllerButton(const CGUIButtonControl& buttonControl,
+                       const std::string& label,
+                       unsigned int index);
+
+  ~CGUIControllerButton() override = default;
+};
+} // namespace GAME
+} // namespace KODI
diff --git a/xbmc/games/controllers/guicontrols/GUIFeatureButton.cpp b/xbmc/games/controllers/guicontrols/GUIFeatureButton.cpp
new file mode 100644
index 0000000..0f1bfd6
--- /dev/null
+++ b/xbmc/games/controllers/guicontrols/GUIFeatureButton.cpp
@@ -0,0 +1,86 @@
+/*
+ *  Copyright (C) 2016-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#include "GUIFeatureButton.h"
+
+#include "ServiceBroker.h"
+#include "games/controllers/windows/GUIControllerDefines.h"
+#include "guilib/GUIMessage.h"
+#include "guilib/WindowIDs.h"
+#include "messaging/ApplicationMessenger.h"
+#include "threads/Event.h"
+#include "utils/StringUtils.h"
+
+using namespace KODI;
+using namespace GAME;
+using namespace std::chrono_literals;
+
+CGUIFeatureButton::CGUIFeatureButton(const CGUIButtonControl& buttonTemplate,
+                                     IConfigurationWizard* wizard,
+                                     const CPhysicalFeature& feature,
+                                     unsigned int index)
+  : CGUIButtonControl(buttonTemplate), m_feature(feature), m_wizard(wizard)
+{
+  // Initialize CGUIButtonControl
+  SetLabel(m_feature.Label());
+  SetID(CONTROL_FEATURE_BUTTONS_START + index);
+  SetVisible(true);
+  AllocResources();
+}
+
+void CGUIFeatureButton::OnUnFocus(void)
+{
+  CGUIButtonControl::OnUnFocus();
+  m_wizard->OnUnfocus(this);
+}
+
+bool CGUIFeatureButton::DoPrompt(const std::string& strPrompt,
+                                 const std::string& strWarn,
+                                 const std::string& strFeature,
+                                 CEvent& waitEvent)
+{
+  bool bInterrupted = false;
+
+  if (!HasFocus())
+  {
+    CGUIMessage msgFocus(GUI_MSG_SETFOCUS, GetID(), GetID());
+    CServiceBroker::GetAppMessenger()->SendGUIMessage(msgFocus, WINDOW_INVALID, false);
+  }
+
+  CGUIMessage msgLabel(GUI_MSG_LABEL_SET, GetID(), GetID());
+
+  for (unsigned int i = 0; i < COUNTDOWN_DURATION_SEC; i++)
+  {
+    const unsigned int secondsElapsed = i;
+    const unsigned int secondsRemaining = COUNTDOWN_DURATION_SEC - i;
+
+    const bool bWarn = secondsElapsed >= WAIT_TO_WARN_SEC;
+
+    std::string strLabel;
+
+    if (bWarn)
+      strLabel = StringUtils::Format(strWarn, strFeature, secondsRemaining);
+    else
+      strLabel = StringUtils::Format(strPrompt, strFeature, secondsRemaining);
+
+    msgLabel.SetLabel(strLabel);
+    CServiceBroker::GetAppMessenger()->SendGUIMessage(msgLabel, WINDOW_INVALID, false);
+
+    waitEvent.Reset();
+    bInterrupted = waitEvent.Wait(1000ms); // Wait 1 second
+
+    if (bInterrupted)
+      break;
+  }
+
+  // Reset label
+  msgLabel.SetLabel(m_feature.Label());
+  CServiceBroker::GetAppMessenger()->SendGUIMessage(msgLabel, WINDOW_INVALID, false);
+
+  return bInterrupted;
+}
diff --git a/xbmc/games/controllers/guicontrols/GUIFeatureButton.h b/xbmc/games/controllers/guicontrols/GUIFeatureButton.h
new file mode 100644
index 0000000..b69f521
--- /dev/null
+++ b/xbmc/games/controllers/guicontrols/GUIFeatureButton.h
@@ -0,0 +1,68 @@
+/*
+ *  Copyright (C) 2016-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#pragma once
+
+#include "games/controllers/input/PhysicalFeature.h"
+#include "games/controllers/windows/IConfigurationWindow.h"
+#include "guilib/GUIButtonControl.h"
+
+#include <string>
+
+namespace KODI
+{
+namespace GAME
+{
+class CGUIFeatureButton : public CGUIButtonControl, public IFeatureButton
+{
+public:
+  CGUIFeatureButton(const CGUIButtonControl& buttonTemplate,
+                    IConfigurationWizard* wizard,
+                    const CPhysicalFeature& feature,
+                    unsigned int index);
+
+  ~CGUIFeatureButton() override = default;
+
+  // implementation of CGUIControl via CGUIButtonControl
+  void OnUnFocus() override;
+
+  // partial implementation of IFeatureButton
+  const CPhysicalFeature& Feature() const override { return m_feature; }
+  INPUT::CARDINAL_DIRECTION GetCardinalDirection() const override
+  {
+    return INPUT::CARDINAL_DIRECTION::NONE;
+  }
+  JOYSTICK::WHEEL_DIRECTION GetWheelDirection() const override
+  {
+    return JOYSTICK::WHEEL_DIRECTION::NONE;
+  }
+  JOYSTICK::THROTTLE_DIRECTION GetThrottleDirection() const override
+  {
+    return JOYSTICK::THROTTLE_DIRECTION::NONE;
+  }
+
+protected:
+  bool DoPrompt(const std::string& strPrompt,
+                const std::string& strWarn,
+                const std::string& strFeature,
+                CEvent& waitEvent);
+
+  // FSM helper
+  template<typename T>
+  T GetNextState(T state)
+  {
+    return static_cast<T>(static_cast<int>(state) + 1);
+  }
+
+  const CPhysicalFeature m_feature;
+
+private:
+  IConfigurationWizard* const m_wizard;
+};
+} // namespace GAME
+} // namespace KODI
diff --git a/xbmc/games/controllers/guicontrols/GUIFeatureControls.cpp b/xbmc/games/controllers/guicontrols/GUIFeatureControls.cpp
new file mode 100644
index 0000000..63d4757
--- /dev/null
+++ b/xbmc/games/controllers/guicontrols/GUIFeatureControls.cpp
@@ -0,0 +1,36 @@
+/*
+ *  Copyright (C) 2016-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#include "GUIFeatureControls.h"
+
+#include "games/controllers/windows/GUIControllerDefines.h"
+
+using namespace KODI;
+using namespace GAME;
+
+CGUIFeatureGroupTitle::CGUIFeatureGroupTitle(const CGUILabelControl& groupTitleTemplate,
+                                             const std::string& groupName,
+                                             unsigned int buttonIndex)
+  : CGUILabelControl(groupTitleTemplate)
+{
+  // Initialize CGUILabelControl
+  SetLabel(groupName);
+  SetID(CONTROL_FEATURE_GROUPS_START + buttonIndex);
+  SetVisible(true);
+  AllocResources();
+}
+
+CGUIFeatureSeparator::CGUIFeatureSeparator(const CGUIImage& separatorTemplate,
+                                           unsigned int buttonIndex)
+  : CGUIImage(separatorTemplate)
+{
+  // Initialize CGUIImage
+  SetID(CONTROL_FEATURE_SEPARATORS_START + buttonIndex);
+  SetVisible(true);
+  AllocResources();
+}
diff --git a/xbmc/games/controllers/guicontrols/GUIFeatureControls.h b/xbmc/games/controllers/guicontrols/GUIFeatureControls.h
new file mode 100644
index 0000000..c72a11a
--- /dev/null
+++ b/xbmc/games/controllers/guicontrols/GUIFeatureControls.h
@@ -0,0 +1,38 @@
+/*
+ *  Copyright (C) 2016-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#pragma once
+
+#include "guilib/GUIImage.h"
+#include "guilib/GUILabelControl.h"
+
+#include <string>
+
+namespace KODI
+{
+namespace GAME
+{
+class CGUIFeatureGroupTitle : public CGUILabelControl
+{
+public:
+  CGUIFeatureGroupTitle(const CGUILabelControl& groupTitleTemplate,
+                        const std::string& groupName,
+                        unsigned int buttonIndex);
+
+  ~CGUIFeatureGroupTitle() override = default;
+};
+
+class CGUIFeatureSeparator : public CGUIImage
+{
+public:
+  CGUIFeatureSeparator(const CGUIImage& separatorTemplate, unsigned int buttonIndex);
+
+  ~CGUIFeatureSeparator() override = default;
+};
+} // namespace GAME
+} // namespace KODI
diff --git a/xbmc/games/controllers/guicontrols/GUIFeatureFactory.cpp b/xbmc/games/controllers/guicontrols/GUIFeatureFactory.cpp
new file mode 100644
index 0000000..2cce033
--- /dev/null
+++ b/xbmc/games/controllers/guicontrols/GUIFeatureFactory.cpp
@@ -0,0 +1,51 @@
+/*
+ *  Copyright (C) 2017-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#include "GUIFeatureFactory.h"
+
+#include "GUICardinalFeatureButton.h"
+#include "GUIScalarFeatureButton.h"
+#include "GUISelectKeyButton.h"
+#include "GUIThrottleButton.h"
+#include "GUIWheelButton.h"
+
+using namespace KODI;
+using namespace GAME;
+
+CGUIButtonControl* CGUIFeatureFactory::CreateButton(BUTTON_TYPE type,
+                                                    const CGUIButtonControl& buttonTemplate,
+                                                    IConfigurationWizard* wizard,
+                                                    const CPhysicalFeature& feature,
+                                                    unsigned int index)
+{
+  switch (type)
+  {
+    case BUTTON_TYPE::BUTTON:
+      return new CGUIScalarFeatureButton(buttonTemplate, wizard, feature, index);
+
+    case BUTTON_TYPE::ANALOG_STICK:
+      return new CGUIAnalogStickButton(buttonTemplate, wizard, feature, index);
+
+    case BUTTON_TYPE::WHEEL:
+      return new CGUIWheelButton(buttonTemplate, wizard, feature, index);
+
+    case BUTTON_TYPE::THROTTLE:
+      return new CGUIThrottleButton(buttonTemplate, wizard, feature, index);
+
+    case BUTTON_TYPE::SELECT_KEY:
+      return new CGUISelectKeyButton(buttonTemplate, wizard, index);
+
+    case BUTTON_TYPE::RELATIVE_POINTER:
+      return new CGUIRelativePointerButton(buttonTemplate, wizard, feature, index);
+
+    default:
+      break;
+  }
+
+  return nullptr;
+}
diff --git a/xbmc/games/controllers/guicontrols/GUIFeatureFactory.h b/xbmc/games/controllers/guicontrols/GUIFeatureFactory.h
new file mode 100644
index 0000000..e35070d
--- /dev/null
+++ b/xbmc/games/controllers/guicontrols/GUIFeatureFactory.h
@@ -0,0 +1,37 @@
+/*
+ *  Copyright (C) 2017-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#pragma once
+
+#include "GUIControlTypes.h"
+
+class CGUIButtonControl;
+
+namespace KODI
+{
+namespace GAME
+{
+class CPhysicalFeature;
+class IConfigurationWizard;
+
+class CGUIFeatureFactory
+{
+public:
+  /*!
+   * \brief Create a button of the specified type
+   * \param type The type of button control being created
+   * \return A button control, or nullptr if type is invalid
+   */
+  static CGUIButtonControl* CreateButton(BUTTON_TYPE type,
+                                         const CGUIButtonControl& buttonTemplate,
+                                         IConfigurationWizard* wizard,
+                                         const CPhysicalFeature& feature,
+                                         unsigned int index);
+};
+} // namespace GAME
+} // namespace KODI
diff --git a/xbmc/games/controllers/guicontrols/GUIFeatureTranslator.cpp b/xbmc/games/controllers/guicontrols/GUIFeatureTranslator.cpp
new file mode 100644
index 0000000..ab941c5
--- /dev/null
+++ b/xbmc/games/controllers/guicontrols/GUIFeatureTranslator.cpp
@@ -0,0 +1,39 @@
+/*
+ *  Copyright (C) 2017-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#include "GUIFeatureTranslator.h"
+
+using namespace KODI;
+using namespace GAME;
+
+BUTTON_TYPE CGUIFeatureTranslator::GetButtonType(JOYSTICK::FEATURE_TYPE featureType)
+{
+  switch (featureType)
+  {
+    case JOYSTICK::FEATURE_TYPE::SCALAR:
+    case JOYSTICK::FEATURE_TYPE::KEY:
+      return BUTTON_TYPE::BUTTON;
+
+    case JOYSTICK::FEATURE_TYPE::ANALOG_STICK:
+      return BUTTON_TYPE::ANALOG_STICK;
+
+    case JOYSTICK::FEATURE_TYPE::RELPOINTER:
+      return BUTTON_TYPE::RELATIVE_POINTER;
+
+    case JOYSTICK::FEATURE_TYPE::WHEEL:
+      return BUTTON_TYPE::WHEEL;
+
+    case JOYSTICK::FEATURE_TYPE::THROTTLE:
+      return BUTTON_TYPE::THROTTLE;
+
+    default:
+      break;
+  }
+
+  return BUTTON_TYPE::UNKNOWN;
+}
diff --git a/xbmc/games/controllers/guicontrols/GUIFeatureTranslator.h b/xbmc/games/controllers/guicontrols/GUIFeatureTranslator.h
new file mode 100644
index 0000000..8e28d16
--- /dev/null
+++ b/xbmc/games/controllers/guicontrols/GUIFeatureTranslator.h
@@ -0,0 +1,27 @@
+/*
+ *  Copyright (C) 2017-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#pragma once
+
+#include "GUIControlTypes.h"
+#include "input/joysticks/JoystickTypes.h"
+
+namespace KODI
+{
+namespace GAME
+{
+class CGUIFeatureTranslator
+{
+public:
+  /*!
+   * \brief Get the type of button control used to map the feature
+   */
+  static BUTTON_TYPE GetButtonType(JOYSTICK::FEATURE_TYPE featureType);
+};
+} // namespace GAME
+} // namespace KODI
diff --git a/xbmc/games/controllers/guicontrols/GUIGameController.cpp b/xbmc/games/controllers/guicontrols/GUIGameController.cpp
new file mode 100644
index 0000000..8990cf2
--- /dev/null
+++ b/xbmc/games/controllers/guicontrols/GUIGameController.cpp
@@ -0,0 +1,64 @@
+/*
+ *  Copyright (C) 2014-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#include "GUIGameController.h"
+
+#include "games/controllers/Controller.h"
+#include "games/controllers/ControllerLayout.h"
+#include "utils/log.h"
+
+#include <mutex>
+
+using namespace KODI;
+using namespace GAME;
+
+CGUIGameController::CGUIGameController(
+    int parentID, int controlID, float posX, float posY, float width, float height)
+  : CGUIImage(parentID, controlID, posX, posY, width, height, CTextureInfo())
+{
+  // Initialize CGUIControl
+  ControlType = GUICONTROL_GAMECONTROLLER;
+}
+
+CGUIGameController::CGUIGameController(const CGUIGameController& from) : CGUIImage(from)
+{
+  // Initialize CGUIControl
+  ControlType = GUICONTROL_GAMECONTROLLER;
+}
+
+CGUIGameController* CGUIGameController::Clone(void) const
+{
+  return new CGUIGameController(*this);
+}
+
+void CGUIGameController::Render(void)
+{
+  CGUIImage::Render();
+
+  std::unique_lock<CCriticalSection> lock(m_mutex);
+
+  if (m_currentController)
+  {
+    //! @todo Render pressed buttons
+  }
+}
+
+void CGUIGameController::ActivateController(const ControllerPtr& controller)
+{
+  std::unique_lock<CCriticalSection> lock(m_mutex);
+
+  if (controller && controller != m_currentController)
+  {
+    m_currentController = controller;
+
+    lock.unlock();
+
+    //! @todo Sometimes this fails on window init
+    SetFileName(m_currentController->Layout().ImagePath());
+  }
+}
diff --git a/xbmc/games/controllers/guicontrols/GUIGameController.h b/xbmc/games/controllers/guicontrols/GUIGameController.h
new file mode 100644
index 0000000..d62819a
--- /dev/null
+++ b/xbmc/games/controllers/guicontrols/GUIGameController.h
@@ -0,0 +1,39 @@
+/*
+ *  Copyright (C) 2014-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#pragma once
+
+#include "games/controllers/ControllerTypes.h"
+#include "guilib/GUIImage.h"
+#include "threads/CriticalSection.h"
+
+namespace KODI
+{
+namespace GAME
+{
+class CGUIGameController : public CGUIImage
+{
+public:
+  CGUIGameController(
+      int parentID, int controlID, float posX, float posY, float width, float height);
+  CGUIGameController(const CGUIGameController& from);
+
+  ~CGUIGameController() override = default;
+
+  // implementation of CGUIControl via CGUIImage
+  CGUIGameController* Clone() const override;
+  void Render() override;
+
+  void ActivateController(const ControllerPtr& controller);
+
+private:
+  ControllerPtr m_currentController;
+  CCriticalSection m_mutex;
+};
+} // namespace GAME
+} // namespace KODI
diff --git a/xbmc/games/controllers/guicontrols/GUIScalarFeatureButton.cpp b/xbmc/games/controllers/guicontrols/GUIScalarFeatureButton.cpp
new file mode 100644
index 0000000..5358aea
--- /dev/null
+++ b/xbmc/games/controllers/guicontrols/GUIScalarFeatureButton.cpp
@@ -0,0 +1,59 @@
+/*
+ *  Copyright (C) 2016-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#include "GUIScalarFeatureButton.h"
+
+#include "guilib/LocalizeStrings.h"
+
+#include <string>
+
+using namespace KODI;
+using namespace GAME;
+
+CGUIScalarFeatureButton::CGUIScalarFeatureButton(const CGUIButtonControl& buttonTemplate,
+                                                 IConfigurationWizard* wizard,
+                                                 const CPhysicalFeature& feature,
+                                                 unsigned int index)
+  : CGUIFeatureButton(buttonTemplate, wizard, feature, index)
+{
+  Reset();
+}
+
+bool CGUIScalarFeatureButton::PromptForInput(CEvent& waitEvent)
+{
+  bool bInterrupted = false;
+
+  switch (m_state)
+  {
+    case STATE::NEED_INPUT:
+    {
+      const std::string& strPrompt = g_localizeStrings.Get(35090); // "Press %s"
+      const std::string& strWarn = g_localizeStrings.Get(35091); // "Press %s (%d)"
+
+      bInterrupted = DoPrompt(strPrompt, strWarn, m_feature.Label(), waitEvent);
+
+      m_state = GetNextState(m_state);
+
+      break;
+    }
+    default:
+      break;
+  }
+
+  return bInterrupted;
+}
+
+bool CGUIScalarFeatureButton::IsFinished(void) const
+{
+  return m_state >= STATE::FINISHED;
+}
+
+void CGUIScalarFeatureButton::Reset(void)
+{
+  m_state = STATE::NEED_INPUT;
+}
diff --git a/xbmc/games/controllers/guicontrols/GUIScalarFeatureButton.h b/xbmc/games/controllers/guicontrols/GUIScalarFeatureButton.h
new file mode 100644
index 0000000..6505684
--- /dev/null
+++ b/xbmc/games/controllers/guicontrols/GUIScalarFeatureButton.h
@@ -0,0 +1,42 @@
+/*
+ *  Copyright (C) 2016-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#pragma once
+
+#include "GUIFeatureButton.h"
+
+namespace KODI
+{
+namespace GAME
+{
+class CGUIScalarFeatureButton : public CGUIFeatureButton
+{
+public:
+  CGUIScalarFeatureButton(const CGUIButtonControl& buttonTemplate,
+                          IConfigurationWizard* wizard,
+                          const CPhysicalFeature& feature,
+                          unsigned int index);
+
+  ~CGUIScalarFeatureButton() override = default;
+
+  // implementation of IFeatureButton
+  bool PromptForInput(CEvent& waitEvent) override;
+  bool IsFinished() const override;
+  void Reset() override;
+
+private:
+  enum class STATE
+  {
+    NEED_INPUT,
+    FINISHED,
+  };
+
+  STATE m_state;
+};
+} // namespace GAME
+} // namespace KODI
diff --git a/xbmc/games/controllers/guicontrols/GUISelectKeyButton.cpp b/xbmc/games/controllers/guicontrols/GUISelectKeyButton.cpp
new file mode 100644
index 0000000..ea4a656
--- /dev/null
+++ b/xbmc/games/controllers/guicontrols/GUISelectKeyButton.cpp
@@ -0,0 +1,87 @@
+/*
+ *  Copyright (C) 2017-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#include "GUISelectKeyButton.h"
+
+#include "guilib/LocalizeStrings.h"
+
+#include <string>
+
+using namespace KODI;
+using namespace GAME;
+
+CGUISelectKeyButton::CGUISelectKeyButton(const CGUIButtonControl& buttonTemplate,
+                                         IConfigurationWizard* wizard,
+                                         unsigned int index)
+  : CGUIFeatureButton(buttonTemplate, wizard, GetFeature(), index)
+{
+}
+
+const CPhysicalFeature& CGUISelectKeyButton::Feature(void) const
+{
+  if (m_state == STATE::NEED_INPUT)
+    return m_selectedKey;
+
+  return CGUIFeatureButton::Feature();
+}
+
+bool CGUISelectKeyButton::PromptForInput(CEvent& waitEvent)
+{
+  bool bInterrupted = false;
+
+  switch (m_state)
+  {
+    case STATE::NEED_KEY:
+    {
+      const std::string& strPrompt = g_localizeStrings.Get(35169); // "Press a key"
+      const std::string& strWarn = g_localizeStrings.Get(35170); // "Press a key ({1:d})"
+
+      bInterrupted = DoPrompt(strPrompt, strWarn, "", waitEvent);
+
+      m_state = GetNextState(m_state);
+
+      break;
+    }
+    case STATE::NEED_INPUT:
+    {
+      const std::string& strPrompt = g_localizeStrings.Get(35090); // "Press {0:s}"
+      const std::string& strWarn = g_localizeStrings.Get(35091); // "Press {0:s} ({1:d})"
+
+      bInterrupted = DoPrompt(strPrompt, strWarn, m_selectedKey.Label(), waitEvent);
+
+      m_state = GetNextState(m_state);
+
+      break;
+    }
+    default:
+      break;
+  }
+
+  return bInterrupted;
+}
+
+bool CGUISelectKeyButton::IsFinished(void) const
+{
+  return m_state >= STATE::FINISHED;
+}
+
+void CGUISelectKeyButton::SetKey(const CPhysicalFeature& key)
+{
+  m_selectedKey = key;
+}
+
+void CGUISelectKeyButton::Reset(void)
+{
+  m_state = STATE::NEED_KEY;
+  m_selectedKey.Reset();
+}
+
+CPhysicalFeature CGUISelectKeyButton::GetFeature()
+{
+  return CPhysicalFeature(35168); // "Select key"
+}
diff --git a/xbmc/games/controllers/guicontrols/GUISelectKeyButton.h b/xbmc/games/controllers/guicontrols/GUISelectKeyButton.h
new file mode 100644
index 0000000..e96f78b
--- /dev/null
+++ b/xbmc/games/controllers/guicontrols/GUISelectKeyButton.h
@@ -0,0 +1,51 @@
+/*
+ *  Copyright (C) 2017-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#pragma once
+
+#include "GUIFeatureButton.h"
+#include "games/controllers/input/PhysicalFeature.h"
+
+namespace KODI
+{
+namespace GAME
+{
+class CGUISelectKeyButton : public CGUIFeatureButton
+{
+public:
+  CGUISelectKeyButton(const CGUIButtonControl& buttonTemplate,
+                      IConfigurationWizard* wizard,
+                      unsigned int index);
+
+  ~CGUISelectKeyButton() override = default;
+
+  // implementation of IFeatureButton
+  const CPhysicalFeature& Feature(void) const override;
+  bool AllowWizard() const override { return false; }
+  bool PromptForInput(CEvent& waitEvent) override;
+  bool IsFinished() const override;
+  bool NeedsKey() const override { return m_state == STATE::NEED_KEY; }
+  void SetKey(const CPhysicalFeature& key) override;
+  void Reset() override;
+
+private:
+  static CPhysicalFeature GetFeature();
+
+  enum class STATE
+  {
+    NEED_KEY,
+    NEED_INPUT,
+    FINISHED,
+  };
+
+  STATE m_state = STATE::NEED_KEY;
+
+  CPhysicalFeature m_selectedKey;
+};
+} // namespace GAME
+} // namespace KODI
diff --git a/xbmc/games/controllers/guicontrols/GUIThrottleButton.cpp b/xbmc/games/controllers/guicontrols/GUIThrottleButton.cpp
new file mode 100644
index 0000000..69f32a1
--- /dev/null
+++ b/xbmc/games/controllers/guicontrols/GUIThrottleButton.cpp
@@ -0,0 +1,88 @@
+/*
+ *  Copyright (C) 2016-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#include "GUIThrottleButton.h"
+
+#include "guilib/LocalizeStrings.h"
+
+#include <string>
+
+using namespace KODI;
+using namespace GAME;
+
+CGUIThrottleButton::CGUIThrottleButton(const CGUIButtonControl& buttonTemplate,
+                                       IConfigurationWizard* wizard,
+                                       const CPhysicalFeature& feature,
+                                       unsigned int index)
+  : CGUIFeatureButton(buttonTemplate, wizard, feature, index)
+{
+  Reset();
+}
+
+bool CGUIThrottleButton::PromptForInput(CEvent& waitEvent)
+{
+  using namespace JOYSTICK;
+
+  bool bInterrupted = false;
+
+  // Get the prompt for the current analog stick direction
+  std::string strPrompt;
+  std::string strWarn;
+  switch (m_state)
+  {
+    case STATE::THROTTLE_UP:
+      strPrompt = g_localizeStrings.Get(35092); // "Move %s up"
+      strWarn = g_localizeStrings.Get(35093); // "Move %s up (%d)"
+      break;
+    case STATE::THROTTLE_DOWN:
+      strPrompt = g_localizeStrings.Get(35094); // "Move %s down"
+      strWarn = g_localizeStrings.Get(35095); // "Move %s down (%d)"
+      break;
+    default:
+      break;
+  }
+
+  if (!strPrompt.empty())
+  {
+    bInterrupted = DoPrompt(strPrompt, strWarn, m_feature.Label(), waitEvent);
+
+    if (!bInterrupted)
+      m_state = STATE::FINISHED; // Not interrupted, must have timed out
+    else
+      m_state = GetNextState(m_state); // Interrupted by input, proceed
+  }
+
+  return bInterrupted;
+}
+
+bool CGUIThrottleButton::IsFinished(void) const
+{
+  return m_state >= STATE::FINISHED;
+}
+
+JOYSTICK::THROTTLE_DIRECTION CGUIThrottleButton::GetThrottleDirection(void) const
+{
+  using namespace JOYSTICK;
+
+  switch (m_state)
+  {
+    case STATE::THROTTLE_UP:
+      return THROTTLE_DIRECTION::UP;
+    case STATE::THROTTLE_DOWN:
+      return THROTTLE_DIRECTION::DOWN;
+    default:
+      break;
+  }
+
+  return THROTTLE_DIRECTION::NONE;
+}
+
+void CGUIThrottleButton::Reset(void)
+{
+  m_state = STATE::THROTTLE_UP;
+}
diff --git a/xbmc/games/controllers/guicontrols/GUIThrottleButton.h b/xbmc/games/controllers/guicontrols/GUIThrottleButton.h
new file mode 100644
index 0000000..72b7ee3
--- /dev/null
+++ b/xbmc/games/controllers/guicontrols/GUIThrottleButton.h
@@ -0,0 +1,44 @@
+/*
+ *  Copyright (C) 2016-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#pragma once
+
+#include "GUIFeatureButton.h"
+
+namespace KODI
+{
+namespace GAME
+{
+class CGUIThrottleButton : public CGUIFeatureButton
+{
+public:
+  CGUIThrottleButton(const CGUIButtonControl& buttonTemplate,
+                     IConfigurationWizard* wizard,
+                     const CPhysicalFeature& feature,
+                     unsigned int index);
+
+  ~CGUIThrottleButton() override = default;
+
+  // implementation of IFeatureButton
+  bool PromptForInput(CEvent& waitEvent) override;
+  bool IsFinished() const override;
+  JOYSTICK::THROTTLE_DIRECTION GetThrottleDirection() const override;
+  void Reset() override;
+
+private:
+  enum class STATE
+  {
+    THROTTLE_UP,
+    THROTTLE_DOWN,
+    FINISHED,
+  };
+
+  STATE m_state;
+};
+} // namespace GAME
+} // namespace KODI
diff --git a/xbmc/games/controllers/guicontrols/GUIWheelButton.cpp b/xbmc/games/controllers/guicontrols/GUIWheelButton.cpp
new file mode 100644
index 0000000..63c3819
--- /dev/null
+++ b/xbmc/games/controllers/guicontrols/GUIWheelButton.cpp
@@ -0,0 +1,88 @@
+/*
+ *  Copyright (C) 2016-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#include "GUIWheelButton.h"
+
+#include "guilib/LocalizeStrings.h"
+
+#include <string>
+
+using namespace KODI;
+using namespace GAME;
+
+CGUIWheelButton::CGUIWheelButton(const CGUIButtonControl& buttonTemplate,
+                                 IConfigurationWizard* wizard,
+                                 const CPhysicalFeature& feature,
+                                 unsigned int index)
+  : CGUIFeatureButton(buttonTemplate, wizard, feature, index)
+{
+  Reset();
+}
+
+bool CGUIWheelButton::PromptForInput(CEvent& waitEvent)
+{
+  using namespace JOYSTICK;
+
+  bool bInterrupted = false;
+
+  // Get the prompt for the current analog stick direction
+  std::string strPrompt;
+  std::string strWarn;
+  switch (m_state)
+  {
+    case STATE::WHEEL_LEFT:
+      strPrompt = g_localizeStrings.Get(35098); // "Move %s left"
+      strWarn = g_localizeStrings.Get(35099); // "Move %s left (%d)"
+      break;
+    case STATE::WHEEL_RIGHT:
+      strPrompt = g_localizeStrings.Get(35096); // "Move %s right"
+      strWarn = g_localizeStrings.Get(35097); // "Move %s right (%d)"
+      break;
+    default:
+      break;
+  }
+
+  if (!strPrompt.empty())
+  {
+    bInterrupted = DoPrompt(strPrompt, strWarn, m_feature.Label(), waitEvent);
+
+    if (!bInterrupted)
+      m_state = STATE::FINISHED; // Not interrupted, must have timed out
+    else
+      m_state = GetNextState(m_state); // Interrupted by input, proceed
+  }
+
+  return bInterrupted;
+}
+
+bool CGUIWheelButton::IsFinished(void) const
+{
+  return m_state >= STATE::FINISHED;
+}
+
+JOYSTICK::WHEEL_DIRECTION CGUIWheelButton::GetWheelDirection(void) const
+{
+  using namespace JOYSTICK;
+
+  switch (m_state)
+  {
+    case STATE::WHEEL_LEFT:
+      return WHEEL_DIRECTION::LEFT;
+    case STATE::WHEEL_RIGHT:
+      return WHEEL_DIRECTION::RIGHT;
+    default:
+      break;
+  }
+
+  return WHEEL_DIRECTION::NONE;
+}
+
+void CGUIWheelButton::Reset(void)
+{
+  m_state = STATE::WHEEL_LEFT;
+}
diff --git a/xbmc/games/controllers/guicontrols/GUIWheelButton.h b/xbmc/games/controllers/guicontrols/GUIWheelButton.h
new file mode 100644
index 0000000..937703a
--- /dev/null
+++ b/xbmc/games/controllers/guicontrols/GUIWheelButton.h
@@ -0,0 +1,44 @@
+/*
+ *  Copyright (C) 2016-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#pragma once
+
+#include "GUIFeatureButton.h"
+
+namespace KODI
+{
+namespace GAME
+{
+class CGUIWheelButton : public CGUIFeatureButton
+{
+public:
+  CGUIWheelButton(const CGUIButtonControl& buttonTemplate,
+                  IConfigurationWizard* wizard,
+                  const CPhysicalFeature& feature,
+                  unsigned int index);
+
+  ~CGUIWheelButton() override = default;
+
+  // implementation of IFeatureButton
+  bool PromptForInput(CEvent& waitEvent) override;
+  bool IsFinished() const override;
+  JOYSTICK::WHEEL_DIRECTION GetWheelDirection() const override;
+  void Reset() override;
+
+private:
+  enum class STATE
+  {
+    WHEEL_LEFT,
+    WHEEL_RIGHT,
+    FINISHED,
+  };
+
+  STATE m_state;
+};
+} // namespace GAME
+} // namespace KODI
diff --git a/xbmc/games/controllers/input/CMakeLists.txt b/xbmc/games/controllers/input/CMakeLists.txt
new file mode 100644
index 0000000..511fa37
--- /dev/null
+++ b/xbmc/games/controllers/input/CMakeLists.txt
@@ -0,0 +1,11 @@
+set(SOURCES InputSink.cpp
+            PhysicalFeature.cpp
+            PhysicalTopology.cpp
+)
+
+set(HEADERS InputSink.h
+            PhysicalFeature.h
+            PhysicalTopology.h
+)
+
+core_add_library(games_controller_input)
diff --git a/xbmc/games/controllers/input/InputSink.cpp b/xbmc/games/controllers/input/InputSink.cpp
new file mode 100644
index 0000000..a48b4b9
--- /dev/null
+++ b/xbmc/games/controllers/input/InputSink.cpp
@@ -0,0 +1,67 @@
+/*
+ *  Copyright (C) 2017-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#include "InputSink.h"
+
+#include "games/controllers/ControllerIDs.h"
+
+using namespace KODI;
+using namespace GAME;
+
+CInputSink::CInputSink(JOYSTICK::IInputHandler* gameInput) : m_gameInput(gameInput)
+{
+}
+
+std::string CInputSink::ControllerID(void) const
+{
+  return DEFAULT_CONTROLLER_ID;
+}
+
+bool CInputSink::AcceptsInput(const std::string& feature) const
+{
+  return m_gameInput->AcceptsInput(feature);
+}
+
+bool CInputSink::OnButtonPress(const std::string& feature, bool bPressed)
+{
+  return true;
+}
+
+bool CInputSink::OnButtonMotion(const std::string& feature,
+                                float magnitude,
+                                unsigned int motionTimeMs)
+{
+  return true;
+}
+
+bool CInputSink::OnAnalogStickMotion(const std::string& feature,
+                                     float x,
+                                     float y,
+                                     unsigned int motionTimeMs)
+{
+  return true;
+}
+
+bool CInputSink::OnAccelerometerMotion(const std::string& feature, float x, float y, float z)
+{
+  return true;
+}
+
+bool CInputSink::OnWheelMotion(const std::string& feature,
+                               float position,
+                               unsigned int motionTimeMs)
+{
+  return true;
+}
+
+bool CInputSink::OnThrottleMotion(const std::string& feature,
+                                  float position,
+                                  unsigned int motionTimeMs)
+{
+  return true;
+}
diff --git a/xbmc/games/controllers/input/InputSink.h b/xbmc/games/controllers/input/InputSink.h
new file mode 100644
index 0000000..5dc331f
--- /dev/null
+++ b/xbmc/games/controllers/input/InputSink.h
@@ -0,0 +1,53 @@
+/*
+ *  Copyright (C) 2017-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#pragma once
+
+#include "input/joysticks/interfaces/IInputHandler.h"
+
+namespace KODI
+{
+namespace GAME
+{
+class CGameClient;
+
+class CInputSink : public JOYSTICK::IInputHandler
+{
+public:
+  explicit CInputSink(JOYSTICK::IInputHandler* gameInput);
+
+  ~CInputSink() override = default;
+
+  // Implementation of IInputHandler
+  std::string ControllerID() const override;
+  bool HasFeature(const std::string& feature) const override { return true; }
+  bool AcceptsInput(const std::string& feature) const override;
+  bool OnButtonPress(const std::string& feature, bool bPressed) override;
+  void OnButtonHold(const std::string& feature, unsigned int holdTimeMs) override {}
+  bool OnButtonMotion(const std::string& feature,
+                      float magnitude,
+                      unsigned int motionTimeMs) override;
+  bool OnAnalogStickMotion(const std::string& feature,
+                           float x,
+                           float y,
+                           unsigned int motionTimeMs) override;
+  bool OnAccelerometerMotion(const std::string& feature, float x, float y, float z) override;
+  bool OnWheelMotion(const std::string& feature,
+                     float position,
+                     unsigned int motionTimeMs) override;
+  bool OnThrottleMotion(const std::string& feature,
+                        float position,
+                        unsigned int motionTimeMs) override;
+  void OnInputFrame() override {}
+
+private:
+  // Construction parameters
+  JOYSTICK::IInputHandler* m_gameInput;
+};
+} // namespace GAME
+} // namespace KODI
diff --git a/xbmc/games/controllers/input/PhysicalFeature.cpp b/xbmc/games/controllers/input/PhysicalFeature.cpp
new file mode 100644
index 0000000..24e0c41
--- /dev/null
+++ b/xbmc/games/controllers/input/PhysicalFeature.cpp
@@ -0,0 +1,162 @@
+/*
+ *  Copyright (C) 2015-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#include "PhysicalFeature.h"
+
+#include "games/controllers/Controller.h"
+#include "games/controllers/ControllerDefinitions.h"
+#include "games/controllers/ControllerTranslator.h"
+#include "guilib/LocalizeStrings.h"
+#include "utils/XMLUtils.h"
+#include "utils/log.h"
+
+#include <sstream>
+
+using namespace KODI;
+using namespace GAME;
+using namespace JOYSTICK;
+
+CPhysicalFeature::CPhysicalFeature(int labelId)
+{
+  Reset();
+  m_labelId = labelId;
+}
+
+void CPhysicalFeature::Reset(void)
+{
+  *this = CPhysicalFeature();
+}
+
+CPhysicalFeature& CPhysicalFeature::operator=(const CPhysicalFeature& rhs)
+{
+  if (this != &rhs)
+  {
+    m_controller = rhs.m_controller;
+    m_type = rhs.m_type;
+    m_category = rhs.m_category;
+    m_categoryLabelId = rhs.m_categoryLabelId;
+    m_strName = rhs.m_strName;
+    m_labelId = rhs.m_labelId;
+    m_inputType = rhs.m_inputType;
+    m_keycode = rhs.m_keycode;
+  }
+  return *this;
+}
+
+std::string CPhysicalFeature::CategoryLabel() const
+{
+  std::string categoryLabel;
+
+  if (m_categoryLabelId >= 0 && m_controller != nullptr)
+    categoryLabel = g_localizeStrings.GetAddonString(m_controller->ID(), m_categoryLabelId);
+
+  if (categoryLabel.empty())
+    categoryLabel = g_localizeStrings.Get(m_categoryLabelId);
+
+  return categoryLabel;
+}
+
+std::string CPhysicalFeature::Label() const
+{
+  std::string label;
+
+  if (m_labelId >= 0 && m_controller != nullptr)
+    label = g_localizeStrings.GetAddonString(m_controller->ID(), m_labelId);
+
+  if (label.empty())
+    label = g_localizeStrings.Get(m_labelId);
+
+  return label;
+}
+
+bool CPhysicalFeature::Deserialize(const TiXmlElement* pElement,
+                                   const CController* controller,
+                                   FEATURE_CATEGORY category,
+                                   int categoryLabelId)
+{
+  Reset();
+
+  if (!pElement)
+    return false;
+
+  std::string strType(pElement->Value());
+
+  // Type
+  m_type = CControllerTranslator::TranslateFeatureType(strType);
+  if (m_type == FEATURE_TYPE::UNKNOWN)
+  {
+    CLog::Log(LOGDEBUG, "Invalid feature: <{}> ", pElement->Value());
+    return false;
+  }
+
+  // Cagegory was obtained from parent XML node
+  m_category = category;
+  m_categoryLabelId = categoryLabelId;
+
+  // Name
+  m_strName = XMLUtils::GetAttribute(pElement, LAYOUT_XML_ATTR_FEATURE_NAME);
+  if (m_strName.empty())
+  {
+    CLog::Log(LOGERROR, "<{}> tag has no \"{}\" attribute", strType, LAYOUT_XML_ATTR_FEATURE_NAME);
+    return false;
+  }
+
+  // Label ID
+  std::string strLabel = XMLUtils::GetAttribute(pElement, LAYOUT_XML_ATTR_FEATURE_LABEL);
+  if (strLabel.empty())
+    CLog::Log(LOGDEBUG, "<{}> tag has no \"{}\" attribute", strType, LAYOUT_XML_ATTR_FEATURE_LABEL);
+  else
+    std::istringstream(strLabel) >> m_labelId;
+
+  // Input type
+  if (m_type == FEATURE_TYPE::SCALAR)
+  {
+    std::string strInputType = XMLUtils::GetAttribute(pElement, LAYOUT_XML_ATTR_INPUT_TYPE);
+    if (strInputType.empty())
+    {
+      CLog::Log(LOGERROR, "<{}> tag has no \"{}\" attribute", strType, LAYOUT_XML_ATTR_INPUT_TYPE);
+      return false;
+    }
+    else
+    {
+      m_inputType = CControllerTranslator::TranslateInputType(strInputType);
+      if (m_inputType == INPUT_TYPE::UNKNOWN)
+      {
+        CLog::Log(LOGERROR, "<{}> tag - attribute \"{}\" is invalid: \"{}\"", strType,
+                  LAYOUT_XML_ATTR_INPUT_TYPE, strInputType);
+        return false;
+      }
+    }
+  }
+
+  // Keycode
+  if (m_type == FEATURE_TYPE::KEY)
+  {
+    std::string strSymbol = XMLUtils::GetAttribute(pElement, LAYOUT_XML_ATTR_KEY_SYMBOL);
+    if (strSymbol.empty())
+    {
+      CLog::Log(LOGERROR, "<{}> tag has no \"{}\" attribute", strType, LAYOUT_XML_ATTR_KEY_SYMBOL);
+      return false;
+    }
+    else
+    {
+      m_keycode = CControllerTranslator::TranslateKeysym(strSymbol);
+      if (m_keycode == XBMCK_UNKNOWN)
+      {
+        CLog::Log(LOGERROR, "<{}> tag - attribute \"{}\" is invalid: \"{}\"", strType,
+                  LAYOUT_XML_ATTR_KEY_SYMBOL, strSymbol);
+        return false;
+      }
+    }
+  }
+
+  // Save controller for string translation
+  m_controller = controller;
+
+  return true;
+}
diff --git a/xbmc/games/controllers/input/PhysicalFeature.h b/xbmc/games/controllers/input/PhysicalFeature.h
new file mode 100644
index 0000000..6319a63
--- /dev/null
+++ b/xbmc/games/controllers/input/PhysicalFeature.h
@@ -0,0 +1,65 @@
+/*
+ *  Copyright (C) 2015-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#pragma once
+
+#include "games/controllers/ControllerTypes.h"
+#include "input/joysticks/JoystickTypes.h"
+#include "input/keyboard/KeyboardTypes.h"
+
+#include <string>
+
+class TiXmlElement;
+
+namespace KODI
+{
+namespace GAME
+{
+
+class CPhysicalFeature
+{
+public:
+  CPhysicalFeature() = default;
+  CPhysicalFeature(int labelId);
+  CPhysicalFeature(const CPhysicalFeature& other) { *this = other; }
+
+  void Reset(void);
+
+  CPhysicalFeature& operator=(const CPhysicalFeature& rhs);
+
+  JOYSTICK::FEATURE_TYPE Type(void) const { return m_type; }
+  JOYSTICK::FEATURE_CATEGORY Category(void) const { return m_category; }
+  const std::string& Name(void) const { return m_strName; }
+
+  // GUI properties
+  std::string Label(void) const;
+  int LabelID(void) const { return m_labelId; }
+  std::string CategoryLabel(void) const;
+
+  // Input properties
+  JOYSTICK::INPUT_TYPE InputType(void) const { return m_inputType; }
+  KEYBOARD::KeySymbol Keycode() const { return m_keycode; }
+
+  bool Deserialize(const TiXmlElement* pElement,
+                   const CController* controller,
+                   JOYSTICK::FEATURE_CATEGORY category,
+                   int categoryLabelId);
+
+private:
+  const CController* m_controller = nullptr; // Used for translating addon-specific labels
+  JOYSTICK::FEATURE_TYPE m_type = JOYSTICK::FEATURE_TYPE::UNKNOWN;
+  JOYSTICK::FEATURE_CATEGORY m_category = JOYSTICK::FEATURE_CATEGORY::UNKNOWN;
+  int m_categoryLabelId = -1;
+  std::string m_strName;
+  int m_labelId = -1;
+  JOYSTICK::INPUT_TYPE m_inputType = JOYSTICK::INPUT_TYPE::UNKNOWN;
+  KEYBOARD::KeySymbol m_keycode = XBMCK_UNKNOWN;
+};
+
+} // namespace GAME
+} // namespace KODI
diff --git a/xbmc/games/controllers/input/PhysicalTopology.cpp b/xbmc/games/controllers/input/PhysicalTopology.cpp
new file mode 100644
index 0000000..2fecb5a
--- /dev/null
+++ b/xbmc/games/controllers/input/PhysicalTopology.cpp
@@ -0,0 +1,56 @@
+/*
+ *  Copyright (C) 2017-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#include "PhysicalTopology.h"
+
+#include "games/controllers/ControllerDefinitions.h"
+#include "utils/XMLUtils.h"
+#include "utils/log.h"
+
+#include <utility>
+
+using namespace KODI;
+using namespace GAME;
+
+CPhysicalTopology::CPhysicalTopology(bool bProvidesInput, std::vector<CPhysicalPort> ports)
+  : m_bProvidesInput(bProvidesInput), m_ports(std::move(ports))
+{
+}
+
+void CPhysicalTopology::Reset()
+{
+  CPhysicalTopology defaultTopology;
+  *this = std::move(defaultTopology);
+}
+
+bool CPhysicalTopology::Deserialize(const TiXmlElement* pElement)
+{
+  Reset();
+
+  if (pElement == nullptr)
+    return false;
+
+  m_bProvidesInput = (XMLUtils::GetAttribute(pElement, LAYOUT_XML_ATTR_PROVIDES_INPUT) != "false");
+
+  for (const TiXmlElement* pChild = pElement->FirstChildElement(); pChild != nullptr;
+       pChild = pChild->NextSiblingElement())
+  {
+    if (pChild->ValueStr() == LAYOUT_XML_ELM_PORT)
+    {
+      CPhysicalPort port;
+      if (port.Deserialize(pChild))
+        m_ports.emplace_back(std::move(port));
+    }
+    else
+    {
+      CLog::Log(LOGDEBUG, "Unknown physical topology tag: <{}>", pChild->ValueStr());
+    }
+  }
+
+  return true;
+}
diff --git a/xbmc/games/controllers/input/PhysicalTopology.h b/xbmc/games/controllers/input/PhysicalTopology.h
new file mode 100644
index 0000000..c194de8
--- /dev/null
+++ b/xbmc/games/controllers/input/PhysicalTopology.h
@@ -0,0 +1,61 @@
+/*
+ *  Copyright (C) 2017-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#pragma once
+
+#include "games/ports/input/PhysicalPort.h"
+
+#include <vector>
+
+class TiXmlElement;
+
+namespace KODI
+{
+namespace GAME
+{
+
+/*!
+ * \brief Represents the physical topology of controller add-ons
+ *
+ * The physical topology of a controller defines how many ports it has and
+ * whether it can provide player input (hubs like the Super Multitap don't
+ * provide input).
+ */
+class CPhysicalTopology
+{
+public:
+  CPhysicalTopology() = default;
+  CPhysicalTopology(bool bProvidesInput, std::vector<CPhysicalPort> ports);
+
+  void Reset();
+
+  /*!
+   * \brief Check if the controller can provide player input
+   *
+   * This allows hubs to specify that they provide no input
+   *
+   * \return True if the controller can provide player input, false otherwise
+   */
+  bool ProvidesInput() const { return m_bProvidesInput; }
+
+  /*!
+   * \brief Get a list of ports provided by this controller
+   *
+   * \return The ports
+   */
+  const std::vector<CPhysicalPort>& Ports() const { return m_ports; }
+
+  bool Deserialize(const TiXmlElement* pElement);
+
+private:
+  bool m_bProvidesInput = true;
+  std::vector<CPhysicalPort> m_ports;
+};
+
+} // namespace GAME
+} // namespace KODI
diff --git a/xbmc/games/controllers/types/CMakeLists.txt b/xbmc/games/controllers/types/CMakeLists.txt
new file mode 100644
index 0000000..503d254
--- /dev/null
+++ b/xbmc/games/controllers/types/CMakeLists.txt
@@ -0,0 +1,12 @@
+set(SOURCES ControllerGrid.cpp
+            ControllerHub.cpp
+            ControllerNode.cpp
+)
+
+set(HEADERS ControllerGrid.h
+            ControllerHub.h
+            ControllerNode.h
+            ControllerTree.h
+)
+
+core_add_library(games_controller_types)
diff --git a/xbmc/games/controllers/types/ControllerGrid.cpp b/xbmc/games/controllers/types/ControllerGrid.cpp
new file mode 100644
index 0000000..f718d5a
--- /dev/null
+++ b/xbmc/games/controllers/types/ControllerGrid.cpp
@@ -0,0 +1,242 @@
+/*
+ *  Copyright (C) 2017-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#include "ControllerGrid.h"
+
+#include "games/controllers/Controller.h"
+#include "utils/log.h"
+
+#include <algorithm>
+#include <utility>
+
+using namespace KODI;
+using namespace GAME;
+
+CControllerGrid::~CControllerGrid() = default;
+
+void CControllerGrid::SetControllerTree(const CControllerTree& controllerTree)
+{
+  // Clear the result
+  m_grid.clear();
+
+  m_height = AddPorts(controllerTree.GetPorts(), m_grid);
+  SetHeight(m_height, m_grid);
+}
+
+ControllerVector CControllerGrid::GetControllers(unsigned int playerIndex) const
+{
+  ControllerVector controllers;
+
+  if (playerIndex < m_grid.size())
+  {
+    for (const auto& controllerVertex : m_grid[playerIndex].vertices)
+    {
+      if (controllerVertex.controller)
+        controllers.emplace_back(controllerVertex.controller);
+    }
+  }
+
+  return controllers;
+}
+
+unsigned int CControllerGrid::AddPorts(const PortVec& ports, ControllerGrid& grid)
+{
+  unsigned int height = 0;
+
+  auto itKeyboard = std::find_if(ports.begin(), ports.end(), [](const CPortNode& port) {
+    return port.GetPortType() == PORT_TYPE::KEYBOARD;
+  });
+
+  auto itMouse = std::find_if(ports.begin(), ports.end(), [](const CPortNode& port) {
+    return port.GetPortType() == PORT_TYPE::MOUSE;
+  });
+
+  auto itController = std::find_if(ports.begin(), ports.end(), [](const CPortNode& port) {
+    return port.GetPortType() == PORT_TYPE::CONTROLLER;
+  });
+
+  // Keyboard and mouse are not allowed to have ports because they might
+  // overlap with controllers
+  if (itKeyboard != ports.end() && itKeyboard->GetActiveController().GetHub().HasPorts())
+  {
+    CLog::Log(LOGERROR, "Found keyboard with controller ports, skipping");
+    itKeyboard = ports.end();
+  }
+  if (itMouse != ports.end() && itMouse->GetActiveController().GetHub().HasPorts())
+  {
+    CLog::Log(LOGERROR, "Found mouse with controller ports, skipping");
+    itMouse = ports.end();
+  }
+
+  if (itController != ports.end())
+  {
+    // Add controller ports
+    bool bFirstPlayer = true;
+    for (const CPortNode& port : ports)
+    {
+      ControllerColumn column;
+
+      if (port.GetPortType() == PORT_TYPE::CONTROLLER)
+      {
+        // Add controller
+        height =
+            std::max(height, AddController(port, static_cast<unsigned int>(column.vertices.size()),
+                                           column.vertices, grid));
+
+        if (bFirstPlayer)
+        {
+          bFirstPlayer = false;
+
+          // Keyboard and mouse are added below the first controller
+          if (itKeyboard != ports.end())
+            height =
+                std::max(height, AddController(*itKeyboard,
+                                               static_cast<unsigned int>(column.vertices.size()),
+                                               column.vertices, grid));
+          if (itMouse != ports.end())
+            height = std::max(
+                height, AddController(*itMouse, static_cast<unsigned int>(column.vertices.size()),
+                                      column.vertices, grid));
+        }
+      }
+
+      if (!column.vertices.empty())
+        grid.emplace_back(std::move(column));
+    }
+  }
+  else
+  {
+    // No controllers, add keyboard and mouse
+    ControllerColumn column;
+
+    if (itKeyboard != ports.end())
+      height = std::max(height, AddController(*itKeyboard,
+                                              static_cast<unsigned int>(column.vertices.size()),
+                                              column.vertices, grid));
+    if (itMouse != ports.end())
+      height = std::max(height,
+                        AddController(*itMouse, static_cast<unsigned int>(column.vertices.size()),
+                                      column.vertices, grid));
+
+    if (!column.vertices.empty())
+      grid.emplace_back(std::move(column));
+  }
+
+  return height;
+}
+
+unsigned int CControllerGrid::AddController(const CPortNode& port,
+                                            unsigned int height,
+                                            std::vector<ControllerVertex>& column,
+                                            ControllerGrid& grid)
+{
+  // Add spacers
+  while (column.size() < height)
+    AddInvisible(column);
+
+  const CControllerNode& activeController = port.GetActiveController();
+
+  // Add vertex
+  ControllerVertex vertex;
+  vertex.bVisible = true;
+  vertex.bConnected = port.IsConnected();
+  vertex.portType = port.GetPortType();
+  vertex.controller = activeController.GetController();
+  vertex.address = activeController.GetControllerAddress();
+  for (const CControllerNode& node : port.GetCompatibleControllers())
+    vertex.compatible.emplace_back(node.GetController());
+  column.emplace_back(std::move(vertex));
+
+  height++;
+
+  // Process ports
+  const PortVec& ports = activeController.GetHub().GetPorts();
+  if (!ports.empty())
+  {
+    switch (GetDirection(activeController))
+    {
+      case GRID_DIRECTION::RIGHT:
+      {
+        height = std::max(height, AddHub(ports, height - 1, false, grid));
+        break;
+      }
+      case GRID_DIRECTION::DOWN:
+      {
+        const unsigned int row = height;
+
+        // Add the first controller to the column
+        const CPortNode firstController = ports.at(0);
+        height = std::max(height, AddController(firstController, row, column, grid));
+
+        // Add the remaining controllers on the same row
+        height = std::max(height, AddHub(ports, row, true, grid));
+
+        break;
+      }
+    }
+  }
+
+  return height;
+}
+
+unsigned int CControllerGrid::AddHub(const PortVec& ports,
+                                     unsigned int height,
+                                     bool bSkipFirst,
+                                     ControllerGrid& grid)
+{
+  const unsigned int row = height;
+
+  unsigned int port = 0;
+  for (const auto& controllerPort : ports)
+  {
+    // If controller has no player, it has already added the hub's first controller
+    if (bSkipFirst && port == 0)
+      continue;
+
+    // Add a column for this controller
+    grid.emplace_back();
+    ControllerColumn& column = grid.back();
+
+    height = std::max(height, AddController(controllerPort, row, column.vertices, grid));
+
+    port++;
+  }
+
+  return height;
+}
+
+void CControllerGrid::AddInvisible(std::vector<ControllerVertex>& column)
+{
+  ControllerVertex vertex;
+  vertex.bVisible = false;
+  column.emplace_back(std::move(vertex));
+}
+
+void CControllerGrid::SetHeight(unsigned int height, ControllerGrid& grid)
+{
+  for (auto& column : grid)
+  {
+    while (static_cast<unsigned int>(column.vertices.size()) < height)
+      AddInvisible(column.vertices);
+  }
+}
+
+CControllerGrid::GRID_DIRECTION CControllerGrid::GetDirection(const CControllerNode& node)
+{
+  // Hub controllers are added horizontally, one per row.
+  //
+  // If the current controller offers a player spot, the row starts to the
+  // right at the same height as the controller.
+  //
+  // Otherwise, to row starts below the current controller in the same
+  // column.
+  if (node.ProvidesInput())
+    return GRID_DIRECTION::RIGHT;
+  else
+    return GRID_DIRECTION::DOWN;
+}
diff --git a/xbmc/games/controllers/types/ControllerGrid.h b/xbmc/games/controllers/types/ControllerGrid.h
new file mode 100644
index 0000000..44ec1d3
--- /dev/null
+++ b/xbmc/games/controllers/types/ControllerGrid.h
@@ -0,0 +1,167 @@
+/*
+ *  Copyright (C) 2017-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#pragma once
+
+#include "ControllerTree.h"
+#include "games/controllers/ControllerTypes.h"
+
+#include <string>
+#include <vector>
+
+namespace KODI
+{
+namespace GAME
+{
+/*!
+ * \brief Vertex in the grid of controllers
+ */
+struct ControllerVertex
+{
+  bool bVisible = true;
+  bool bConnected = false;
+  ControllerPtr controller; // Mandatory if connected
+  PORT_TYPE portType = PORT_TYPE::UNKNOWN; // Optional
+  std::string address; // Optional
+  ControllerVector compatible; // Compatible controllers
+};
+
+/*!
+ * \brief Column of controllers in the grid
+ */
+struct ControllerColumn
+{
+  std::vector<ControllerVertex> vertices;
+};
+
+/*!
+ * \brief Collection of controllers in a grid layout
+ */
+using ControllerGrid = std::vector<ControllerColumn>;
+
+/*!
+ * \brief Class to encapsulate grid operations
+ */
+class CControllerGrid
+{
+public:
+  CControllerGrid() = default;
+  CControllerGrid(const CControllerGrid& other) = default;
+  ~CControllerGrid();
+
+  /*!
+   * \brief Create a grid from a controller tree
+   */
+  void SetControllerTree(const CControllerTree& controllerTree);
+
+  /*!
+   * \brief Get the width of the controller grid
+   */
+  unsigned int GetWidth() const { return static_cast<unsigned int>(m_grid.size()); }
+
+  /*!
+   * \brief Get the height (deepest controller) of the controller grid
+   *
+   * The height is cached when the controller grid is created to avoid
+   * iterating the grid
+   */
+  unsigned int GetHeight() const { return m_height; }
+
+  /*!
+   * \brief Access the controller grid
+   */
+  const ControllerGrid& GetGrid() const { return m_grid; }
+
+  /*!
+   * \brief Get the controllers in use by the specified player
+   *
+   * \param playerIndex The column in the grid to get controllers from
+   */
+  ControllerVector GetControllers(unsigned int playerIndex) const;
+
+private:
+  /*!
+   * \brief Directions of vertex traversal
+   */
+  enum class GRID_DIRECTION
+  {
+    RIGHT,
+    DOWN,
+  };
+
+  /*!
+   * \brief Add ports to the grid
+   *
+   * \param ports The ports on a console or controller
+   * \param[out] grid The controller grid being created
+   *
+   * \return The height of the grid determined by the maximum column height
+   */
+  static unsigned int AddPorts(const PortVec& ports, ControllerGrid& grid);
+
+  /*!
+   * \brief Draw a controller to the column at the specified height
+   *
+   * \param port The controller's port node
+   * \param height The height to draw the controller at
+   * \param column[in/out] The column to draw to
+   * \param grid[in/out] The grid to add additional columns to
+   *
+   * \return The height of the grid
+   */
+  static unsigned int AddController(const CPortNode& port,
+                                    unsigned int height,
+                                    std::vector<ControllerVertex>& column,
+                                    ControllerGrid& grid);
+
+  /*!
+   * \brief Draw a series of controllers to the grid at the specified height
+   *
+   * \param ports The ports of the controllers to draw
+   * \param height The height to start drawing the controllers at
+   * \param bSkipFirst True if the first controller has already been drawn to
+   *                   a column, false to start drawing at the first controller
+   * \param grid[in/out] The grid to add columns to
+   *
+   * \return The height of the grid
+   */
+  static unsigned int AddHub(const PortVec& ports,
+                             unsigned int height,
+                             bool bSkipFirst,
+                             ControllerGrid& grid);
+
+  /*!
+   * \brief Draw an invisible vertex to the column
+   *
+   * \param[in/out] column The column in a controller grid
+   */
+  static void AddInvisible(std::vector<ControllerVertex>& column);
+
+  /*!
+   * \brief Fill all columns with invisible vertices until the specified height
+   *
+   * \param height The height to make all columns
+   * \param[in/out] grid The grid to update
+   */
+  static void SetHeight(unsigned int height, ControllerGrid& grid);
+
+  /*!
+   * \brief Get the direction of traversal for the next vertex
+   *
+   * \param node The node in the controller tree being visited
+   *
+   * \return The direction of the next vertex, or GRID_DIRECTION::UNKNOWN if
+   *         unknown
+   */
+  static GRID_DIRECTION GetDirection(const CControllerNode& node);
+
+  ControllerGrid m_grid;
+  unsigned int m_height = 0;
+};
+} // namespace GAME
+} // namespace KODI
diff --git a/xbmc/games/controllers/types/ControllerHub.cpp b/xbmc/games/controllers/types/ControllerHub.cpp
new file mode 100644
index 0000000..5fd0ece
--- /dev/null
+++ b/xbmc/games/controllers/types/ControllerHub.cpp
@@ -0,0 +1,109 @@
+/*
+ *  Copyright (C) 2017-2021 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#include "ControllerHub.h"
+
+#include "ControllerTree.h"
+#include "games/controllers/Controller.h"
+
+#include <algorithm>
+#include <utility>
+
+using namespace KODI;
+using namespace GAME;
+
+CControllerHub::~CControllerHub() = default;
+
+CControllerHub& CControllerHub::operator=(const CControllerHub& rhs)
+{
+  if (this != &rhs)
+  {
+    m_ports = rhs.m_ports;
+  }
+
+  return *this;
+}
+
+CControllerHub& CControllerHub::operator=(CControllerHub&& rhs) noexcept
+{
+  if (this != &rhs)
+  {
+    m_ports = std::move(rhs.m_ports);
+  }
+
+  return *this;
+}
+
+void CControllerHub::Clear()
+{
+  m_ports.clear();
+}
+
+void CControllerHub::SetPorts(PortVec ports)
+{
+  m_ports = std::move(ports);
+}
+
+bool CControllerHub::IsControllerAccepted(const std::string& controllerId) const
+{
+  return std::any_of(m_ports.begin(), m_ports.end(), [controllerId](const CPortNode& port) {
+    return port.IsControllerAccepted(controllerId);
+  });
+}
+
+bool CControllerHub::IsControllerAccepted(const std::string& portAddress,
+                                          const std::string& controllerId) const
+{
+  return std::any_of(m_ports.begin(), m_ports.end(),
+                     [portAddress, controllerId](const CPortNode& port) {
+                       return port.IsControllerAccepted(portAddress, controllerId);
+                     });
+}
+
+ControllerVector CControllerHub::GetControllers() const
+{
+  ControllerVector controllers;
+  GetControllers(controllers);
+  return controllers;
+}
+
+void CControllerHub::GetControllers(ControllerVector& controllers) const
+{
+  for (const CPortNode& port : m_ports)
+  {
+    for (const CControllerNode& node : port.GetCompatibleControllers())
+      node.GetControllers(controllers);
+  }
+}
+
+const CPortNode& CControllerHub::GetPort(const std::string& address) const
+{
+  return GetPortInternal(m_ports, address);
+}
+
+const CPortNode& CControllerHub::GetPortInternal(const PortVec& ports, const std::string& address)
+{
+  for (const CPortNode& port : ports)
+  {
+    // Base case
+    if (port.GetAddress() == address)
+      return port;
+
+    // Check children
+    for (const CControllerNode& controller : port.GetCompatibleControllers())
+    {
+      const CPortNode& port = GetPortInternal(controller.GetHub().GetPorts(), address);
+      if (port.GetAddress() == address)
+        return port;
+    }
+  }
+
+  // Not found
+  static const CPortNode empty{};
+  return empty;
+}
diff --git a/xbmc/games/controllers/types/ControllerHub.h b/xbmc/games/controllers/types/ControllerHub.h
new file mode 100644
index 0000000..fc48a81
--- /dev/null
+++ b/xbmc/games/controllers/types/ControllerHub.h
@@ -0,0 +1,53 @@
+/*
+ *  Copyright (C) 2017-2021 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#pragma once
+
+#include "games/controllers/ControllerTypes.h"
+#include "games/ports/types/PortNode.h"
+
+#include <string>
+
+namespace KODI
+{
+namespace GAME
+{
+/*!
+ * \brief A branch in the controller tree
+ */
+class CControllerHub
+{
+public:
+  CControllerHub() = default;
+  CControllerHub(const CControllerHub& other) { *this = other; }
+  CControllerHub(CControllerHub&& other) = default;
+  CControllerHub& operator=(const CControllerHub& rhs);
+  CControllerHub& operator=(CControllerHub&& rhs) noexcept;
+  ~CControllerHub();
+
+  void Clear();
+
+  bool HasPorts() const { return !m_ports.empty(); }
+  PortVec& GetPorts() { return m_ports; }
+  const PortVec& GetPorts() const { return m_ports; }
+  void SetPorts(PortVec ports);
+
+  bool IsControllerAccepted(const std::string& controllerId) const;
+  bool IsControllerAccepted(const std::string& portAddress, const std::string& controllerId) const;
+  ControllerVector GetControllers() const;
+  void GetControllers(ControllerVector& controllers) const;
+
+  const CPortNode& GetPort(const std::string& address) const;
+
+private:
+  static const CPortNode& GetPortInternal(const PortVec& ports, const std::string& address);
+
+  PortVec m_ports;
+};
+} // namespace GAME
+} // namespace KODI
diff --git a/xbmc/games/controllers/types/ControllerNode.cpp b/xbmc/games/controllers/types/ControllerNode.cpp
new file mode 100644
index 0000000..4bfda73
--- /dev/null
+++ b/xbmc/games/controllers/types/ControllerNode.cpp
@@ -0,0 +1,136 @@
+/*
+ *  Copyright (C) 2017-2021 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#include "ControllerNode.h"
+
+#include "ControllerHub.h"
+#include "games/controllers/Controller.h"
+#include "games/controllers/input/PhysicalTopology.h"
+#include "games/ports/types/PortNode.h"
+
+#include <algorithm>
+#include <utility>
+
+using namespace KODI;
+using namespace GAME;
+
+CControllerNode::CControllerNode() : m_hub(new CControllerHub)
+{
+}
+
+CControllerNode::~CControllerNode() = default;
+
+CControllerNode& CControllerNode::operator=(const CControllerNode& rhs)
+{
+  if (this != &rhs)
+  {
+    m_controller = rhs.m_controller;
+    m_portAddress = rhs.m_portAddress;
+    m_controllerAddress = rhs.m_controllerAddress;
+    m_hub.reset(new CControllerHub(*rhs.m_hub));
+  }
+
+  return *this;
+}
+
+CControllerNode& CControllerNode::operator=(CControllerNode&& rhs) noexcept
+{
+  if (this != &rhs)
+  {
+    m_controller = std::move(rhs.m_controller);
+    m_portAddress = std::move(rhs.m_portAddress);
+    m_controllerAddress = std::move(rhs.m_controllerAddress);
+    m_hub = std::move(rhs.m_hub);
+  }
+
+  return *this;
+}
+
+void CControllerNode::Clear()
+{
+  m_controller.reset();
+  m_portAddress.clear();
+  m_controllerAddress.clear();
+  m_hub.reset(new CControllerHub);
+}
+
+void CControllerNode::SetController(ControllerPtr controller)
+{
+  m_controller = std::move(controller);
+}
+
+void CControllerNode::GetControllers(ControllerVector& controllers) const
+{
+  if (m_controller)
+  {
+    const ControllerPtr& myController = m_controller;
+
+    auto it = std::find_if(controllers.begin(), controllers.end(),
+                           [&myController](const ControllerPtr& controller) {
+                             return myController->ID() == controller->ID();
+                           });
+
+    if (it == controllers.end())
+      controllers.emplace_back(m_controller);
+  }
+
+  m_hub->GetControllers(controllers);
+}
+
+void CControllerNode::SetPortAddress(std::string portAddress)
+{
+  m_portAddress = std::move(portAddress);
+}
+
+void CControllerNode::SetControllerAddress(std::string controllerAddress)
+{
+  m_controllerAddress = std::move(controllerAddress);
+}
+
+void CControllerNode::SetHub(CControllerHub hub)
+{
+  m_hub.reset(new CControllerHub(std::move(hub)));
+}
+
+bool CControllerNode::IsControllerAccepted(const std::string& controllerId) const
+{
+  bool bAccepted = false;
+
+  for (const auto& port : m_hub->GetPorts())
+  {
+    if (port.IsControllerAccepted(controllerId))
+    {
+      bAccepted = true;
+      break;
+    }
+  }
+
+  return bAccepted;
+}
+
+bool CControllerNode::IsControllerAccepted(const std::string& portAddress,
+                                           const std::string& controllerId) const
+{
+  bool bAccepted = false;
+
+  for (const auto& port : m_hub->GetPorts())
+  {
+    if (port.IsControllerAccepted(portAddress, controllerId))
+    {
+      bAccepted = true;
+      break;
+    }
+  }
+
+  return bAccepted;
+}
+
+bool CControllerNode::ProvidesInput() const
+{
+  return m_controller && m_controller->Topology().ProvidesInput();
+}
diff --git a/xbmc/games/controllers/types/ControllerNode.h b/xbmc/games/controllers/types/ControllerNode.h
new file mode 100644
index 0000000..d4d86e5
--- /dev/null
+++ b/xbmc/games/controllers/types/ControllerNode.h
@@ -0,0 +1,118 @@
+/*
+ *  Copyright (C) 2017-2021 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#pragma once
+
+#include "games/controllers/ControllerTypes.h"
+
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace KODI
+{
+namespace GAME
+{
+class CControllerHub;
+
+/*!
+ * \brief Node in the controller tree
+ *
+ * The node identifies the controller profile, and optionally the available
+ * controller ports.
+ */
+class CControllerNode
+{
+public:
+  CControllerNode();
+  CControllerNode(const CControllerNode& other) { *this = other; }
+  CControllerNode(CControllerNode&& other) = default;
+  CControllerNode& operator=(const CControllerNode& rhs);
+  CControllerNode& operator=(CControllerNode&& rhs) noexcept;
+  ~CControllerNode();
+
+  void Clear();
+
+  /*!
+   * \brief Controller profile of this code
+   *
+   * \return Controller profile, or empty if this node is invalid
+   *
+   * \sa IsValid()
+   */
+  const ControllerPtr& GetController() const { return m_controller; }
+  void SetController(ControllerPtr controller);
+
+  void GetControllers(ControllerVector& controllers) const;
+
+  /*!
+   * \brief Address given to the controller's port by the implementation
+   */
+  const std::string& GetPortAddress() const { return m_portAddress; }
+  void SetPortAddress(std::string portAddress);
+
+  /*!
+   * \brief Address given to the controller node by the implementation
+   */
+  const std::string& GetControllerAddress() const { return m_controllerAddress; }
+  void SetControllerAddress(std::string controllerAddress);
+
+  /*!
+   * \brief Collection of ports on this controller
+   *
+   * \return A hub with controller ports, or an empty hub if this controller
+   *         has no available ports
+   */
+  const CControllerHub& GetHub() const { return *m_hub; }
+  CControllerHub& GetHub() { return *m_hub; }
+  void SetHub(CControllerHub hub);
+
+  /*!
+   * \brief Check if this node has a valid controller profile
+   */
+  bool IsValid() const { return static_cast<bool>(m_controller); }
+
+  /*!
+   * \brief Check to see if a controller is compatible with a controller port
+   *
+   * \param controllerId The ID of the controller
+   *
+   * \return True if the controller is compatible with a port, false otherwise
+   */
+  bool IsControllerAccepted(const std::string& controllerId) const;
+
+  /*!
+   * \brief Check to see if a controller is compatible with a controller port
+   *
+   * \param portAddress The port address
+   * \param controllerId The ID of the controller
+   *
+   * \return True if the controller is compatible with a port, false otherwise
+   */
+  bool IsControllerAccepted(const std::string& portAddress, const std::string& controllerId) const;
+
+  /*!
+   * \brief Check if this node provides input
+   */
+  bool ProvidesInput() const;
+
+private:
+  ControllerPtr m_controller;
+
+  // Address of the port this controller is connected to
+  std::string m_portAddress;
+
+  // Address of this controller: m_portAddress + "/" + m_controller->ID()
+  std::string m_controllerAddress;
+
+  std::unique_ptr<CControllerHub> m_hub;
+};
+
+using ControllerNodeVec = std::vector<CControllerNode>;
+} // namespace GAME
+} // namespace KODI
diff --git a/xbmc/games/controllers/types/ControllerTree.h b/xbmc/games/controllers/types/ControllerTree.h
new file mode 100644
index 0000000..47e42e9
--- /dev/null
+++ b/xbmc/games/controllers/types/ControllerTree.h
@@ -0,0 +1,30 @@
+/*
+ *  Copyright (C) 2017-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#pragma once
+
+//
+// Note: Hierarchy of headers is:
+//
+//  - ControllerTree.h (this file)
+//    - ControllerHub.h
+//      - PortNode.h
+//        - ControllerNode.h
+//
+#include "ControllerHub.h"
+
+namespace KODI
+{
+namespace GAME
+{
+/*!
+ * \brief Collection of ports on a console
+ */
+using CControllerTree = CControllerHub;
+} // namespace GAME
+} // namespace KODI
diff --git a/xbmc/games/controllers/windows/CMakeLists.txt b/xbmc/games/controllers/windows/CMakeLists.txt
new file mode 100644
index 0000000..72c8154
--- /dev/null
+++ b/xbmc/games/controllers/windows/CMakeLists.txt
@@ -0,0 +1,15 @@
+set(SOURCES GUIConfigurationWizard.cpp
+            GUIControllerList.cpp
+            GUIControllerWindow.cpp
+            GUIFeatureList.cpp
+)
+
+set(HEADERS GUIConfigurationWizard.h
+            GUIControllerDefines.h
+            GUIControllerList.h
+            GUIControllerWindow.h
+            GUIFeatureList.h
+            IConfigurationWindow.h
+)
+
+core_add_library(games_controller_windows)
diff --git a/xbmc/games/controllers/windows/GUIConfigurationWizard.cpp b/xbmc/games/controllers/windows/GUIConfigurationWizard.cpp
new file mode 100644
index 0000000..c2ac2f5
--- /dev/null
+++ b/xbmc/games/controllers/windows/GUIConfigurationWizard.cpp
@@ -0,0 +1,494 @@
+/*
+ *  Copyright (C) 2014-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#include "GUIConfigurationWizard.h"
+
+#include "ServiceBroker.h"
+#include "games/controllers/Controller.h"
+#include "games/controllers/dialogs/GUIDialogAxisDetection.h"
+#include "games/controllers/guicontrols/GUIFeatureButton.h"
+#include "games/controllers/input/PhysicalFeature.h"
+#include "input/IKeymap.h"
+#include "input/InputManager.h"
+#include "input/joysticks/JoystickUtils.h"
+#include "input/joysticks/interfaces/IButtonMap.h"
+#include "input/joysticks/interfaces/IButtonMapCallback.h"
+#include "input/keyboard/KeymapActionMap.h"
+#include "peripherals/Peripherals.h"
+#include "threads/SingleLock.h"
+#include "utils/log.h"
+
+#include <mutex>
+
+using namespace KODI;
+using namespace GAME;
+using namespace std::chrono_literals;
+
+namespace
+{
+
+#define ESC_KEY_CODE 27
+#define SKIPPING_DETECTION_MS 200
+
+// Duration to wait for axes to neutralize after mapping is finished
+constexpr auto POST_MAPPING_WAIT_TIME_MS = 5000ms;
+
+} // namespace
+
+CGUIConfigurationWizard::CGUIConfigurationWizard()
+  : CThread("GUIConfigurationWizard"), m_actionMap(new KEYBOARD::CKeymapActionMap)
+{
+  InitializeState();
+}
+
+CGUIConfigurationWizard::~CGUIConfigurationWizard(void) = default;
+
+void CGUIConfigurationWizard::InitializeState(void)
+{
+  m_currentButton = nullptr;
+  m_cardinalDirection = INPUT::CARDINAL_DIRECTION::NONE;
+  m_wheelDirection = JOYSTICK::WHEEL_DIRECTION::NONE;
+  m_throttleDirection = JOYSTICK::THROTTLE_DIRECTION::NONE;
+  m_history.clear();
+  m_lateAxisDetected = false;
+  m_location.clear();
+}
+
+void CGUIConfigurationWizard::Run(const std::string& strControllerId,
+                                  const std::vector<IFeatureButton*>& buttons)
+{
+  Abort();
+
+  {
+    std::unique_lock<CCriticalSection> lock(m_stateMutex);
+
+    // Set Run() parameters
+    m_strControllerId = strControllerId;
+    m_buttons = buttons;
+
+    // Reset synchronization variables
+    m_inputEvent.Reset();
+    m_motionlessEvent.Reset();
+    m_bInMotion.clear();
+
+    // Initialize state variables
+    InitializeState();
+  }
+
+  Create();
+}
+
+void CGUIConfigurationWizard::OnUnfocus(IFeatureButton* button)
+{
+  std::unique_lock<CCriticalSection> lock(m_stateMutex);
+
+  if (button == m_currentButton)
+    Abort(false);
+}
+
+bool CGUIConfigurationWizard::Abort(bool bWait /* = true */)
+{
+  bool bWasRunning = !m_bStop;
+
+  StopThread(false);
+
+  m_inputEvent.Set();
+  m_motionlessEvent.Set();
+
+  if (bWait)
+    StopThread(true);
+
+  return bWasRunning;
+}
+
+void CGUIConfigurationWizard::RegisterKey(const CPhysicalFeature& key)
+{
+  if (key.Keycode() != XBMCK_UNKNOWN)
+    m_keyMap[key.Keycode()] = key;
+}
+
+void CGUIConfigurationWizard::UnregisterKeys()
+{
+  m_keyMap.clear();
+}
+
+void CGUIConfigurationWizard::Process(void)
+{
+  CLog::Log(LOGDEBUG, "Starting configuration wizard");
+
+  InstallHooks();
+
+  bool bLateAxisDetected = false;
+
+  {
+    std::unique_lock<CCriticalSection> lock(m_stateMutex);
+    for (IFeatureButton* button : m_buttons)
+    {
+      // Allow other threads to access the button we're using
+      m_currentButton = button;
+
+      while (!button->IsFinished())
+      {
+        // Allow other threads to access which direction the prompt is on
+        m_cardinalDirection = button->GetCardinalDirection();
+        m_wheelDirection = button->GetWheelDirection();
+        m_throttleDirection = button->GetThrottleDirection();
+
+        // Wait for input
+        {
+          using namespace JOYSTICK;
+
+          CSingleExit exit(m_stateMutex);
+
+          if (button->Feature().Type() == FEATURE_TYPE::UNKNOWN)
+            CLog::Log(LOGDEBUG, "{}: Waiting for input", m_strControllerId);
+          else
+            CLog::Log(LOGDEBUG, "{}: Waiting for input for feature \"{}\"", m_strControllerId,
+                      button->Feature().Name());
+
+          if (!button->PromptForInput(m_inputEvent))
+            Abort(false);
+        }
+
+        if (m_bStop)
+          break;
+      }
+
+      button->Reset();
+
+      if (m_bStop)
+        break;
+    }
+
+    bLateAxisDetected = m_lateAxisDetected;
+
+    // Finished mapping
+    InitializeState();
+  }
+
+  for (auto callback : ButtonMapCallbacks())
+    callback.second->SaveButtonMap();
+
+  if (bLateAxisDetected)
+  {
+    CGUIDialogAxisDetection dialog;
+    dialog.Show();
+  }
+  else
+  {
+    // Wait for motion to stop to avoid sending analog actions for the button
+    // that is pressed immediately after button mapping finishes.
+    bool bInMotion;
+
+    {
+      std::unique_lock<CCriticalSection> lock(m_motionMutex);
+      bInMotion = !m_bInMotion.empty();
+    }
+
+    if (bInMotion)
+    {
+      CLog::Log(LOGDEBUG, "Configuration wizard: waiting {}ms for axes to neutralize",
+                POST_MAPPING_WAIT_TIME_MS.count());
+      m_motionlessEvent.Wait(POST_MAPPING_WAIT_TIME_MS);
+    }
+  }
+
+  RemoveHooks();
+
+  CLog::Log(LOGDEBUG, "Configuration wizard ended");
+}
+
+bool CGUIConfigurationWizard::MapPrimitive(JOYSTICK::IButtonMap* buttonMap,
+                                           IKeymap* keymap,
+                                           const JOYSTICK::CDriverPrimitive& primitive)
+{
+  using namespace INPUT;
+  using namespace JOYSTICK;
+
+  bool bHandled = false;
+
+  // Abort if another controller cancels the prompt
+  if (IsMapping() && !IsMapping(buttonMap->Location()))
+  {
+    //! @todo This only succeeds for game.controller.default; no actions are
+    //        currently defined for other controllers
+    if (keymap)
+    {
+      std::string feature;
+      if (buttonMap->GetFeature(primitive, feature))
+      {
+        const auto& actions = keymap->GetActions(CJoystickUtils::MakeKeyName(feature)).actions;
+        if (!actions.empty())
+        {
+          //! @todo Handle multiple actions mapped to the same key
+          OnAction(actions.begin()->actionId);
+        }
+      }
+    }
+
+    // Discard input
+    bHandled = true;
+  }
+  else if (m_history.find(primitive) != m_history.end())
+  {
+    // Primitive has already been mapped this round, ignore it
+    bHandled = true;
+  }
+  else if (buttonMap->IsIgnored(primitive))
+  {
+    bHandled = true;
+  }
+  else
+  {
+    // Get the current state of the thread
+    IFeatureButton* currentButton;
+    CARDINAL_DIRECTION cardinalDirection;
+    WHEEL_DIRECTION wheelDirection;
+    THROTTLE_DIRECTION throttleDirection;
+    {
+      std::unique_lock<CCriticalSection> lock(m_stateMutex);
+      currentButton = m_currentButton;
+      cardinalDirection = m_cardinalDirection;
+      wheelDirection = m_wheelDirection;
+      throttleDirection = m_throttleDirection;
+    }
+
+    if (currentButton)
+    {
+      // Check if we were expecting a keyboard key
+      if (currentButton->NeedsKey())
+      {
+        if (primitive.Type() == PRIMITIVE_TYPE::KEY)
+        {
+          auto it = m_keyMap.find(primitive.Keycode());
+          if (it != m_keyMap.end())
+          {
+            const CPhysicalFeature& key = it->second;
+            currentButton->SetKey(key);
+            m_inputEvent.Set();
+          }
+        }
+        else
+        {
+          //! @todo Check if primitive is a cancel or motion action
+        }
+        bHandled = true;
+      }
+      else
+      {
+        const CPhysicalFeature& feature = currentButton->Feature();
+
+        if (primitive.Type() == PRIMITIVE_TYPE::RELATIVE_POINTER &&
+            feature.Type() != FEATURE_TYPE::RELPOINTER)
+        {
+          // Don't allow relative pointers to map to other features
+        }
+        else
+        {
+          CLog::Log(LOGDEBUG, "{}: mapping feature \"{}\" for device {} to \"{}\"",
+                    m_strControllerId, feature.Name(), buttonMap->Location(), primitive.ToString());
+
+          switch (feature.Type())
+          {
+            case FEATURE_TYPE::SCALAR:
+            {
+              buttonMap->AddScalar(feature.Name(), primitive);
+              bHandled = true;
+              break;
+            }
+            case FEATURE_TYPE::ANALOG_STICK:
+            {
+              buttonMap->AddAnalogStick(feature.Name(), cardinalDirection, primitive);
+              bHandled = true;
+              break;
+            }
+            case FEATURE_TYPE::RELPOINTER:
+            {
+              buttonMap->AddRelativePointer(feature.Name(), cardinalDirection, primitive);
+              bHandled = true;
+              break;
+            }
+            case FEATURE_TYPE::WHEEL:
+            {
+              buttonMap->AddWheel(feature.Name(), wheelDirection, primitive);
+              bHandled = true;
+              break;
+            }
+            case FEATURE_TYPE::THROTTLE:
+            {
+              buttonMap->AddThrottle(feature.Name(), throttleDirection, primitive);
+              bHandled = true;
+              break;
+            }
+            case FEATURE_TYPE::KEY:
+            {
+              buttonMap->AddKey(feature.Name(), primitive);
+              bHandled = true;
+              break;
+            }
+            default:
+              break;
+          }
+        }
+
+        if (bHandled)
+        {
+          m_history.insert(primitive);
+
+          // Don't record motion for relative pointers
+          if (primitive.Type() != PRIMITIVE_TYPE::RELATIVE_POINTER)
+            OnMotion(buttonMap);
+
+          m_inputEvent.Set();
+
+          if (m_location.empty())
+          {
+            m_location = buttonMap->Location();
+            m_bIsKeyboard = (primitive.Type() == PRIMITIVE_TYPE::KEY);
+          }
+        }
+      }
+    }
+  }
+
+  return bHandled;
+}
+
+void CGUIConfigurationWizard::OnEventFrame(const JOYSTICK::IButtonMap* buttonMap, bool bMotion)
+{
+  std::unique_lock<CCriticalSection> lock(m_motionMutex);
+
+  if (m_bInMotion.find(buttonMap) != m_bInMotion.end() && !bMotion)
+    OnMotionless(buttonMap);
+}
+
+void CGUIConfigurationWizard::OnLateAxis(const JOYSTICK::IButtonMap* buttonMap,
+                                         unsigned int axisIndex)
+{
+  std::unique_lock<CCriticalSection> lock(m_stateMutex);
+
+  m_lateAxisDetected = true;
+  Abort(false);
+}
+
+void CGUIConfigurationWizard::OnMotion(const JOYSTICK::IButtonMap* buttonMap)
+{
+  std::unique_lock<CCriticalSection> lock(m_motionMutex);
+
+  m_motionlessEvent.Reset();
+  m_bInMotion.insert(buttonMap);
+}
+
+void CGUIConfigurationWizard::OnMotionless(const JOYSTICK::IButtonMap* buttonMap)
+{
+  m_bInMotion.erase(buttonMap);
+  if (m_bInMotion.empty())
+    m_motionlessEvent.Set();
+}
+
+bool CGUIConfigurationWizard::OnKeyPress(const CKey& key)
+{
+  bool bHandled = false;
+
+  if (!m_bStop)
+  {
+    // Only allow key to abort the prompt if we know for sure that we're mapping
+    // a controller
+    const bool bIsMappingController = (IsMapping() && !m_bIsKeyboard);
+
+    if (bIsMappingController)
+    {
+      bHandled = OnAction(m_actionMap->GetActionID(key));
+    }
+    else
+    {
+      // Allow key press to fall through to the button mapper
+    }
+  }
+
+  return bHandled;
+}
+
+bool CGUIConfigurationWizard::OnAction(unsigned int actionId)
+{
+  bool bHandled = false;
+
+  switch (actionId)
+  {
+    case ACTION_MOVE_LEFT:
+    case ACTION_MOVE_RIGHT:
+    case ACTION_MOVE_UP:
+    case ACTION_MOVE_DOWN:
+    case ACTION_PAGE_UP:
+    case ACTION_PAGE_DOWN:
+      // Abort and allow motion
+      Abort(false);
+      bHandled = false;
+      break;
+
+    case ACTION_PARENT_DIR:
+    case ACTION_PREVIOUS_MENU:
+    case ACTION_STOP:
+    case ACTION_NAV_BACK:
+      // Abort and prevent action
+      Abort(false);
+      bHandled = true;
+      break;
+
+    default:
+      // Absorb keypress
+      bHandled = true;
+      break;
+  }
+
+  return bHandled;
+}
+
+bool CGUIConfigurationWizard::IsMapping() const
+{
+  return !m_location.empty();
+}
+
+bool CGUIConfigurationWizard::IsMapping(const std::string& location) const
+{
+  return m_location == location;
+}
+
+void CGUIConfigurationWizard::InstallHooks(void)
+{
+  // Install button mapper with lowest priority
+  CServiceBroker::GetPeripherals().RegisterJoystickButtonMapper(this);
+
+  // Install hook to reattach button mapper when peripherals change
+  CServiceBroker::GetPeripherals().RegisterObserver(this);
+
+  // Install hook to cancel the button mapper
+  CServiceBroker::GetInputManager().RegisterKeyboardDriverHandler(this);
+}
+
+void CGUIConfigurationWizard::RemoveHooks(void)
+{
+  CServiceBroker::GetInputManager().UnregisterKeyboardDriverHandler(this);
+  CServiceBroker::GetPeripherals().UnregisterObserver(this);
+  CServiceBroker::GetPeripherals().UnregisterJoystickButtonMapper(this);
+}
+
+void CGUIConfigurationWizard::Notify(const Observable& obs, const ObservableMessage msg)
+{
+  switch (msg)
+  {
+    case ObservableMessagePeripheralsChanged:
+    {
+      CServiceBroker::GetPeripherals().UnregisterJoystickButtonMapper(this);
+      CServiceBroker::GetPeripherals().RegisterJoystickButtonMapper(this);
+      break;
+    }
+    default:
+      break;
+  }
+}
diff --git a/xbmc/games/controllers/windows/GUIConfigurationWizard.h b/xbmc/games/controllers/windows/GUIConfigurationWizard.h
new file mode 100644
index 0000000..b69badf
--- /dev/null
+++ b/xbmc/games/controllers/windows/GUIConfigurationWizard.h
@@ -0,0 +1,117 @@
+/*
+ *  Copyright (C) 2014-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#pragma once
+
+#include "IConfigurationWindow.h"
+#include "games/controllers/input/PhysicalFeature.h"
+#include "input/XBMC_keysym.h"
+#include "input/joysticks/DriverPrimitive.h"
+#include "input/joysticks/interfaces/IButtonMapper.h"
+#include "input/keyboard/interfaces/IKeyboardDriverHandler.h"
+#include "threads/CriticalSection.h"
+#include "threads/Event.h"
+#include "threads/Thread.h"
+#include "utils/Observer.h"
+
+#include <map>
+#include <memory>
+#include <set>
+#include <string>
+#include <vector>
+
+namespace KODI
+{
+namespace KEYBOARD
+{
+class IActionMap;
+}
+
+namespace GAME
+{
+class CGUIConfigurationWizard : public IConfigurationWizard,
+                                public JOYSTICK::IButtonMapper,
+                                public KEYBOARD::IKeyboardDriverHandler,
+                                public Observer,
+                                protected CThread
+{
+public:
+  CGUIConfigurationWizard();
+
+  ~CGUIConfigurationWizard() override;
+
+  // implementation of IConfigurationWizard
+  void Run(const std::string& strControllerId,
+           const std::vector<IFeatureButton*>& buttons) override;
+  void OnUnfocus(IFeatureButton* button) override;
+  bool Abort(bool bWait = true) override;
+  void RegisterKey(const CPhysicalFeature& key) override;
+  void UnregisterKeys() override;
+
+  // implementation of IButtonMapper
+  std::string ControllerID() const override { return m_strControllerId; }
+  bool NeedsCooldown() const override { return true; }
+  bool AcceptsPrimitive(JOYSTICK::PRIMITIVE_TYPE type) const override { return true; }
+  bool MapPrimitive(JOYSTICK::IButtonMap* buttonMap,
+                    IKeymap* keymap,
+                    const JOYSTICK::CDriverPrimitive& primitive) override;
+  void OnEventFrame(const JOYSTICK::IButtonMap* buttonMap, bool bMotion) override;
+  void OnLateAxis(const JOYSTICK::IButtonMap* buttonMap, unsigned int axisIndex) override;
+
+  // implementation of IKeyboardDriverHandler
+  bool OnKeyPress(const CKey& key) override;
+  void OnKeyRelease(const CKey& key) override {}
+
+  // implementation of Observer
+  void Notify(const Observable& obs, const ObservableMessage msg) override;
+
+protected:
+  // implementation of CThread
+  void Process() override;
+
+private:
+  void InitializeState(void);
+
+  bool IsMapping() const;
+  bool IsMapping(const std::string& location) const;
+
+  void InstallHooks(void);
+  void RemoveHooks(void);
+
+  void OnMotion(const JOYSTICK::IButtonMap* buttonMap);
+  void OnMotionless(const JOYSTICK::IButtonMap* buttonMap);
+
+  bool OnAction(unsigned int actionId);
+
+  // Run() parameters
+  std::string m_strControllerId;
+  std::vector<IFeatureButton*> m_buttons;
+
+  // State variables and mutex
+  IFeatureButton* m_currentButton;
+  INPUT::CARDINAL_DIRECTION m_cardinalDirection;
+  JOYSTICK::WHEEL_DIRECTION m_wheelDirection;
+  JOYSTICK::THROTTLE_DIRECTION m_throttleDirection;
+  std::set<JOYSTICK::CDriverPrimitive> m_history; // History to avoid repeated features
+  bool m_lateAxisDetected; // Set to true if an axis is detected during button mapping
+  std::string m_location; // Peripheral location of device that we're mapping
+  bool m_bIsKeyboard = false; // True if we're mapping keyboard keys
+  CCriticalSection m_stateMutex;
+
+  // Synchronization events
+  CEvent m_inputEvent;
+  CEvent m_motionlessEvent;
+  CCriticalSection m_motionMutex;
+  std::set<const JOYSTICK::IButtonMap*> m_bInMotion;
+
+  // Keyboard handling
+  std::unique_ptr<KEYBOARD::IActionMap> m_actionMap;
+  std::map<XBMCKey, CPhysicalFeature> m_keyMap; // Keycode -> feature
+};
+} // namespace GAME
+} // namespace KODI
diff --git a/xbmc/games/controllers/windows/GUIControllerDefines.h b/xbmc/games/controllers/windows/GUIControllerDefines.h
new file mode 100644
index 0000000..64d2142
--- /dev/null
+++ b/xbmc/games/controllers/windows/GUIControllerDefines.h
@@ -0,0 +1,45 @@
+/*
+ *  Copyright (C) 2014-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#pragma once
+
+// Duration to wait for input from the user
+#define COUNTDOWN_DURATION_SEC 6
+
+// Warn the user that time is running out after this duration
+#define WAIT_TO_WARN_SEC 2
+
+// GUI Control IDs
+#define CONTROL_CONTROLLER_LIST 3
+#define CONTROL_FEATURE_LIST 5
+#define CONTROL_FEATURE_BUTTON_TEMPLATE 7
+#define CONTROL_FEATURE_GROUP_TITLE 8
+#define CONTROL_FEATURE_SEPARATOR 9
+#define CONTROL_CONTROLLER_BUTTON_TEMPLATE 10
+#define CONTROL_GAME_CONTROLLER 31
+#define CONTROL_CONTROLLER_DESCRIPTION 32
+
+// GUI button IDs
+#define CONTROL_HELP_BUTTON 17
+#define CONTROL_CLOSE_BUTTON 18
+#define CONTROL_RESET_BUTTON 19
+#define CONTROL_GET_MORE 20
+#define CONTROL_FIX_SKIPPING 21
+#define CONTROL_GET_ALL 22
+
+#define MAX_CONTROLLER_COUNT 100 // large enough
+#define MAX_FEATURE_COUNT 200 // large enough
+
+#define CONTROL_CONTROLLER_BUTTONS_START 100
+#define CONTROL_CONTROLLER_BUTTONS_END (CONTROL_CONTROLLER_BUTTONS_START + MAX_CONTROLLER_COUNT)
+#define CONTROL_FEATURE_BUTTONS_START CONTROL_CONTROLLER_BUTTONS_END
+#define CONTROL_FEATURE_BUTTONS_END (CONTROL_FEATURE_BUTTONS_START + MAX_FEATURE_COUNT)
+#define CONTROL_FEATURE_GROUPS_START CONTROL_FEATURE_BUTTONS_END
+#define CONTROL_FEATURE_GROUPS_END (CONTROL_FEATURE_GROUPS_START + MAX_FEATURE_COUNT)
+#define CONTROL_FEATURE_SEPARATORS_START CONTROL_FEATURE_GROUPS_END
+#define CONTROL_FEATURE_SEPARATORS_END (CONTROL_FEATURE_SEPARATORS_START + MAX_FEATURE_COUNT)
diff --git a/xbmc/games/controllers/windows/GUIControllerList.cpp b/xbmc/games/controllers/windows/GUIControllerList.cpp
new file mode 100644
index 0000000..02f8d37
--- /dev/null
+++ b/xbmc/games/controllers/windows/GUIControllerList.cpp
@@ -0,0 +1,239 @@
+/*
+ *  Copyright (C) 2014-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#include "GUIControllerList.h"
+
+#include "GUIControllerDefines.h"
+#include "GUIControllerWindow.h"
+#include "GUIFeatureList.h"
+#include "ServiceBroker.h"
+#include "addons/AddonManager.h"
+#include "dialogs/GUIDialogYesNo.h"
+#include "games/GameServices.h"
+#include "games/addons/GameClient.h"
+#include "games/addons/input/GameClientInput.h"
+#include "games/controllers/Controller.h"
+#include "games/controllers/ControllerIDs.h"
+#include "games/controllers/ControllerLayout.h"
+#include "games/controllers/guicontrols/GUIControllerButton.h"
+#include "games/controllers/guicontrols/GUIGameController.h"
+#include "games/controllers/types/ControllerTree.h"
+#include "guilib/GUIButtonControl.h"
+#include "guilib/GUIControlGroupList.h"
+#include "guilib/GUIMessage.h"
+#include "guilib/GUIWindow.h"
+#include "messaging/ApplicationMessenger.h"
+#include "peripherals/Peripherals.h"
+#include "utils/StringUtils.h"
+
+#include <algorithm>
+#include <assert.h>
+#include <iterator>
+
+using namespace KODI;
+using namespace ADDON;
+using namespace GAME;
+
+CGUIControllerList::CGUIControllerList(CGUIWindow* window,
+                                       IFeatureList* featureList,
+                                       GameClientPtr gameClient)
+  : m_guiWindow(window),
+    m_featureList(featureList),
+    m_controllerList(nullptr),
+    m_controllerButton(nullptr),
+    m_focusedController(-1), // Initially unfocused
+    m_gameClient(std::move(gameClient))
+{
+  assert(m_featureList != nullptr);
+}
+
+bool CGUIControllerList::Initialize(void)
+{
+  m_controllerList =
+      dynamic_cast<CGUIControlGroupList*>(m_guiWindow->GetControl(CONTROL_CONTROLLER_LIST));
+  m_controllerButton =
+      dynamic_cast<CGUIButtonControl*>(m_guiWindow->GetControl(CONTROL_CONTROLLER_BUTTON_TEMPLATE));
+
+  if (m_controllerButton)
+    m_controllerButton->SetVisible(false);
+
+  CServiceBroker::GetAddonMgr().Events().Subscribe(this, &CGUIControllerList::OnEvent);
+  Refresh("");
+
+  return m_controllerList != nullptr && m_controllerButton != nullptr;
+}
+
+void CGUIControllerList::Deinitialize(void)
+{
+  CServiceBroker::GetAddonMgr().Events().Unsubscribe(this);
+
+  CleanupButtons();
+
+  m_controllerList = nullptr;
+  m_controllerButton = nullptr;
+}
+
+bool CGUIControllerList::Refresh(const std::string& controllerId)
+{
+  // Focus specified controller after refresh
+  std::string focusController = controllerId;
+
+  if (focusController.empty() && m_focusedController >= 0)
+  {
+    // If controller ID wasn't provided, focus current controller
+    focusController = m_controllers[m_focusedController]->ID();
+  }
+
+  if (!RefreshControllers())
+    return false;
+
+  CleanupButtons();
+
+  if (m_controllerList)
+  {
+    unsigned int buttonId = 0;
+    for (const auto& controller : m_controllers)
+    {
+      CGUIButtonControl* pButton =
+          new CGUIControllerButton(*m_controllerButton, controller->Layout().Label(), buttonId++);
+      m_controllerList->AddControl(pButton);
+
+      if (!focusController.empty() && controller->ID() == focusController)
+      {
+        CGUIMessage msg(GUI_MSG_SETFOCUS, m_guiWindow->GetID(), pButton->GetID());
+        m_guiWindow->OnMessage(msg);
+      }
+
+      // Just in case
+      if (buttonId >= MAX_CONTROLLER_COUNT)
+        break;
+    }
+  }
+
+  return true;
+}
+
+void CGUIControllerList::OnFocus(unsigned int controllerIndex)
+{
+  if (controllerIndex < m_controllers.size())
+  {
+    m_focusedController = controllerIndex;
+
+    const ControllerPtr& controller = m_controllers[controllerIndex];
+    m_featureList->Load(controller);
+
+    //! @todo Activate controller for all game controller controls
+    CGUIGameController* pController =
+        dynamic_cast<CGUIGameController*>(m_guiWindow->GetControl(CONTROL_GAME_CONTROLLER));
+    if (pController)
+      pController->ActivateController(controller);
+
+    // Update controller description
+    CGUIMessage msg(GUI_MSG_LABEL_SET, m_guiWindow->GetID(), CONTROL_CONTROLLER_DESCRIPTION);
+    msg.SetLabel(controller->Description());
+    m_guiWindow->OnMessage(msg);
+  }
+}
+
+void CGUIControllerList::OnSelect(unsigned int controllerIndex)
+{
+  m_featureList->OnSelect(0);
+}
+
+void CGUIControllerList::ResetController(void)
+{
+  if (0 <= m_focusedController && m_focusedController < (int)m_controllers.size())
+  {
+    const std::string strControllerId = m_controllers[m_focusedController]->ID();
+
+    //! @todo Choose peripheral
+    // For now, ask the user if they would like to reset all peripherals
+    // "Reset controller profile"
+    // "Would you like to reset this controller profile for all devices?"
+    if (!CGUIDialogYesNo::ShowAndGetInput(35060, 35061))
+      return;
+
+    CServiceBroker::GetPeripherals().ResetButtonMaps(strControllerId);
+  }
+}
+
+void CGUIControllerList::OnEvent(const ADDON::AddonEvent& event)
+{
+  if (typeid(event) == typeid(ADDON::AddonEvents::Enabled) || // also called on install,
+      typeid(event) == typeid(ADDON::AddonEvents::Disabled) || // not called on uninstall
+      typeid(event) == typeid(ADDON::AddonEvents::ReInstalled) ||
+      typeid(event) == typeid(ADDON::AddonEvents::UnInstalled))
+  {
+    CGUIMessage msg(GUI_MSG_REFRESH_LIST, m_guiWindow->GetID(), CONTROL_CONTROLLER_LIST);
+
+    // Focus installed add-on
+    if (typeid(event) == typeid(ADDON::AddonEvents::Enabled) ||
+        typeid(event) == typeid(ADDON::AddonEvents::ReInstalled))
+      msg.SetStringParam(event.addonId);
+
+    CServiceBroker::GetAppMessenger()->SendGUIMessage(msg, m_guiWindow->GetID());
+  }
+}
+
+bool CGUIControllerList::RefreshControllers(void)
+{
+  // Get current controllers
+  CGameServices& gameServices = CServiceBroker::GetGameServices();
+  ControllerVector newControllers = gameServices.GetControllers();
+
+  // Filter by current game add-on
+  if (m_gameClient)
+  {
+    const CControllerTree& controllers = m_gameClient->Input().GetDefaultControllerTree();
+
+    auto ControllerNotAccepted = [&controllers](const ControllerPtr& controller) {
+      return !controllers.IsControllerAccepted(controller->ID());
+    };
+
+    if (!std::all_of(newControllers.begin(), newControllers.end(), ControllerNotAccepted))
+      newControllers.erase(
+          std::remove_if(newControllers.begin(), newControllers.end(), ControllerNotAccepted),
+          newControllers.end());
+  }
+
+  // Check for changes
+  std::set<std::string> oldControllerIds;
+  std::set<std::string> newControllerIds;
+
+  auto GetControllerID = [](const ControllerPtr& controller) { return controller->ID(); };
+
+  std::transform(m_controllers.begin(), m_controllers.end(),
+                 std::inserter(oldControllerIds, oldControllerIds.begin()), GetControllerID);
+  std::transform(newControllers.begin(), newControllers.end(),
+                 std::inserter(newControllerIds, newControllerIds.begin()), GetControllerID);
+
+  const bool bChanged = (oldControllerIds != newControllerIds);
+  if (bChanged)
+  {
+    m_controllers = std::move(newControllers);
+
+    // Sort add-ons, with default controller first
+    std::sort(m_controllers.begin(), m_controllers.end(),
+              [](const ControllerPtr& i, const ControllerPtr& j) {
+                if (i->ID() == DEFAULT_CONTROLLER_ID && j->ID() != DEFAULT_CONTROLLER_ID)
+                  return true;
+                if (i->ID() != DEFAULT_CONTROLLER_ID && j->ID() == DEFAULT_CONTROLLER_ID)
+                  return false;
+
+                return StringUtils::CompareNoCase(i->Layout().Label(), j->Layout().Label()) < 0;
+              });
+  }
+
+  return bChanged;
+}
+
+void CGUIControllerList::CleanupButtons(void)
+{
+  if (m_controllerList)
+    m_controllerList->ClearAll();
+}
diff --git a/xbmc/games/controllers/windows/GUIControllerList.h b/xbmc/games/controllers/windows/GUIControllerList.h
new file mode 100644
index 0000000..8292889
--- /dev/null
+++ b/xbmc/games/controllers/windows/GUIControllerList.h
@@ -0,0 +1,62 @@
+/*
+ *  Copyright (C) 2014-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#pragma once
+
+#include "IConfigurationWindow.h"
+#include "addons/AddonEvents.h"
+#include "games/GameTypes.h"
+#include "games/controllers/ControllerTypes.h"
+
+#include <set>
+#include <string>
+
+class CGUIButtonControl;
+class CGUIControlGroupList;
+class CGUIWindow;
+
+namespace KODI
+{
+namespace GAME
+{
+class CGUIControllerWindow;
+
+class CGUIControllerList : public IControllerList
+{
+public:
+  CGUIControllerList(CGUIWindow* window, IFeatureList* featureList, GameClientPtr gameClient);
+  ~CGUIControllerList() override { Deinitialize(); }
+
+  // implementation of IControllerList
+  bool Initialize() override;
+  void Deinitialize() override;
+  bool Refresh(const std::string& controllerId) override;
+  void OnFocus(unsigned int controllerIndex) override;
+  void OnSelect(unsigned int controllerIndex) override;
+  int GetFocusedController() const override { return m_focusedController; }
+  void ResetController() override;
+
+private:
+  bool RefreshControllers(void);
+
+  void CleanupButtons(void);
+  void OnEvent(const ADDON::AddonEvent& event);
+
+  // GUI stuff
+  CGUIWindow* const m_guiWindow;
+  IFeatureList* const m_featureList;
+  CGUIControlGroupList* m_controllerList;
+  CGUIButtonControl* m_controllerButton;
+
+  // Game stuff
+  ControllerVector m_controllers;
+  int m_focusedController;
+  GameClientPtr m_gameClient;
+};
+} // namespace GAME
+} // namespace KODI
diff --git a/xbmc/games/controllers/windows/GUIControllerWindow.cpp b/xbmc/games/controllers/windows/GUIControllerWindow.cpp
new file mode 100644
index 0000000..6b2d2ac
--- /dev/null
+++ b/xbmc/games/controllers/windows/GUIControllerWindow.cpp
@@ -0,0 +1,376 @@
+/*
+ *  Copyright (C) 2014-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#include "GUIControllerWindow.h"
+
+#include "GUIControllerDefines.h"
+#include "GUIControllerList.h"
+#include "GUIFeatureList.h"
+#include "ServiceBroker.h"
+#include "addons/AddonManager.h"
+#include "addons/IAddon.h"
+#include "addons/addoninfo/AddonType.h"
+#include "addons/gui/GUIWindowAddonBrowser.h"
+#include "cores/RetroPlayer/guibridge/GUIGameRenderManager.h"
+#include "cores/RetroPlayer/guibridge/GUIGameSettingsHandle.h"
+#include "games/addons/GameClient.h"
+#include "games/controllers/dialogs/ControllerInstaller.h"
+#include "games/controllers/dialogs/GUIDialogIgnoreInput.h"
+#include "guilib/GUIButtonControl.h"
+#include "guilib/GUIControl.h"
+#include "guilib/GUIMessage.h"
+#include "guilib/WindowIDs.h"
+#include "messaging/helpers/DialogOKHelper.h"
+
+// To enable button mapping support
+#include "peripherals/Peripherals.h"
+
+using namespace KODI;
+using namespace GAME;
+using namespace KODI::MESSAGING;
+
+CGUIControllerWindow::CGUIControllerWindow(void)
+  : CGUIDialog(WINDOW_DIALOG_GAME_CONTROLLERS, "DialogGameControllers.xml"),
+    m_installer(new CControllerInstaller)
+{
+  // initialize CGUIWindow
+  m_loadType = KEEP_IN_MEMORY;
+}
+
+CGUIControllerWindow::~CGUIControllerWindow(void)
+{
+  delete m_controllerList;
+  delete m_featureList;
+}
+
+void CGUIControllerWindow::DoProcess(unsigned int currentTime, CDirtyRegionList& dirtyregions)
+{
+  /*
+   * Apply the faded focus texture to the current controller when unfocused
+   */
+
+  CGUIControl* control = nullptr; // The controller button
+  bool bAlphaFaded = false; // True if the controller button has been focused and faded this frame
+
+  if (m_controllerList && m_controllerList->GetFocusedController() >= 0)
+  {
+    control = GetFirstFocusableControl(CONTROL_CONTROLLER_BUTTONS_START +
+                                       m_controllerList->GetFocusedController());
+    if (control && !control->HasFocus())
+    {
+      if (control->GetControlType() == CGUIControl::GUICONTROL_BUTTON)
+      {
+        control->SetFocus(true);
+        static_cast<CGUIButtonControl*>(control)->SetAlpha(0x80);
+        bAlphaFaded = true;
+      }
+    }
+  }
+
+  CGUIDialog::DoProcess(currentTime, dirtyregions);
+
+  if (control && bAlphaFaded)
+  {
+    control->SetFocus(false);
+    if (control->GetControlType() == CGUIControl::GUICONTROL_BUTTON)
+      static_cast<CGUIButtonControl*>(control)->SetAlpha(0xFF);
+  }
+}
+
+bool CGUIControllerWindow::OnMessage(CGUIMessage& message)
+{
+  // Set to true to block the call to the super class
+  bool bHandled = false;
+
+  switch (message.GetMessage())
+  {
+    case GUI_MSG_CLICKED:
+    {
+      int controlId = message.GetSenderId();
+
+      if (controlId == CONTROL_CLOSE_BUTTON)
+      {
+        Close();
+        bHandled = true;
+      }
+      else if (controlId == CONTROL_GET_MORE)
+      {
+        GetMoreControllers();
+        bHandled = true;
+      }
+      else if (controlId == CONTROL_GET_ALL)
+      {
+        GetAllControllers();
+        bHandled = true;
+      }
+      else if (controlId == CONTROL_RESET_BUTTON)
+      {
+        ResetController();
+        bHandled = true;
+      }
+      else if (controlId == CONTROL_HELP_BUTTON)
+      {
+        ShowHelp();
+        bHandled = true;
+      }
+      else if (controlId == CONTROL_FIX_SKIPPING)
+      {
+        ShowButtonCaptureDialog();
+      }
+      else if (CONTROL_CONTROLLER_BUTTONS_START <= controlId &&
+               controlId < CONTROL_CONTROLLER_BUTTONS_END)
+      {
+        OnControllerSelected(controlId - CONTROL_CONTROLLER_BUTTONS_START);
+        bHandled = true;
+      }
+      else if (CONTROL_FEATURE_BUTTONS_START <= controlId &&
+               controlId < CONTROL_FEATURE_BUTTONS_END)
+      {
+        OnFeatureSelected(controlId - CONTROL_FEATURE_BUTTONS_START);
+        bHandled = true;
+      }
+      break;
+    }
+    case GUI_MSG_FOCUSED:
+    {
+      int controlId = message.GetControlId();
+
+      if (CONTROL_CONTROLLER_BUTTONS_START <= controlId &&
+          controlId < CONTROL_CONTROLLER_BUTTONS_END)
+      {
+        OnControllerFocused(controlId - CONTROL_CONTROLLER_BUTTONS_START);
+      }
+      else if (CONTROL_FEATURE_BUTTONS_START <= controlId &&
+               controlId < CONTROL_FEATURE_BUTTONS_END)
+      {
+        OnFeatureFocused(controlId - CONTROL_FEATURE_BUTTONS_START);
+      }
+      break;
+    }
+    case GUI_MSG_SETFOCUS:
+    {
+      int controlId = message.GetControlId();
+
+      if (CONTROL_CONTROLLER_BUTTONS_START <= controlId &&
+          controlId < CONTROL_CONTROLLER_BUTTONS_END)
+      {
+        OnControllerFocused(controlId - CONTROL_CONTROLLER_BUTTONS_START);
+      }
+      else if (CONTROL_FEATURE_BUTTONS_START <= controlId &&
+               controlId < CONTROL_FEATURE_BUTTONS_END)
+      {
+        OnFeatureFocused(controlId - CONTROL_FEATURE_BUTTONS_START);
+      }
+      break;
+    }
+    case GUI_MSG_REFRESH_LIST:
+    {
+      int controlId = message.GetControlId();
+
+      if (controlId == CONTROL_CONTROLLER_LIST)
+      {
+        const std::string controllerId = message.GetStringParam();
+        if (m_controllerList && m_controllerList->Refresh(controllerId))
+        {
+          CGUIDialog::OnMessage(message);
+          bHandled = true;
+        }
+      }
+      break;
+    }
+    default:
+      break;
+  }
+
+  if (!bHandled)
+    bHandled = CGUIDialog::OnMessage(message);
+
+  return bHandled;
+}
+
+void CGUIControllerWindow::OnEvent(const ADDON::CRepositoryUpdater::RepositoryUpdated& event)
+{
+  UpdateButtons();
+}
+
+void CGUIControllerWindow::OnEvent(const ADDON::AddonEvent& event)
+{
+  using namespace ADDON;
+
+  if (typeid(event) == typeid(AddonEvents::Enabled) || // also called on install,
+      typeid(event) == typeid(AddonEvents::Disabled) || // not called on uninstall
+      typeid(event) == typeid(AddonEvents::UnInstalled) ||
+      typeid(event) == typeid(AddonEvents::ReInstalled))
+  {
+    if (CServiceBroker::GetAddonMgr().HasType(event.addonId, AddonType::GAME_CONTROLLER))
+    {
+      UpdateButtons();
+    }
+  }
+}
+
+void CGUIControllerWindow::OnInitWindow(void)
+{
+  // Get active game add-on
+  GameClientPtr gameClient;
+  {
+    auto gameSettingsHandle = CServiceBroker::GetGameRenderManager().RegisterGameSettingsDialog();
+    if (gameSettingsHandle)
+    {
+      ADDON::AddonPtr addon;
+      if (CServiceBroker::GetAddonMgr().GetAddon(gameSettingsHandle->GameClientID(), addon,
+                                                 ADDON::AddonType::GAMEDLL,
+                                                 ADDON::OnlyEnabled::CHOICE_YES))
+        gameClient = std::static_pointer_cast<CGameClient>(addon);
+    }
+  }
+  m_gameClient = std::move(gameClient);
+
+  CGUIDialog::OnInitWindow();
+
+  if (!m_featureList)
+  {
+    m_featureList = new CGUIFeatureList(this, m_gameClient);
+    if (!m_featureList->Initialize())
+    {
+      delete m_featureList;
+      m_featureList = nullptr;
+    }
+  }
+
+  if (!m_controllerList && m_featureList)
+  {
+    m_controllerList = new CGUIControllerList(this, m_featureList, m_gameClient);
+    if (!m_controllerList->Initialize())
+    {
+      delete m_controllerList;
+      m_controllerList = nullptr;
+    }
+  }
+
+  // Focus the first controller so that the feature list is loaded properly
+  CGUIMessage msgFocus(GUI_MSG_SETFOCUS, GetID(), CONTROL_CONTROLLER_BUTTONS_START);
+  OnMessage(msgFocus);
+
+  // Enable button mapping support
+  CServiceBroker::GetPeripherals().EnableButtonMapping();
+
+  UpdateButtons();
+
+  // subscribe to events
+  CServiceBroker::GetRepositoryUpdater().Events().Subscribe(this, &CGUIControllerWindow::OnEvent);
+  CServiceBroker::GetAddonMgr().Events().Subscribe(this, &CGUIControllerWindow::OnEvent);
+}
+
+void CGUIControllerWindow::OnDeinitWindow(int nextWindowID)
+{
+  CServiceBroker::GetRepositoryUpdater().Events().Unsubscribe(this);
+  CServiceBroker::GetAddonMgr().Events().Unsubscribe(this);
+
+  if (m_controllerList)
+  {
+    m_controllerList->Deinitialize();
+    delete m_controllerList;
+    m_controllerList = nullptr;
+  }
+
+  if (m_featureList)
+  {
+    m_featureList->Deinitialize();
+    delete m_featureList;
+    m_featureList = nullptr;
+  }
+
+  CGUIDialog::OnDeinitWindow(nextWindowID);
+
+  m_gameClient.reset();
+}
+
+void CGUIControllerWindow::OnControllerFocused(unsigned int controllerIndex)
+{
+  if (m_controllerList)
+    m_controllerList->OnFocus(controllerIndex);
+}
+
+void CGUIControllerWindow::OnControllerSelected(unsigned int controllerIndex)
+{
+  if (m_controllerList)
+    m_controllerList->OnSelect(controllerIndex);
+}
+
+void CGUIControllerWindow::OnFeatureFocused(unsigned int buttonIndex)
+{
+  if (m_featureList)
+    m_featureList->OnFocus(buttonIndex);
+}
+
+void CGUIControllerWindow::OnFeatureSelected(unsigned int buttonIndex)
+{
+  if (m_featureList)
+    m_featureList->OnSelect(buttonIndex);
+}
+
+void CGUIControllerWindow::UpdateButtons(void)
+{
+  using namespace ADDON;
+
+  VECADDONS addons;
+  if (m_gameClient)
+  {
+    SET_CONTROL_HIDDEN(CONTROL_GET_MORE);
+    SET_CONTROL_HIDDEN(CONTROL_GET_ALL);
+  }
+  else
+  {
+    const bool bEnable = CServiceBroker::GetAddonMgr().GetInstallableAddons(
+                             addons, ADDON::AddonType::GAME_CONTROLLER) &&
+                         !addons.empty();
+    CONTROL_ENABLE_ON_CONDITION(CONTROL_GET_MORE, bEnable);
+    CONTROL_ENABLE_ON_CONDITION(CONTROL_GET_ALL, bEnable);
+  }
+}
+
+void CGUIControllerWindow::GetMoreControllers(void)
+{
+  std::string strAddonId;
+  if (CGUIWindowAddonBrowser::SelectAddonID(ADDON::AddonType::GAME_CONTROLLER, strAddonId, false,
+                                            true, false, true, false) < 0)
+  {
+    // "Controller profiles"
+    // "All available controller profiles are installed."
+    HELPERS::ShowOKDialogText(CVariant{35050}, CVariant{35062});
+    return;
+  }
+}
+
+void CGUIControllerWindow::GetAllControllers()
+{
+  if (m_installer->IsRunning())
+    return;
+
+  m_installer->Create(false);
+}
+
+void CGUIControllerWindow::ResetController(void)
+{
+  if (m_controllerList)
+    m_controllerList->ResetController();
+}
+
+void CGUIControllerWindow::ShowHelp(void)
+{
+  // "Help"
+  // <help text>
+  HELPERS::ShowOKDialogText(CVariant{10043}, CVariant{35055});
+}
+
+void CGUIControllerWindow::ShowButtonCaptureDialog(void)
+{
+  CGUIDialogIgnoreInput dialog;
+  dialog.Show();
+}
diff --git a/xbmc/games/controllers/windows/GUIControllerWindow.h b/xbmc/games/controllers/windows/GUIControllerWindow.h
new file mode 100644
index 0000000..137fd56
--- /dev/null
+++ b/xbmc/games/controllers/windows/GUIControllerWindow.h
@@ -0,0 +1,68 @@
+/*
+ *  Copyright (C) 2014-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#pragma once
+
+#include "addons/RepositoryUpdater.h"
+#include "games/GameTypes.h"
+#include "guilib/GUIDialog.h"
+
+#include <memory>
+
+namespace KODI
+{
+namespace GAME
+{
+class CControllerInstaller;
+class IControllerList;
+class IFeatureList;
+
+class CGUIControllerWindow : public CGUIDialog
+{
+public:
+  CGUIControllerWindow(void);
+  ~CGUIControllerWindow() override;
+
+  // implementation of CGUIControl via CGUIDialog
+  void DoProcess(unsigned int currentTime, CDirtyRegionList& dirtyregions) override;
+  bool OnMessage(CGUIMessage& message) override;
+
+protected:
+  // implementation of CGUIWindow via CGUIDialog
+  void OnInitWindow() override;
+  void OnDeinitWindow(int nextWindowID) override;
+
+private:
+  void OnControllerFocused(unsigned int controllerIndex);
+  void OnControllerSelected(unsigned int controllerIndex);
+  void OnFeatureFocused(unsigned int featureIndex);
+  void OnFeatureSelected(unsigned int featureIndex);
+  void UpdateButtons(void);
+
+  // Callbacks for events
+  void OnEvent(const ADDON::CRepositoryUpdater::RepositoryUpdated& event);
+  void OnEvent(const ADDON::AddonEvent& event);
+
+  // Action for the available button
+  void GetMoreControllers(void);
+  void GetAllControllers();
+  void ResetController(void);
+  void ShowHelp(void);
+  void ShowButtonCaptureDialog(void);
+
+  IControllerList* m_controllerList = nullptr;
+  IFeatureList* m_featureList = nullptr;
+
+  // Game parameters
+  GameClientPtr m_gameClient;
+
+  // Controller parameters
+  std::unique_ptr<CControllerInstaller> m_installer;
+};
+} // namespace GAME
+} // namespace KODI
diff --git a/xbmc/games/controllers/windows/GUIFeatureList.cpp b/xbmc/games/controllers/windows/GUIFeatureList.cpp
new file mode 100644
index 0000000..d43c16d
--- /dev/null
+++ b/xbmc/games/controllers/windows/GUIFeatureList.cpp
@@ -0,0 +1,297 @@
+/*
+ *  Copyright (C) 2014-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#include "GUIFeatureList.h"
+
+#include "GUIConfigurationWizard.h"
+#include "GUIControllerDefines.h"
+#include "games/addons/GameClient.h"
+#include "games/addons/input/GameClientInput.h"
+#include "games/controllers/Controller.h"
+#include "games/controllers/guicontrols/GUIFeatureButton.h"
+#include "games/controllers/guicontrols/GUIFeatureControls.h"
+#include "games/controllers/guicontrols/GUIFeatureFactory.h"
+#include "games/controllers/guicontrols/GUIFeatureTranslator.h"
+#include "games/controllers/input/PhysicalFeature.h"
+#include "guilib/GUIButtonControl.h"
+#include "guilib/GUIControlGroupList.h"
+#include "guilib/GUIImage.h"
+#include "guilib/GUILabelControl.h"
+#include "guilib/GUIWindow.h"
+#include "guilib/LocalizeStrings.h"
+
+using namespace KODI;
+using namespace GAME;
+
+CGUIFeatureList::CGUIFeatureList(CGUIWindow* window, GameClientPtr gameClient)
+  : m_window(window),
+    m_guiList(nullptr),
+    m_guiButtonTemplate(nullptr),
+    m_guiGroupTitle(nullptr),
+    m_guiFeatureSeparator(nullptr),
+    m_gameClient(std::move(gameClient)),
+    m_wizard(new CGUIConfigurationWizard)
+{
+}
+
+CGUIFeatureList::~CGUIFeatureList(void)
+{
+  Deinitialize();
+  delete m_wizard;
+}
+
+bool CGUIFeatureList::Initialize(void)
+{
+  m_guiList = dynamic_cast<CGUIControlGroupList*>(m_window->GetControl(CONTROL_FEATURE_LIST));
+  m_guiButtonTemplate =
+      dynamic_cast<CGUIButtonControl*>(m_window->GetControl(CONTROL_FEATURE_BUTTON_TEMPLATE));
+  m_guiGroupTitle =
+      dynamic_cast<CGUILabelControl*>(m_window->GetControl(CONTROL_FEATURE_GROUP_TITLE));
+  m_guiFeatureSeparator = dynamic_cast<CGUIImage*>(m_window->GetControl(CONTROL_FEATURE_SEPARATOR));
+
+  if (m_guiButtonTemplate)
+    m_guiButtonTemplate->SetVisible(false);
+
+  if (m_guiGroupTitle)
+    m_guiGroupTitle->SetVisible(false);
+
+  if (m_guiFeatureSeparator)
+    m_guiFeatureSeparator->SetVisible(false);
+
+  return m_guiList != nullptr && m_guiButtonTemplate != nullptr;
+}
+
+void CGUIFeatureList::Deinitialize(void)
+{
+  CleanupButtons();
+
+  m_guiList = nullptr;
+  m_guiButtonTemplate = nullptr;
+  m_guiGroupTitle = nullptr;
+  m_guiFeatureSeparator = nullptr;
+}
+
+void CGUIFeatureList::Load(const ControllerPtr& controller)
+{
+  if (m_controller && m_controller->ID() == controller->ID())
+    return; // Already loaded
+
+  CleanupButtons();
+
+  // Set new controller
+  m_controller = controller;
+
+  // Get features
+  const std::vector<CPhysicalFeature>& features = controller->Features();
+
+  // Split into groups
+  auto featureGroups = GetFeatureGroups(features);
+
+  // Create controls
+  m_buttonCount = 0;
+  for (auto itGroup = featureGroups.begin(); itGroup != featureGroups.end(); ++itGroup)
+  {
+    const std::string& groupName = itGroup->groupName;
+    const bool bIsVirtualKey = itGroup->bIsVirtualKey;
+
+    std::vector<CGUIButtonControl*> buttons;
+
+    // Create buttons
+    if (bIsVirtualKey)
+    {
+      CGUIButtonControl* button = GetSelectKeyButton(itGroup->features, m_buttonCount);
+      if (button != nullptr)
+        buttons.push_back(button);
+    }
+    else
+    {
+      buttons = GetButtons(itGroup->features, m_buttonCount);
+    }
+
+    // Just in case
+    if (m_buttonCount + buttons.size() >= MAX_FEATURE_COUNT)
+      break;
+
+    // Add a separator if the group list isn't empty
+    if (m_guiFeatureSeparator && m_guiList->GetTotalSize() > 0)
+    {
+      CGUIFeatureSeparator* pSeparator =
+          new CGUIFeatureSeparator(*m_guiFeatureSeparator, m_buttonCount);
+      m_guiList->AddControl(pSeparator);
+    }
+
+    // Add the group title
+    if (m_guiGroupTitle && !groupName.empty())
+    {
+      CGUIFeatureGroupTitle* pGroupTitle =
+          new CGUIFeatureGroupTitle(*m_guiGroupTitle, groupName, m_buttonCount);
+      m_guiList->AddControl(pGroupTitle);
+    }
+
+    // Add the buttons
+    for (CGUIButtonControl* pButton : buttons)
+      m_guiList->AddControl(pButton);
+
+    m_buttonCount += static_cast<unsigned int>(buttons.size());
+  }
+}
+
+void CGUIFeatureList::OnSelect(unsigned int buttonIndex)
+{
+  // Generate list of buttons for the wizard
+  std::vector<IFeatureButton*> buttons;
+  for (; buttonIndex < m_buttonCount; buttonIndex++)
+  {
+    IFeatureButton* control = GetButtonControl(buttonIndex);
+    if (control == nullptr)
+      continue;
+
+    if (control->AllowWizard())
+      buttons.push_back(control);
+    else
+    {
+      // Only map this button if it's the only one
+      if (buttons.empty())
+        buttons.push_back(control);
+      break;
+    }
+  }
+
+  m_wizard->Run(m_controller->ID(), buttons);
+}
+
+IFeatureButton* CGUIFeatureList::GetButtonControl(unsigned int buttonIndex)
+{
+  CGUIControl* control = m_guiList->GetControl(CONTROL_FEATURE_BUTTONS_START + buttonIndex);
+
+  return static_cast<IFeatureButton*>(dynamic_cast<CGUIFeatureButton*>(control));
+}
+
+void CGUIFeatureList::CleanupButtons(void)
+{
+  m_buttonCount = 0;
+
+  m_wizard->Abort(true);
+  m_wizard->UnregisterKeys();
+
+  if (m_guiList)
+    m_guiList->ClearAll();
+}
+
+std::vector<CGUIFeatureList::FeatureGroup> CGUIFeatureList::GetFeatureGroups(
+    const std::vector<CPhysicalFeature>& features) const
+{
+  std::vector<FeatureGroup> groups;
+
+  // Get group names
+  std::vector<std::string> groupNames;
+  for (const CPhysicalFeature& feature : features)
+  {
+    // Skip features not supported by the game client
+    if (m_gameClient)
+    {
+      if (!m_gameClient->Input().HasFeature(m_controller->ID(), feature.Name()))
+        continue;
+    }
+
+    bool bAdded = false;
+
+    if (!groups.empty())
+    {
+      FeatureGroup& previousGroup = *groups.rbegin();
+      if (feature.CategoryLabel() == previousGroup.groupName)
+      {
+        // Add feature to previous group
+        previousGroup.features.emplace_back(feature);
+        bAdded = true;
+
+        // If feature is a key, add it to the preceding virtual group as well
+        if (feature.Category() == JOYSTICK::FEATURE_CATEGORY::KEY && groups.size() >= 2)
+        {
+          FeatureGroup& virtualGroup = *(groups.rbegin() + 1);
+          if (virtualGroup.bIsVirtualKey)
+            virtualGroup.features.emplace_back(feature);
+        }
+      }
+    }
+
+    if (!bAdded)
+    {
+      // If feature is a key, create a virtual group that allows the user to
+      // select which key to map
+      if (feature.Category() == JOYSTICK::FEATURE_CATEGORY::KEY)
+      {
+        FeatureGroup virtualGroup;
+        virtualGroup.groupName = g_localizeStrings.Get(35166); // "All keys"
+        virtualGroup.bIsVirtualKey = true;
+        virtualGroup.features.emplace_back(feature);
+        groups.emplace_back(std::move(virtualGroup));
+      }
+
+      // Create new group and add feature
+      FeatureGroup group;
+      group.groupName = feature.CategoryLabel();
+      group.features.emplace_back(feature);
+      groups.emplace_back(std::move(group));
+    }
+  }
+
+  // If there are no features, add an empty group
+  if (groups.empty())
+  {
+    FeatureGroup group;
+    group.groupName = g_localizeStrings.Get(35022); // "Nothing to map"
+    groups.emplace_back(std::move(group));
+  }
+
+  return groups;
+}
+
+bool CGUIFeatureList::HasButton(JOYSTICK::FEATURE_TYPE type) const
+{
+  return CGUIFeatureTranslator::GetButtonType(type) != BUTTON_TYPE::UNKNOWN;
+}
+
+std::vector<CGUIButtonControl*> CGUIFeatureList::GetButtons(
+    const std::vector<CPhysicalFeature>& features, unsigned int startIndex)
+{
+  std::vector<CGUIButtonControl*> buttons;
+
+  // Create buttons
+  unsigned int buttonIndex = startIndex;
+  for (const CPhysicalFeature& feature : features)
+  {
+    BUTTON_TYPE buttonType = CGUIFeatureTranslator::GetButtonType(feature.Type());
+
+    CGUIButtonControl* pButton = CGUIFeatureFactory::CreateButton(buttonType, *m_guiButtonTemplate,
+                                                                  m_wizard, feature, buttonIndex);
+
+    // If successful, add button to result
+    if (pButton != nullptr)
+    {
+      buttons.push_back(pButton);
+      buttonIndex++;
+    }
+  }
+
+  return buttons;
+}
+
+CGUIButtonControl* CGUIFeatureList::GetSelectKeyButton(
+    const std::vector<CPhysicalFeature>& features, unsigned int buttonIndex)
+{
+  // Expose keycodes to the wizard
+  for (const CPhysicalFeature& feature : features)
+  {
+    if (feature.Type() == JOYSTICK::FEATURE_TYPE::KEY)
+      m_wizard->RegisterKey(feature);
+  }
+
+  return CGUIFeatureFactory::CreateButton(BUTTON_TYPE::SELECT_KEY, *m_guiButtonTemplate, m_wizard,
+                                          CPhysicalFeature(), buttonIndex);
+}
diff --git a/xbmc/games/controllers/windows/GUIFeatureList.h b/xbmc/games/controllers/windows/GUIFeatureList.h
new file mode 100644
index 0000000..c7df54f
--- /dev/null
+++ b/xbmc/games/controllers/windows/GUIFeatureList.h
@@ -0,0 +1,77 @@
+/*
+ *  Copyright (C) 2014-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#pragma once
+
+#include "IConfigurationWindow.h"
+#include "games/GameTypes.h"
+#include "games/controllers/ControllerTypes.h"
+#include "games/controllers/input/PhysicalFeature.h"
+#include "input/joysticks/JoystickTypes.h"
+
+class CGUIButtonControl;
+class CGUIControlGroupList;
+class CGUIImage;
+class CGUILabelControl;
+class CGUIWindow;
+
+namespace KODI
+{
+namespace GAME
+{
+class CGUIFeatureList : public IFeatureList
+{
+public:
+  CGUIFeatureList(CGUIWindow* window, GameClientPtr gameClient);
+  ~CGUIFeatureList() override;
+
+  // implementation of IFeatureList
+  bool Initialize() override;
+  void Deinitialize() override;
+  bool HasButton(JOYSTICK::FEATURE_TYPE type) const override;
+  void Load(const ControllerPtr& controller) override;
+  void OnFocus(unsigned int buttonIndex) override {}
+  void OnSelect(unsigned int buttonIndex) override;
+
+private:
+  IFeatureButton* GetButtonControl(unsigned int buttonIndex);
+
+  void CleanupButtons(void);
+
+  // Helper functions
+  struct FeatureGroup
+  {
+    std::string groupName;
+    std::vector<CPhysicalFeature> features;
+    /*!
+     * True if this group is a button that allows the user to map a key of
+     * their choosing.
+     */
+    bool bIsVirtualKey = false;
+  };
+  std::vector<FeatureGroup> GetFeatureGroups(const std::vector<CPhysicalFeature>& features) const;
+  std::vector<CGUIButtonControl*> GetButtons(const std::vector<CPhysicalFeature>& features,
+                                             unsigned int startIndex);
+  CGUIButtonControl* GetSelectKeyButton(const std::vector<CPhysicalFeature>& features,
+                                        unsigned int buttonIndex);
+
+  // GUI stuff
+  CGUIWindow* const m_window;
+  unsigned int m_buttonCount = 0;
+  CGUIControlGroupList* m_guiList;
+  CGUIButtonControl* m_guiButtonTemplate;
+  CGUILabelControl* m_guiGroupTitle;
+  CGUIImage* m_guiFeatureSeparator;
+
+  // Game window stuff
+  GameClientPtr m_gameClient;
+  ControllerPtr m_controller;
+  IConfigurationWizard* m_wizard;
+};
+} // namespace GAME
+} // namespace KODI
diff --git a/xbmc/games/controllers/windows/IConfigurationWindow.h b/xbmc/games/controllers/windows/IConfigurationWindow.h
new file mode 100644
index 0000000..017adf0
--- /dev/null
+++ b/xbmc/games/controllers/windows/IConfigurationWindow.h
@@ -0,0 +1,262 @@
+/*
+ *  Copyright (C) 2014-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#pragma once
+
+#include "games/controllers/ControllerTypes.h"
+#include "input/InputTypes.h"
+#include "input/joysticks/JoystickTypes.h"
+
+#include <string>
+#include <vector>
+
+class CEvent;
+
+/*!
+ * \brief Controller configuration window
+ *
+ * The configuration window presents a list of controllers. Also on the screen
+ * is a list of features belonging to that controller.
+ *
+ * The configuration utility reacts to several events:
+ *
+ *   1) When a controller is focused, the feature list is populated with the
+ *      controller's features.
+ *
+ *   2) When a feature is selected, the user is prompted for controller input.
+ *      This initiates a "wizard" that walks the user through the subsequent
+ *      features.
+ *
+ *   3) When the wizard's active feature loses focus, the wizard is cancelled
+ *      and the prompt for input ends.
+ */
+
+namespace KODI
+{
+namespace GAME
+{
+class CPhysicalFeature;
+
+/*!
+ * \brief A list populated by installed controllers
+ */
+class IControllerList
+{
+public:
+  virtual ~IControllerList() = default;
+
+  /*!
+   * \brief  Initialize the resource
+   * \return true if the resource is initialized and can be used
+   *         false if the resource failed to initialize and must not be used
+   */
+  virtual bool Initialize(void) = 0;
+
+  /*!
+   * \brief  Deinitialize the resource
+   */
+  virtual void Deinitialize(void) = 0;
+
+  /*!
+   * \brief Refresh the contents of the list
+   * \param controllerId The controller to focus, or empty to leave focus unchanged
+   * \return True if the list was changed
+   */
+  virtual bool Refresh(const std::string& controllerId) = 0;
+
+  /*
+   * \brief  The specified controller has been focused
+   * \param  controllerIndex The index of the controller being focused
+   */
+  virtual void OnFocus(unsigned int controllerIndex) = 0;
+
+  /*!
+   * \brief  The specified controller has been selected
+   * \param  controllerIndex The index of the controller being selected
+   */
+  virtual void OnSelect(unsigned int controllerIndex) = 0;
+
+  /*!
+   * \brief Get the index of the focused controller
+   * \return The index of the focused controller, or -1 if no controller has been focused yet
+   */
+  virtual int GetFocusedController() const = 0;
+
+  /*!
+   * \brief Reset the focused controller
+   */
+  virtual void ResetController(void) = 0;
+};
+
+/*!
+ * \brief A list populated by the controller's features
+ */
+class IFeatureList
+{
+public:
+  virtual ~IFeatureList() = default;
+
+  /*!
+   * \brief  Initialize the resource
+   * \return true if the resource is initialized and can be used
+   *         false if the resource failed to initialize and must not be used
+   */
+  virtual bool Initialize(void) = 0;
+
+  /*!
+   * \brief  Deinitialize the resource
+   * \remark This must be called if Initialize() returned true
+   */
+  virtual void Deinitialize(void) = 0;
+
+  /*!
+   * \brief Check if the feature type has any buttons in the GUI
+   * \param The type of the feature being added to the GUI
+   * \return True if the type is support, false otherwise
+   */
+  virtual bool HasButton(JOYSTICK::FEATURE_TYPE type) const = 0;
+
+  /*!
+   * \brief Load the features for the specified controller
+   * \param controller The controller to load
+   */
+  virtual void Load(const ControllerPtr& controller) = 0;
+
+  /*!
+   * \brief  Focus has been set to the specified GUI button
+   * \param  buttonIndex The index of the button being focused
+   */
+  virtual void OnFocus(unsigned int buttonIndex) = 0;
+
+  /*!
+   * \brief  The specified GUI button has been selected
+   * \param  buttonIndex The index of the button being selected
+   */
+  virtual void OnSelect(unsigned int buttonIndex) = 0;
+};
+
+/*!
+ * \brief A GUI button in a feature list
+ */
+class IFeatureButton
+{
+public:
+  virtual ~IFeatureButton() = default;
+
+  /*!
+   * \brief Get the feature represented by this button
+   */
+  virtual const CPhysicalFeature& Feature(void) const = 0;
+
+  /*!
+   * \brief Allow the wizard to include this feature in a list of buttons
+   *        to map
+   */
+  virtual bool AllowWizard() const { return true; }
+
+  /*!
+   * \brief Prompt the user for a single input element
+   * \param waitEvent The event to block on while prompting for input
+   * \return true if input was received (event fired), false if the prompt timed out
+   *
+   * After the button has finished prompting the user for all the input
+   * elements it requires, this will return false until Reset() is called.
+   */
+  virtual bool PromptForInput(CEvent& waitEvent) = 0;
+
+  /*!
+   * \brief Check if the button supports further calls to PromptForInput()
+   * \return true if the button requires no more input elements from the user
+   */
+  virtual bool IsFinished(void) const = 0;
+
+  /*!
+   * \brief Get the direction of the next analog stick or relative pointer
+   *        prompt
+   * \return The next direction to be prompted, or UNKNOWN if this isn't a
+   *         cardinal feature or the prompt is finished
+   */
+  virtual INPUT::CARDINAL_DIRECTION GetCardinalDirection(void) const = 0;
+
+  /*!
+   * \brief Get the direction of the next wheel prompt
+   * \return The next direction to be prompted, or UNKNOWN if this isn't a
+   *         wheel or the prompt is finished
+   */
+  virtual JOYSTICK::WHEEL_DIRECTION GetWheelDirection(void) const = 0;
+
+  /*!
+   * \brief Get the direction of the next throttle prompt
+   * \return The next direction to be prompted, or UNKNOWN if this isn't a
+   *         throttle or the prompt is finished
+   */
+  virtual JOYSTICK::THROTTLE_DIRECTION GetThrottleDirection(void) const = 0;
+
+  /*!
+   * \brief True if the button is waiting for a key press
+   */
+  virtual bool NeedsKey() const { return false; }
+
+  /*!
+   * \brief Set the pressed key that the user will be prompted to map
+   *
+   * \param key The key that was pressed
+   */
+  virtual void SetKey(const CPhysicalFeature& key) {}
+
+  /*!
+   * \brief Reset button after prompting for input has finished
+   */
+  virtual void Reset(void) = 0;
+};
+
+/*!
+ * \brief A wizard to direct user input
+ */
+class IConfigurationWizard
+{
+public:
+  virtual ~IConfigurationWizard() = default;
+
+  /*!
+   * \brief Start the wizard for the specified buttons
+   * \param controllerId The controller ID being mapped
+   * \param buttons The buttons to map
+   */
+  virtual void Run(const std::string& strControllerId,
+                   const std::vector<IFeatureButton*>& buttons) = 0;
+
+  /*!
+   * \brief Callback for feature losing focus
+   * \param button The feature button losing focus
+   */
+  virtual void OnUnfocus(IFeatureButton* button) = 0;
+
+  /*!
+   * \brief Abort a running wizard
+   * \param bWait True if the call should block until the wizard is fully aborted
+   * \return true if aborted, or false if the wizard wasn't running
+   */
+  virtual bool Abort(bool bWait = true) = 0;
+
+  /*!
+   * \brief Register a key by its keycode
+   * \param key A key with a valid keycode
+   *
+   * This should be called before Run(). It allows the user to choose a key
+   * to map instead of scrolling through a long list.
+   */
+  virtual void RegisterKey(const CPhysicalFeature& key) = 0;
+
+  /*!
+   * \brief Unregister all registered keys
+   */
+  virtual void UnregisterKeys() = 0;
+};
+} // namespace GAME
+} // namespace KODI