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

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

182 files changed, 19802 insertions, 0 deletions

diff --git a/xbmc/games/CMakeLists.txt b/xbmc/games/CMakeLists.txt
new file mode 100644
index 0000000..70b26f3
--- /dev/null
+++ b/xbmc/games/CMakeLists.txt
@@ -0,0 +1,10 @@
+set(SOURCES GameServices.cpp
+            GameSettings.cpp
+            GameUtils.cpp)
+
+set(HEADERS GameServices.h
+            GameSettings.h
+            GameTypes.h
+            GameUtils.h)
+
+core_add_library(games)
diff --git a/xbmc/games/GameServices.cpp b/xbmc/games/GameServices.cpp
new file mode 100644
index 0000000..099c9a9
--- /dev/null
+++ b/xbmc/games/GameServices.cpp
@@ -0,0 +1,63 @@
+/*
+ *  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 "GameServices.h"
+
+#include "controllers/Controller.h"
+#include "controllers/ControllerManager.h"
+#include "games/GameSettings.h"
+#include "games/agents/GameAgentManager.h"
+#include "profiles/ProfileManager.h"
+
+using namespace KODI;
+using namespace GAME;
+
+CGameServices::CGameServices(CControllerManager& controllerManager,
+                             RETRO::CGUIGameRenderManager& renderManager,
+                             PERIPHERALS::CPeripherals& peripheralManager,
+                             const CProfileManager& profileManager,
+                             CInputManager& inputManager)
+  : m_controllerManager(controllerManager),
+    m_gameRenderManager(renderManager),
+    m_profileManager(profileManager),
+    m_gameSettings(new CGameSettings()),
+    m_gameAgentManager(new CGameAgentManager(peripheralManager, inputManager))
+{
+}
+
+CGameServices::~CGameServices() = default;
+
+ControllerPtr CGameServices::GetController(const std::string& controllerId)
+{
+  return m_controllerManager.GetController(controllerId);
+}
+
+ControllerPtr CGameServices::GetDefaultController()
+{
+  return m_controllerManager.GetDefaultController();
+}
+
+ControllerPtr CGameServices::GetDefaultKeyboard()
+{
+  return m_controllerManager.GetDefaultKeyboard();
+}
+
+ControllerPtr CGameServices::GetDefaultMouse()
+{
+  return m_controllerManager.GetDefaultMouse();
+}
+
+ControllerVector CGameServices::GetControllers()
+{
+  return m_controllerManager.GetControllers();
+}
+
+std::string CGameServices::GetSavestatesFolder() const
+{
+  return m_profileManager.GetSavestatesFolder();
+}
diff --git a/xbmc/games/GameServices.h b/xbmc/games/GameServices.h
new file mode 100644
index 0000000..c736feb
--- /dev/null
+++ b/xbmc/games/GameServices.h
@@ -0,0 +1,72 @@
+/*
+ *  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 "controllers/ControllerTypes.h"
+
+#include <memory>
+#include <string>
+
+class CInputManager;
+class CProfileManager;
+
+namespace PERIPHERALS
+{
+class CPeripherals;
+}
+
+namespace KODI
+{
+namespace RETRO
+{
+class CGUIGameRenderManager;
+}
+
+namespace GAME
+{
+class CGameAgentManager;
+class CControllerManager;
+class CGameSettings;
+
+class CGameServices
+{
+public:
+  CGameServices(CControllerManager& controllerManager,
+                RETRO::CGUIGameRenderManager& renderManager,
+                PERIPHERALS::CPeripherals& peripheralManager,
+                const CProfileManager& profileManager,
+                CInputManager& inputManager);
+  ~CGameServices();
+
+  ControllerPtr GetController(const std::string& controllerId);
+  ControllerPtr GetDefaultController();
+  ControllerPtr GetDefaultKeyboard();
+  ControllerPtr GetDefaultMouse();
+  ControllerVector GetControllers();
+
+  std::string GetSavestatesFolder() const;
+
+  CGameSettings& GameSettings() { return *m_gameSettings; }
+
+  RETRO::CGUIGameRenderManager& GameRenderManager() { return m_gameRenderManager; }
+
+  CGameAgentManager& GameAgentManager() { return *m_gameAgentManager; }
+
+private:
+  // Construction parameters
+  CControllerManager& m_controllerManager;
+  RETRO::CGUIGameRenderManager& m_gameRenderManager;
+  const CProfileManager& m_profileManager;
+
+  // Game services
+  std::unique_ptr<CGameSettings> m_gameSettings;
+  std::unique_ptr<CGameAgentManager> m_gameAgentManager;
+};
+} // namespace GAME
+} // namespace KODI
diff --git a/xbmc/games/GameSettings.cpp b/xbmc/games/GameSettings.cpp
new file mode 100644
index 0000000..acbccdc
--- /dev/null
+++ b/xbmc/games/GameSettings.cpp
@@ -0,0 +1,242 @@
+/*
+ *  Copyright (C) 2012-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 "GameSettings.h"
+
+#include "ServiceBroker.h"
+#include "URL.h"
+#include "events/EventLog.h"
+#include "events/NotificationEvent.h"
+#include "filesystem/File.h"
+#include "settings/Settings.h"
+#include "settings/SettingsComponent.h"
+#include "settings/lib/Setting.h"
+#include "utils/JSONVariantParser.h"
+#include "utils/StringUtils.h"
+#include "utils/Variant.h"
+#include "utils/log.h"
+
+#include <algorithm>
+#include <vector>
+
+using namespace KODI;
+using namespace GAME;
+
+namespace
+{
+const std::string SETTING_GAMES_ENABLE = "gamesgeneral.enable";
+const std::string SETTING_GAMES_SHOW_OSD_HELP = "gamesgeneral.showosdhelp";
+const std::string SETTING_GAMES_ENABLEAUTOSAVE = "gamesgeneral.enableautosave";
+const std::string SETTING_GAMES_ENABLEREWIND = "gamesgeneral.enablerewind";
+const std::string SETTING_GAMES_REWINDTIME = "gamesgeneral.rewindtime";
+const std::string SETTING_GAMES_ACHIEVEMENTS_USERNAME = "gamesachievements.username";
+const std::string SETTING_GAMES_ACHIEVEMENTS_PASSWORD = "gamesachievements.password";
+const std::string SETTING_GAMES_ACHIEVEMENTS_TOKEN = "gamesachievements.token";
+const std::string SETTING_GAMES_ACHIEVEMENTS_LOGGED_IN = "gamesachievements.loggedin";
+
+constexpr auto LOGIN_TO_RETRO_ACHIEVEMENTS_URL_TEMPLATE =
+    "http://retroachievements.org/dorequest.php?r=login&u={}&p={}";
+constexpr auto GET_PATCH_DATA_URL_TEMPLATE =
+    "http://retroachievements.org/dorequest.php?r=patch&u={}&t={}&g=0";
+constexpr auto SUCCESS = "Success";
+constexpr auto TOKEN = "Token";
+} // namespace
+
+CGameSettings::CGameSettings()
+{
+  m_settings = CServiceBroker::GetSettingsComponent()->GetSettings();
+
+  m_settings->RegisterCallback(this, {SETTING_GAMES_ENABLEREWIND, SETTING_GAMES_REWINDTIME,
+                                      SETTING_GAMES_ACHIEVEMENTS_USERNAME,
+                                      SETTING_GAMES_ACHIEVEMENTS_PASSWORD,
+                                      SETTING_GAMES_ACHIEVEMENTS_LOGGED_IN});
+}
+
+CGameSettings::~CGameSettings()
+{
+  m_settings->UnregisterCallback(this);
+}
+
+bool CGameSettings::GamesEnabled()
+{
+  return m_settings->GetBool(SETTING_GAMES_ENABLE);
+}
+
+bool CGameSettings::ShowOSDHelp()
+{
+  return m_settings->GetBool(SETTING_GAMES_SHOW_OSD_HELP);
+}
+
+void CGameSettings::SetShowOSDHelp(bool bShow)
+{
+  if (m_settings->GetBool(SETTING_GAMES_SHOW_OSD_HELP) != bShow)
+  {
+    m_settings->SetBool(SETTING_GAMES_SHOW_OSD_HELP, bShow);
+
+    //! @todo Asynchronous save
+    m_settings->Save();
+  }
+}
+
+void CGameSettings::ToggleGames()
+{
+  m_settings->ToggleBool(SETTING_GAMES_ENABLE);
+}
+
+bool CGameSettings::AutosaveEnabled()
+{
+  return m_settings->GetBool(SETTING_GAMES_ENABLEAUTOSAVE);
+}
+
+bool CGameSettings::RewindEnabled()
+{
+  return m_settings->GetBool(SETTING_GAMES_ENABLEREWIND);
+}
+
+unsigned int CGameSettings::MaxRewindTimeSec()
+{
+  int rewindTimeSec = m_settings->GetInt(SETTING_GAMES_REWINDTIME);
+
+  return static_cast<unsigned int>(std::max(rewindTimeSec, 0));
+}
+
+std::string CGameSettings::GetRAUsername() const
+{
+  return m_settings->GetString(SETTING_GAMES_ACHIEVEMENTS_USERNAME);
+}
+
+std::string CGameSettings::GetRAToken() const
+{
+  return m_settings->GetString(SETTING_GAMES_ACHIEVEMENTS_TOKEN);
+}
+
+void CGameSettings::OnSettingChanged(const std::shared_ptr<const CSetting>& setting)
+{
+  if (setting == nullptr)
+    return;
+
+  const std::string& settingId = setting->GetId();
+
+  if (settingId == SETTING_GAMES_ENABLEREWIND || settingId == SETTING_GAMES_REWINDTIME)
+  {
+    SetChanged();
+    NotifyObservers(ObservableMessageSettingsChanged);
+  }
+  else if (settingId == SETTING_GAMES_ACHIEVEMENTS_LOGGED_IN &&
+           std::dynamic_pointer_cast<const CSettingBool>(setting)->GetValue())
+  {
+    const std::string username = m_settings->GetString(SETTING_GAMES_ACHIEVEMENTS_USERNAME);
+    const std::string password = m_settings->GetString(SETTING_GAMES_ACHIEVEMENTS_PASSWORD);
+    std::string token = m_settings->GetString(SETTING_GAMES_ACHIEVEMENTS_TOKEN);
+
+    token = LoginToRA(username, password, std::move(token));
+
+    m_settings->SetString(SETTING_GAMES_ACHIEVEMENTS_TOKEN, token);
+
+    if (!token.empty())
+    {
+      m_settings->SetBool(SETTING_GAMES_ACHIEVEMENTS_LOGGED_IN, true);
+    }
+    else
+    {
+      if (settingId == SETTING_GAMES_ACHIEVEMENTS_PASSWORD)
+        m_settings->SetString(SETTING_GAMES_ACHIEVEMENTS_PASSWORD, "");
+      m_settings->SetBool(SETTING_GAMES_ACHIEVEMENTS_LOGGED_IN, false);
+    }
+
+    m_settings->Save();
+  }
+  else if (settingId == SETTING_GAMES_ACHIEVEMENTS_LOGGED_IN &&
+           !std::dynamic_pointer_cast<const CSettingBool>(setting)->GetValue())
+  {
+    m_settings->SetString(SETTING_GAMES_ACHIEVEMENTS_TOKEN, "");
+    m_settings->Save();
+  }
+  else if (settingId == SETTING_GAMES_ACHIEVEMENTS_USERNAME ||
+           settingId == SETTING_GAMES_ACHIEVEMENTS_PASSWORD)
+  {
+    m_settings->SetBool(SETTING_GAMES_ACHIEVEMENTS_LOGGED_IN, false);
+    m_settings->SetString(SETTING_GAMES_ACHIEVEMENTS_TOKEN, "");
+    m_settings->Save();
+  }
+}
+
+std::string CGameSettings::LoginToRA(const std::string& username,
+                                     const std::string& password,
+                                     std::string token) const
+{
+  if (username.empty() || password.empty())
+    return token;
+
+  XFILE::CFile request;
+  const CURL loginUrl(
+      StringUtils::Format(LOGIN_TO_RETRO_ACHIEVEMENTS_URL_TEMPLATE, username, password));
+
+  std::vector<uint8_t> response;
+  if (request.LoadFile(loginUrl, response) > 0)
+  {
+    std::string strResponse(response.begin(), response.end());
+    CVariant data(CVariant::VariantTypeObject);
+    if (CJSONVariantParser::Parse(strResponse, data))
+    {
+      if (data[SUCCESS].asBoolean())
+      {
+        token = data[TOKEN].asString();
+        if (!IsAccountVerified(username, token))
+        {
+          token.clear();
+          // "RetroAchievements", "Your account is not verified, please check your emails to complete your sign up"
+          CServiceBroker::GetEventLog()->AddWithNotification(
+              EventPtr(new CNotificationEvent(35264, 35270, EventLevel::Error)));
+        }
+      }
+      else
+      {
+        token.clear();
+
+        // "RetroAchievements", "Incorrect User/Password!"
+        CServiceBroker::GetEventLog()->AddWithNotification(
+            EventPtr(new CNotificationEvent(35264, 35265, EventLevel::Error)));
+      }
+    }
+    else
+    {
+      // "RetroAchievements", "Invalid response from server"
+      CServiceBroker::GetEventLog()->AddWithNotification(
+          EventPtr(new CNotificationEvent(35264, 35267, EventLevel::Error)));
+
+      CLog::Log(LOGERROR, "Invalid server response: {}", strResponse);
+    }
+  }
+  else
+  {
+    // "RetroAchievements", "Failed to contact server"
+    CServiceBroker::GetEventLog()->AddWithNotification(
+        EventPtr(new CNotificationEvent(35264, 35266, EventLevel::Error)));
+  }
+  return token;
+}
+
+bool CGameSettings::IsAccountVerified(const std::string& username, const std::string& token) const
+{
+  XFILE::CFile request;
+  const CURL getPatchFileUrl(StringUtils::Format(GET_PATCH_DATA_URL_TEMPLATE, username, token));
+  std::vector<uint8_t> response;
+  if (request.LoadFile(getPatchFileUrl, response) > 0)
+  {
+    std::string strResponse(response.begin(), response.end());
+    CVariant data(CVariant::VariantTypeObject);
+
+    if (CJSONVariantParser::Parse(strResponse, data))
+    {
+      return data[SUCCESS].asBoolean();
+    }
+  }
+
+  return false;
+}
diff --git a/xbmc/games/GameSettings.h b/xbmc/games/GameSettings.h
new file mode 100644
index 0000000..63ee67b
--- /dev/null
+++ b/xbmc/games/GameSettings.h
@@ -0,0 +1,55 @@
+/*
+ *  Copyright (C) 2012-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 "settings/lib/ISettingCallback.h"
+#include "utils/Observer.h"
+
+#include <string>
+
+class CSetting;
+class CSettings;
+
+namespace KODI
+{
+namespace GAME
+{
+
+class CGameSettings : public ISettingCallback, public Observable
+{
+public:
+  CGameSettings();
+  ~CGameSettings() override;
+
+  // General settings
+  bool GamesEnabled();
+  bool ShowOSDHelp();
+  void SetShowOSDHelp(bool bShow);
+  void ToggleGames();
+  bool AutosaveEnabled();
+  bool RewindEnabled();
+  unsigned int MaxRewindTimeSec();
+  std::string GetRAUsername() const;
+  std::string GetRAToken() const;
+
+  // Inherited from ISettingCallback
+  void OnSettingChanged(const std::shared_ptr<const CSetting>& setting) override;
+
+private:
+  std::string LoginToRA(const std::string& username,
+                        const std::string& password,
+                        std::string token) const;
+  bool IsAccountVerified(const std::string& username, const std::string& token) const;
+
+  // Construction parameters
+  std::shared_ptr<CSettings> m_settings;
+};
+
+} // namespace GAME
+} // namespace KODI
diff --git a/xbmc/games/GameTypes.h b/xbmc/games/GameTypes.h
new file mode 100644
index 0000000..3be3195
--- /dev/null
+++ b/xbmc/games/GameTypes.h
@@ -0,0 +1,32 @@
+/*
+ *  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 CGameClient;
+using GameClientPtr = std::shared_ptr<CGameClient>;
+using GameClientVector = std::vector<GameClientPtr>;
+
+class CGameClientPort;
+using GameClientPortPtr = std::unique_ptr<CGameClientPort>;
+using GameClientPortVec = std::vector<GameClientPortPtr>;
+
+class CGameClientDevice;
+using GameClientDevicePtr = std::unique_ptr<CGameClientDevice>;
+using GameClientDeviceVec = std::vector<GameClientDevicePtr>;
+
+} // namespace GAME
+} // namespace KODI
diff --git a/xbmc/games/GameUtils.cpp b/xbmc/games/GameUtils.cpp
new file mode 100644
index 0000000..5eba00b
--- /dev/null
+++ b/xbmc/games/GameUtils.cpp
@@ -0,0 +1,314 @@
+/*
+ *  Copyright (C) 2012-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 "GameUtils.h"
+
+#include "FileItem.h"
+#include "ServiceBroker.h"
+#include "URL.h"
+#include "addons/Addon.h"
+#include "addons/AddonInstaller.h"
+#include "addons/AddonManager.h"
+#include "addons/BinaryAddonCache.h"
+#include "addons/addoninfo/AddonType.h"
+#include "cores/RetroPlayer/savestates/ISavestate.h"
+#include "cores/RetroPlayer/savestates/SavestateDatabase.h"
+#include "filesystem/SpecialProtocol.h"
+#include "games/addons/GameClient.h"
+#include "games/dialogs/GUIDialogSelectGameClient.h"
+#include "games/dialogs/GUIDialogSelectSavestate.h"
+#include "games/tags/GameInfoTag.h"
+#include "messaging/helpers/DialogOKHelper.h"
+#include "utils/StringUtils.h"
+#include "utils/URIUtils.h"
+#include "utils/log.h"
+
+#include <algorithm>
+
+using namespace KODI;
+using namespace GAME;
+
+bool CGameUtils::FillInGameClient(CFileItem& item, std::string& savestatePath)
+{
+  using namespace ADDON;
+
+  if (item.GetGameInfoTag()->GetGameClient().empty())
+  {
+    // If the fileitem is an add-on, fall back to that
+    if (item.HasAddonInfo() && item.GetAddonInfo()->Type() == AddonType::GAMEDLL)
+    {
+      item.GetGameInfoTag()->SetGameClient(item.GetAddonInfo()->ID());
+    }
+    else
+    {
+      if (!CGUIDialogSelectSavestate::ShowAndGetSavestate(item.GetPath(), savestatePath))
+        return false;
+
+      if (!savestatePath.empty())
+      {
+        RETRO::CSavestateDatabase db;
+        std::unique_ptr<RETRO::ISavestate> save = RETRO::CSavestateDatabase::AllocateSavestate();
+        db.GetSavestate(savestatePath, *save);
+        item.GetGameInfoTag()->SetGameClient(save->GameClientID());
+      }
+      else
+      {
+        // No game client specified, need to ask the user
+        GameClientVector candidates;
+        GameClientVector installable;
+        bool bHasVfsGameClient;
+        GetGameClients(item, candidates, installable, bHasVfsGameClient);
+
+        if (candidates.empty() && installable.empty())
+        {
+          // if: "This game can only be played directly from a hard drive or partition. Compressed files must be extracted."
+          // else: "This game isn't compatible with any available emulators."
+          int errorTextId = bHasVfsGameClient ? 35214 : 35212;
+
+          // "Failed to play game"
+          KODI::MESSAGING::HELPERS::ShowOKDialogText(CVariant{35210}, CVariant{errorTextId});
+        }
+        else if (candidates.size() == 1 && installable.empty())
+        {
+          // Only 1 option, avoid prompting the user
+          item.GetGameInfoTag()->SetGameClient(candidates[0]->ID());
+        }
+        else
+        {
+          std::string gameClient = CGUIDialogSelectGameClient::ShowAndGetGameClient(
+              item.GetPath(), candidates, installable);
+
+          if (!gameClient.empty())
+            item.GetGameInfoTag()->SetGameClient(gameClient);
+        }
+      }
+    }
+  }
+
+  const std::string gameClient = item.GetGameInfoTag()->GetGameClient();
+  if (gameClient.empty())
+    return false;
+
+  if (Install(gameClient))
+  {
+    // If the addon is disabled we need to enable it
+    if (!Enable(gameClient))
+    {
+      CLog::Log(LOGDEBUG, "Failed to enable game client {}", gameClient);
+      item.GetGameInfoTag()->SetGameClient("");
+    }
+  }
+  else
+  {
+    CLog::Log(LOGDEBUG, "Failed to install game client: {}", gameClient);
+    item.GetGameInfoTag()->SetGameClient("");
+  }
+
+  return !item.GetGameInfoTag()->GetGameClient().empty();
+}
+
+void CGameUtils::GetGameClients(const CFileItem& file,
+                                GameClientVector& candidates,
+                                GameClientVector& installable,
+                                bool& bHasVfsGameClient)
+{
+  using namespace ADDON;
+
+  bHasVfsGameClient = false;
+
+  // Try to resolve path to a local file, as not all game clients support VFS
+  CURL translatedUrl(CSpecialProtocol::TranslatePath(file.GetPath()));
+
+  // Get local candidates
+  VECADDONS localAddons;
+  CBinaryAddonCache& addonCache = CServiceBroker::GetBinaryAddonCache();
+  addonCache.GetAddons(localAddons, AddonType::GAMEDLL);
+
+  bool bVfs = false;
+  GetGameClients(localAddons, translatedUrl, candidates, bVfs);
+  bHasVfsGameClient |= bVfs;
+
+  // Get remote candidates
+  VECADDONS remoteAddons;
+  if (CServiceBroker::GetAddonMgr().GetInstallableAddons(remoteAddons, AddonType::GAMEDLL))
+  {
+    GetGameClients(remoteAddons, translatedUrl, installable, bVfs);
+    bHasVfsGameClient |= bVfs;
+  }
+
+  // Sort by name
+  //! @todo Move to presentation code
+  auto SortByName = [](const GameClientPtr& lhs, const GameClientPtr& rhs) {
+    std::string lhsName = lhs->Name();
+    std::string rhsName = rhs->Name();
+
+    StringUtils::ToLower(lhsName);
+    StringUtils::ToLower(rhsName);
+
+    return lhsName < rhsName;
+  };
+
+  std::sort(candidates.begin(), candidates.end(), SortByName);
+  std::sort(installable.begin(), installable.end(), SortByName);
+}
+
+void CGameUtils::GetGameClients(const ADDON::VECADDONS& addons,
+                                const CURL& translatedUrl,
+                                GameClientVector& candidates,
+                                bool& bHasVfsGameClient)
+{
+  bHasVfsGameClient = false;
+
+  const std::string extension = URIUtils::GetExtension(translatedUrl.Get());
+
+  const bool bIsLocalFile =
+      (translatedUrl.GetProtocol() == "file" || translatedUrl.GetProtocol().empty());
+
+  for (auto& addon : addons)
+  {
+    GameClientPtr gameClient = std::static_pointer_cast<CGameClient>(addon);
+
+    // Filter by extension
+    if (!gameClient->IsExtensionValid(extension))
+      continue;
+
+    // Filter by VFS
+    if (!bIsLocalFile && !gameClient->SupportsVFS())
+    {
+      bHasVfsGameClient = true;
+      continue;
+    }
+
+    candidates.push_back(gameClient);
+  }
+}
+
+bool CGameUtils::HasGameExtension(const std::string& path)
+{
+  using namespace ADDON;
+
+  // Get filename from CURL so that top-level zip directories will become
+  // normal paths:
+  //
+  //   zip://%2Fpath_to_zip_file.zip/  ->  /path_to_zip_file.zip
+  //
+  std::string filename = CURL(path).GetFileNameWithoutPath();
+
+  // Get the file extension
+  std::string extension = URIUtils::GetExtension(filename);
+  if (extension.empty())
+    return false;
+
+  StringUtils::ToLower(extension);
+
+  // Look for a game client that supports this extension
+  VECADDONS gameClients;
+  CBinaryAddonCache& addonCache = CServiceBroker::GetBinaryAddonCache();
+  addonCache.GetInstalledAddons(gameClients, AddonType::GAMEDLL);
+  for (auto& gameClient : gameClients)
+  {
+    GameClientPtr gc(std::static_pointer_cast<CGameClient>(gameClient));
+    if (gc->IsExtensionValid(extension))
+      return true;
+  }
+
+  // Check remote add-ons
+  gameClients.clear();
+  if (CServiceBroker::GetAddonMgr().GetInstallableAddons(gameClients, AddonType::GAMEDLL))
+  {
+    for (auto& gameClient : gameClients)
+    {
+      GameClientPtr gc(std::static_pointer_cast<CGameClient>(gameClient));
+      if (gc->IsExtensionValid(extension))
+        return true;
+    }
+  }
+
+  return false;
+}
+
+std::set<std::string> CGameUtils::GetGameExtensions()
+{
+  using namespace ADDON;
+
+  std::set<std::string> extensions;
+
+  VECADDONS gameClients;
+  CBinaryAddonCache& addonCache = CServiceBroker::GetBinaryAddonCache();
+  addonCache.GetAddons(gameClients, AddonType::GAMEDLL);
+  for (auto& gameClient : gameClients)
+  {
+    GameClientPtr gc(std::static_pointer_cast<CGameClient>(gameClient));
+    extensions.insert(gc->GetExtensions().begin(), gc->GetExtensions().end());
+  }
+
+  // Check remote add-ons
+  gameClients.clear();
+  if (CServiceBroker::GetAddonMgr().GetInstallableAddons(gameClients, AddonType::GAMEDLL))
+  {
+    for (auto& gameClient : gameClients)
+    {
+      GameClientPtr gc(std::static_pointer_cast<CGameClient>(gameClient));
+      extensions.insert(gc->GetExtensions().begin(), gc->GetExtensions().end());
+    }
+  }
+
+  return extensions;
+}
+
+bool CGameUtils::IsStandaloneGame(const ADDON::AddonPtr& addon)
+{
+  using namespace ADDON;
+
+  switch (addon->Type())
+  {
+    case AddonType::GAMEDLL:
+    {
+      return std::static_pointer_cast<GAME::CGameClient>(addon)->SupportsStandalone();
+    }
+    case AddonType::SCRIPT:
+    {
+      return addon->HasType(AddonType::GAME);
+    }
+    default:
+      break;
+  }
+
+  return false;
+}
+
+bool CGameUtils::Install(const std::string& gameClient)
+{
+  // If the addon isn't installed we need to install it
+  bool installed = CServiceBroker::GetAddonMgr().IsAddonInstalled(gameClient);
+  if (!installed)
+  {
+    ADDON::AddonPtr installedAddon;
+    installed = ADDON::CAddonInstaller::GetInstance().InstallModal(
+        gameClient, installedAddon, ADDON::InstallModalPrompt::CHOICE_NO);
+    if (!installed)
+    {
+      CLog::Log(LOGERROR, "Game utils: Failed to install {}", gameClient);
+      // "Error"
+      // "Failed to install add-on."
+      MESSAGING::HELPERS::ShowOKDialogText(CVariant{257}, CVariant{35256});
+    }
+  }
+
+  return installed;
+}
+
+bool CGameUtils::Enable(const std::string& gameClient)
+{
+  bool bSuccess = true;
+
+  if (CServiceBroker::GetAddonMgr().IsAddonDisabled(gameClient))
+    bSuccess = CServiceBroker::GetAddonMgr().EnableAddon(gameClient);
+
+  return bSuccess;
+}
diff --git a/xbmc/games/GameUtils.h b/xbmc/games/GameUtils.h
new file mode 100644
index 0000000..b49985c
--- /dev/null
+++ b/xbmc/games/GameUtils.h
@@ -0,0 +1,105 @@
+/*
+ *  Copyright (C) 2012-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 "GameTypes.h"
+
+#include <set>
+#include <string>
+
+class CFileItem;
+class CURL;
+
+namespace ADDON
+{
+class IAddon;
+using AddonPtr = std::shared_ptr<IAddon>;
+using VECADDONS = std::vector<AddonPtr>;
+} // namespace ADDON
+
+namespace KODI
+{
+namespace GAME
+{
+/*!
+ * \ingroup games
+ * \brief Game related utilities.
+ */
+class CGameUtils
+{
+public:
+  /*!
+   * \brief Set the game client property, prompt the user for a savestate if there are any
+   * (savestates store the information of which game client created it).
+   * If there are no savestates or the user wants a new savestate, prompt the user
+   * for a game client.
+   *
+   * \param item The item with or without a game client in its info tag
+   * \param savestatePath Output. The path to the savestate selected. Empty if new savestate was
+   * selected
+   *
+   * \return True if the item has a valid game client ID in its info tag
+   */
+  static bool FillInGameClient(CFileItem& item, std::string& savestatePath);
+
+  /*!
+   * \brief Check if the file extension is supported by an add-on in
+   *        a local or remote repository
+   *
+   * \param path The path of the game file
+   *
+   * \return true if the path's extension is supported by a known game client
+   */
+  static bool HasGameExtension(const std::string& path);
+
+  /*!
+   * \brief Get all game extensions
+   */
+  static std::set<std::string> GetGameExtensions();
+
+  /*!
+   * \brief Check if game script or game add-on can be launched directly
+   *
+   * \return true if the add-on can be launched, false otherwise
+   */
+  static bool IsStandaloneGame(const ADDON::AddonPtr& addon);
+
+private:
+  static void GetGameClients(const CFileItem& file,
+                             GameClientVector& candidates,
+                             GameClientVector& installable,
+                             bool& bHasVfsGameClient);
+  static void GetGameClients(const ADDON::VECADDONS& addons,
+                             const CURL& translatedUrl,
+                             GameClientVector& candidates,
+                             bool& bHasVfsGameClient);
+
+  /*!
+   * \brief Install the specified game client
+   *
+   * If the game client is not installed, a model dialog is shown installing
+   * the game client. If the installation fails, an error dialog is shown.
+   *
+   * \param gameClient The game client to install
+   *
+   * \return True if the game client is installed, false otherwise
+   */
+  static bool Install(const std::string& gameClient);
+
+  /*!
+   * \brief Enable the specified game client
+   *
+   * \param gameClient the game client to enable
+   *
+   * \return True if the game client is enabled, false otherwise
+   */
+  static bool Enable(const std::string& gameClient);
+};
+} // namespace GAME
+} // namespace KODI
diff --git a/xbmc/games/addons/CMakeLists.txt b/xbmc/games/addons/CMakeLists.txt
new file mode 100644
index 0000000..42ec18d
--- /dev/null
+++ b/xbmc/games/addons/CMakeLists.txt
@@ -0,0 +1,14 @@
+set(SOURCES GameClient.cpp
+            GameClientInGameSaves.cpp
+            GameClientProperties.cpp
+            GameClientSubsystem.cpp
+            GameClientTranslator.cpp)
+
+set(HEADERS GameClient.h
+            GameClientCallbacks.h
+            GameClientInGameSaves.h
+            GameClientProperties.h
+            GameClientSubsystem.h
+            GameClientTranslator.h)
+
+core_add_library(gameaddons)
diff --git a/xbmc/games/addons/GameClient.cpp b/xbmc/games/addons/GameClient.cpp
new file mode 100644
index 0000000..b3e7e01
--- /dev/null
+++ b/xbmc/games/addons/GameClient.cpp
@@ -0,0 +1,730 @@
+/*
+ *  Copyright (C) 2012-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 "GameClient.h"
+
+#include "FileItem.h"
+#include "GameClientCallbacks.h"
+#include "GameClientInGameSaves.h"
+#include "GameClientProperties.h"
+#include "GameClientTranslator.h"
+#include "ServiceBroker.h"
+#include "URL.h"
+#include "addons/AddonManager.h"
+#include "addons/BinaryAddonCache.h"
+#include "addons/addoninfo/AddonInfo.h"
+#include "addons/addoninfo/AddonType.h"
+#include "filesystem/Directory.h"
+#include "filesystem/SpecialProtocol.h"
+#include "games/GameServices.h"
+#include "games/addons/cheevos/GameClientCheevos.h"
+#include "games/addons/input/GameClientInput.h"
+#include "games/addons/streams/GameClientStreams.h"
+#include "games/addons/streams/IGameClientStream.h"
+#include "guilib/GUIWindowManager.h"
+#include "guilib/LocalizeStrings.h"
+#include "guilib/WindowIDs.h"
+#include "input/actions/Action.h"
+#include "input/actions/ActionIDs.h"
+#include "messaging/ApplicationMessenger.h"
+#include "messaging/helpers/DialogOKHelper.h"
+#include "utils/FileUtils.h"
+#include "utils/StringUtils.h"
+#include "utils/URIUtils.h"
+#include "utils/log.h"
+
+#include <algorithm>
+#include <cstring>
+#include <iterator>
+#include <mutex>
+#include <utility>
+
+using namespace KODI;
+using namespace GAME;
+using namespace KODI::MESSAGING;
+
+#define EXTENSION_SEPARATOR "|"
+#define EXTENSION_WILDCARD "*"
+
+#define GAME_PROPERTY_EXTENSIONS "extensions"
+#define GAME_PROPERTY_SUPPORTS_VFS "supports_vfs"
+#define GAME_PROPERTY_SUPPORTS_STANDALONE "supports_standalone"
+
+// --- NormalizeExtension ------------------------------------------------------
+
+namespace
+{
+/*
+ * \brief Convert to lower case and canonicalize with a leading "."
+ */
+std::string NormalizeExtension(const std::string& strExtension)
+{
+  std::string ext = strExtension;
+
+  if (!ext.empty() && ext != EXTENSION_WILDCARD)
+  {
+    StringUtils::ToLower(ext);
+
+    if (ext[0] != '.')
+      ext.insert(0, ".");
+  }
+
+  return ext;
+}
+} // namespace
+
+// --- CGameClient -------------------------------------------------------------
+
+CGameClient::CGameClient(const ADDON::AddonInfoPtr& addonInfo)
+  : CAddonDll(addonInfo, ADDON::AddonType::GAMEDLL),
+    m_subsystems(CGameClientSubsystem::CreateSubsystems(*this, *m_ifc.game, m_critSection)),
+    m_bSupportsAllExtensions(false),
+    m_bIsPlaying(false),
+    m_serializeSize(0),
+    m_region(GAME_REGION_UNKNOWN)
+{
+  using namespace ADDON;
+
+  std::vector<std::string> extensions = StringUtils::Split(
+      Type(AddonType::GAMEDLL)->GetValue(GAME_PROPERTY_EXTENSIONS).asString(), EXTENSION_SEPARATOR);
+  std::transform(extensions.begin(), extensions.end(),
+                 std::inserter(m_extensions, m_extensions.begin()), NormalizeExtension);
+
+  // Check for wildcard extension
+  if (m_extensions.find(EXTENSION_WILDCARD) != m_extensions.end())
+  {
+    m_bSupportsAllExtensions = true;
+    m_extensions.clear();
+  }
+
+  m_bSupportsVFS =
+      addonInfo->Type(AddonType::GAMEDLL)->GetValue(GAME_PROPERTY_SUPPORTS_VFS).asBoolean();
+  m_bSupportsStandalone =
+      addonInfo->Type(AddonType::GAMEDLL)->GetValue(GAME_PROPERTY_SUPPORTS_STANDALONE).asBoolean();
+
+  std::tie(m_emulatorName, m_platforms) = ParseLibretroName(Name());
+}
+
+CGameClient::~CGameClient(void)
+{
+  CloseFile();
+  CGameClientSubsystem::DestroySubsystems(m_subsystems);
+}
+
+std::string CGameClient::LibPath() const
+{
+  // If the game client requires a proxy, load its DLL instead
+  if (m_ifc.game->props->proxy_dll_count > 0)
+    return GetDllPath(m_ifc.game->props->proxy_dll_paths[0]);
+
+  return CAddonDll::LibPath();
+}
+
+ADDON::AddonPtr CGameClient::GetRunningInstance() const
+{
+  using namespace ADDON;
+
+  CBinaryAddonCache& addonCache = CServiceBroker::GetBinaryAddonCache();
+  return addonCache.GetAddonInstance(ID(), Type());
+}
+
+bool CGameClient::SupportsPath() const
+{
+  return !m_extensions.empty() || m_bSupportsAllExtensions;
+}
+
+bool CGameClient::IsExtensionValid(const std::string& strExtension) const
+{
+  if (strExtension.empty())
+    return false;
+
+  if (SupportsAllExtensions())
+    return true;
+
+  return m_extensions.find(NormalizeExtension(strExtension)) != m_extensions.end();
+}
+
+bool CGameClient::Initialize(void)
+{
+  using namespace XFILE;
+
+  // Ensure user profile directory exists for add-on
+  if (!CDirectory::Exists(Profile()))
+    CDirectory::Create(Profile());
+
+  // Ensure directory exists for savestates
+  const CGameServices& gameServices = CServiceBroker::GetGameServices();
+  std::string savestatesDir = URIUtils::AddFileToFolder(gameServices.GetSavestatesFolder(), ID());
+  if (!CDirectory::Exists(savestatesDir))
+    CDirectory::Create(savestatesDir);
+
+  if (!AddonProperties().InitializeProperties())
+    return false;
+
+  m_ifc.game->toKodi->kodiInstance = this;
+  m_ifc.game->toKodi->CloseGame = cb_close_game;
+  m_ifc.game->toKodi->OpenStream = cb_open_stream;
+  m_ifc.game->toKodi->GetStreamBuffer = cb_get_stream_buffer;
+  m_ifc.game->toKodi->AddStreamData = cb_add_stream_data;
+  m_ifc.game->toKodi->ReleaseStreamBuffer = cb_release_stream_buffer;
+  m_ifc.game->toKodi->CloseStream = cb_close_stream;
+  m_ifc.game->toKodi->HwGetProcAddress = cb_hw_get_proc_address;
+  m_ifc.game->toKodi->InputEvent = cb_input_event;
+
+  memset(m_ifc.game->toAddon, 0, sizeof(KodiToAddonFuncTable_Game));
+
+  if (CreateInstance(&m_ifc) == ADDON_STATUS_OK)
+  {
+    Input().Initialize();
+    LogAddonProperties();
+    return true;
+  }
+
+  return false;
+}
+
+void CGameClient::Unload()
+{
+  Input().Deinitialize();
+
+  DestroyInstance(&m_ifc);
+}
+
+bool CGameClient::OpenFile(const CFileItem& file,
+                           RETRO::IStreamManager& streamManager,
+                           IGameInputCallback* input)
+{
+  // Check if we should open in standalone mode
+  if (file.GetPath().empty())
+    return false;
+
+  // Some cores "succeed" to load the file even if it doesn't exist
+  if (!CFileUtils::Exists(file.GetPath()))
+  {
+
+    // Failed to play game
+    // The required files can't be found.
+    HELPERS::ShowOKDialogText(CVariant{35210}, CVariant{g_localizeStrings.Get(35219)});
+    return false;
+  }
+
+  // Resolve special:// URLs
+  CURL translatedUrl(CSpecialProtocol::TranslatePath(file.GetPath()));
+
+  // Remove file:// from URLs if add-on doesn't support VFS
+  if (!m_bSupportsVFS)
+  {
+    if (translatedUrl.GetProtocol() == "file")
+      translatedUrl.SetProtocol("");
+  }
+
+  std::string path = translatedUrl.Get();
+  CLog::Log(LOGDEBUG, "GameClient: Loading {}", CURL::GetRedacted(path));
+
+  std::unique_lock<CCriticalSection> lock(m_critSection);
+
+  if (!Initialized())
+    return false;
+
+  CloseFile();
+
+  GAME_ERROR error = GAME_ERROR_FAILED;
+
+  // Loading the game might require the stream subsystem to be initialized
+  Streams().Initialize(streamManager);
+
+  try
+  {
+    LogError(error = m_ifc.game->toAddon->LoadGame(m_ifc.game, path.c_str()), "LoadGame()");
+  }
+  catch (...)
+  {
+    LogException("LoadGame()");
+  }
+
+  if (error != GAME_ERROR_NO_ERROR)
+  {
+    NotifyError(error);
+    Streams().Deinitialize();
+    return false;
+  }
+
+  if (!InitializeGameplay(file.GetPath(), streamManager, input))
+  {
+    Streams().Deinitialize();
+    return false;
+  }
+
+  return true;
+}
+
+bool CGameClient::OpenStandalone(RETRO::IStreamManager& streamManager, IGameInputCallback* input)
+{
+  CLog::Log(LOGDEBUG, "GameClient: Loading {} in standalone mode", ID());
+
+  std::unique_lock<CCriticalSection> lock(m_critSection);
+
+  if (!Initialized())
+    return false;
+
+  CloseFile();
+
+  GAME_ERROR error = GAME_ERROR_FAILED;
+
+  // Loading the game might require the stream subsystem to be initialized
+  Streams().Initialize(streamManager);
+
+  try
+  {
+    LogError(error = m_ifc.game->toAddon->LoadStandalone(m_ifc.game), "LoadStandalone()");
+  }
+  catch (...)
+  {
+    LogException("LoadStandalone()");
+  }
+
+  if (error != GAME_ERROR_NO_ERROR)
+  {
+    NotifyError(error);
+    Streams().Deinitialize();
+    return false;
+  }
+
+  if (!InitializeGameplay("", streamManager, input))
+  {
+    Streams().Deinitialize();
+    return false;
+  }
+
+  return true;
+}
+
+bool CGameClient::InitializeGameplay(const std::string& gamePath,
+                                     RETRO::IStreamManager& streamManager,
+                                     IGameInputCallback* input)
+{
+  if (LoadGameInfo())
+  {
+    Input().Start(input);
+
+    m_bIsPlaying = true;
+    m_gamePath = gamePath;
+    m_input = input;
+
+    m_inGameSaves.reset(new CGameClientInGameSaves(this, m_ifc.game));
+    m_inGameSaves->Load();
+
+    return true;
+  }
+
+  return false;
+}
+
+bool CGameClient::LoadGameInfo()
+{
+  bool bRequiresGameLoop;
+  try
+  {
+    bRequiresGameLoop = m_ifc.game->toAddon->RequiresGameLoop(m_ifc.game);
+  }
+  catch (...)
+  {
+    LogException("RequiresGameLoop()");
+    return false;
+  }
+
+  // Get information about system timings
+  // Can be called only after retro_load_game()
+  game_system_timing timingInfo = {};
+
+  bool bSuccess = false;
+  try
+  {
+    bSuccess =
+        LogError(m_ifc.game->toAddon->GetGameTiming(m_ifc.game, &timingInfo), "GetGameTiming()");
+  }
+  catch (...)
+  {
+    LogException("GetGameTiming()");
+  }
+
+  if (!bSuccess)
+  {
+    CLog::Log(LOGERROR, "GameClient: Failed to get timing info");
+    return false;
+  }
+
+  GAME_REGION region;
+  try
+  {
+    region = m_ifc.game->toAddon->GetRegion(m_ifc.game);
+  }
+  catch (...)
+  {
+    LogException("GetRegion()");
+    return false;
+  }
+
+  size_t serializeSize;
+  try
+  {
+    serializeSize = m_ifc.game->toAddon->SerializeSize(m_ifc.game);
+  }
+  catch (...)
+  {
+    LogException("SerializeSize()");
+    return false;
+  }
+
+  CLog::Log(LOGINFO, "GAME: ---------------------------------------");
+  CLog::Log(LOGINFO, "GAME: Game loop:      {}", bRequiresGameLoop ? "true" : "false");
+  CLog::Log(LOGINFO, "GAME: FPS:            {:f}", timingInfo.fps);
+  CLog::Log(LOGINFO, "GAME: Sample Rate:    {:f}", timingInfo.sample_rate);
+  CLog::Log(LOGINFO, "GAME: Region:         {}", CGameClientTranslator::TranslateRegion(region));
+  CLog::Log(LOGINFO, "GAME: Savestate size: {}", serializeSize);
+  CLog::Log(LOGINFO, "GAME: ---------------------------------------");
+
+  m_bRequiresGameLoop = bRequiresGameLoop;
+  m_serializeSize = serializeSize;
+  m_framerate = timingInfo.fps;
+  m_samplerate = timingInfo.sample_rate;
+  m_region = region;
+
+  return true;
+}
+
+void CGameClient::NotifyError(GAME_ERROR error)
+{
+  std::string missingResource;
+
+  if (error == GAME_ERROR_RESTRICTED)
+    missingResource = GetMissingResource();
+
+  if (!missingResource.empty())
+  {
+    // Failed to play game
+    // This game requires the following add-on: %s
+    HELPERS::ShowOKDialogText(CVariant{35210}, CVariant{StringUtils::Format(
+                                                   g_localizeStrings.Get(35211), missingResource)});
+  }
+  else
+  {
+    // Failed to play game
+    // The emulator "%s" had an internal error.
+    HELPERS::ShowOKDialogText(CVariant{35210},
+                              CVariant{StringUtils::Format(g_localizeStrings.Get(35213), Name())});
+  }
+}
+
+std::string CGameClient::GetMissingResource()
+{
+  using namespace ADDON;
+
+  std::string strAddonId;
+
+  const auto& dependencies = GetDependencies();
+  for (auto it = dependencies.begin(); it != dependencies.end(); ++it)
+  {
+    const std::string& strDependencyId = it->id;
+    if (StringUtils::StartsWith(strDependencyId, "resource.games"))
+    {
+      AddonPtr addon;
+      const bool bInstalled =
+          CServiceBroker::GetAddonMgr().GetAddon(strDependencyId, addon, OnlyEnabled::CHOICE_YES);
+      if (!bInstalled)
+      {
+        strAddonId = strDependencyId;
+        break;
+      }
+    }
+  }
+
+  return strAddonId;
+}
+
+void CGameClient::Reset()
+{
+  std::unique_lock<CCriticalSection> lock(m_critSection);
+
+  if (m_bIsPlaying)
+  {
+    try
+    {
+      LogError(m_ifc.game->toAddon->Reset(m_ifc.game), "Reset()");
+    }
+    catch (...)
+    {
+      LogException("Reset()");
+    }
+  }
+}
+
+void CGameClient::CloseFile()
+{
+  std::unique_lock<CCriticalSection> lock(m_critSection);
+
+  if (m_bIsPlaying)
+  {
+    m_inGameSaves->Save();
+    m_inGameSaves.reset();
+
+    m_bIsPlaying = false;
+    m_gamePath.clear();
+    m_serializeSize = 0;
+    m_input = nullptr;
+
+    Input().Stop();
+
+    try
+    {
+      LogError(m_ifc.game->toAddon->UnloadGame(m_ifc.game), "UnloadGame()");
+    }
+    catch (...)
+    {
+      LogException("UnloadGame()");
+    }
+
+    Streams().Deinitialize();
+  }
+}
+
+void CGameClient::RunFrame()
+{
+  IGameInputCallback* input;
+
+  {
+    std::unique_lock<CCriticalSection> lock(m_critSection);
+    input = m_input;
+  }
+
+  if (input)
+    input->PollInput();
+
+  std::unique_lock<CCriticalSection> lock(m_critSection);
+
+  if (m_bIsPlaying)
+  {
+    try
+    {
+      LogError(m_ifc.game->toAddon->RunFrame(m_ifc.game), "RunFrame()");
+    }
+    catch (...)
+    {
+      LogException("RunFrame()");
+    }
+  }
+}
+
+bool CGameClient::Serialize(uint8_t* data, size_t size)
+{
+  if (data == nullptr || size == 0)
+    return false;
+
+  std::unique_lock<CCriticalSection> lock(m_critSection);
+
+  bool bSuccess = false;
+  if (m_bIsPlaying)
+  {
+    try
+    {
+      bSuccess = LogError(m_ifc.game->toAddon->Serialize(m_ifc.game, data, size), "Serialize()");
+    }
+    catch (...)
+    {
+      LogException("Serialize()");
+    }
+  }
+
+  return bSuccess;
+}
+
+bool CGameClient::Deserialize(const uint8_t* data, size_t size)
+{
+  if (data == nullptr || size == 0)
+    return false;
+
+  std::unique_lock<CCriticalSection> lock(m_critSection);
+
+  bool bSuccess = false;
+  if (m_bIsPlaying)
+  {
+    try
+    {
+      bSuccess =
+          LogError(m_ifc.game->toAddon->Deserialize(m_ifc.game, data, size), "Deserialize()");
+    }
+    catch (...)
+    {
+      LogException("Deserialize()");
+    }
+  }
+
+  return bSuccess;
+}
+
+void CGameClient::LogAddonProperties(void) const
+{
+  CLog::Log(LOGINFO, "GAME: ------------------------------------");
+  CLog::Log(LOGINFO, "GAME: Loaded DLL for {}", ID());
+  CLog::Log(LOGINFO, "GAME: Client:              {}", Name());
+  CLog::Log(LOGINFO, "GAME: Version:             {}", Version().asString());
+  CLog::Log(LOGINFO, "GAME: Valid extensions:    {}", StringUtils::Join(m_extensions, " "));
+  CLog::Log(LOGINFO, "GAME: Supports VFS:        {}", m_bSupportsVFS);
+  CLog::Log(LOGINFO, "GAME: Supports standalone: {}", m_bSupportsStandalone);
+  CLog::Log(LOGINFO, "GAME: ------------------------------------");
+}
+
+bool CGameClient::LogError(GAME_ERROR error, const char* strMethod) const
+{
+  if (error != GAME_ERROR_NO_ERROR)
+  {
+    CLog::Log(LOGERROR, "GAME - {} - addon '{}' returned an error: {}", strMethod, ID(),
+              CGameClientTranslator::ToString(error));
+    return false;
+  }
+  return true;
+}
+
+void CGameClient::LogException(const char* strFunctionName) const
+{
+  CLog::Log(LOGERROR, "GAME: exception caught while trying to call '{}' on add-on {}",
+            strFunctionName, ID());
+  CLog::Log(LOGERROR, "Please contact the developer of this add-on: {}", Author());
+}
+
+void CGameClient::cb_close_game(KODI_HANDLE kodiInstance)
+{
+  CServiceBroker::GetAppMessenger()->PostMsg(TMSG_GUI_ACTION, WINDOW_INVALID, -1,
+                                             static_cast<void*>(new CAction(ACTION_STOP)));
+}
+
+KODI_GAME_STREAM_HANDLE CGameClient::cb_open_stream(KODI_HANDLE kodiInstance,
+                                                    const game_stream_properties* properties)
+{
+  if (properties == nullptr)
+    return nullptr;
+
+  CGameClient* gameClient = static_cast<CGameClient*>(kodiInstance);
+  if (gameClient == nullptr)
+    return nullptr;
+
+  return gameClient->Streams().OpenStream(*properties);
+}
+
+bool CGameClient::cb_get_stream_buffer(KODI_HANDLE kodiInstance,
+                                       KODI_GAME_STREAM_HANDLE stream,
+                                       unsigned int width,
+                                       unsigned int height,
+                                       game_stream_buffer* buffer)
+{
+  if (buffer == nullptr)
+    return false;
+
+  IGameClientStream* gameClientStream = static_cast<IGameClientStream*>(stream);
+  if (gameClientStream == nullptr)
+    return false;
+
+  return gameClientStream->GetBuffer(width, height, *buffer);
+}
+
+void CGameClient::cb_add_stream_data(KODI_HANDLE kodiInstance,
+                                     KODI_GAME_STREAM_HANDLE stream,
+                                     const game_stream_packet* packet)
+{
+  if (packet == nullptr)
+    return;
+
+  IGameClientStream* gameClientStream = static_cast<IGameClientStream*>(stream);
+  if (gameClientStream == nullptr)
+    return;
+
+  gameClientStream->AddData(*packet);
+}
+
+void CGameClient::cb_release_stream_buffer(KODI_HANDLE kodiInstance,
+                                           KODI_GAME_STREAM_HANDLE stream,
+                                           game_stream_buffer* buffer)
+{
+  if (buffer == nullptr)
+    return;
+
+  IGameClientStream* gameClientStream = static_cast<IGameClientStream*>(stream);
+  if (gameClientStream == nullptr)
+    return;
+
+  gameClientStream->ReleaseBuffer(*buffer);
+}
+
+void CGameClient::cb_close_stream(KODI_HANDLE kodiInstance, KODI_GAME_STREAM_HANDLE stream)
+{
+  CGameClient* gameClient = static_cast<CGameClient*>(kodiInstance);
+  if (gameClient == nullptr)
+    return;
+
+  IGameClientStream* gameClientStream = static_cast<IGameClientStream*>(stream);
+  if (gameClientStream == nullptr)
+    return;
+
+  gameClient->Streams().CloseStream(gameClientStream);
+}
+
+game_proc_address_t CGameClient::cb_hw_get_proc_address(KODI_HANDLE kodiInstance, const char* sym)
+{
+  CGameClient* gameClient = static_cast<CGameClient*>(kodiInstance);
+  if (!gameClient)
+    return nullptr;
+
+  //! @todo
+  return nullptr;
+}
+
+bool CGameClient::cb_input_event(KODI_HANDLE kodiInstance, const game_input_event* event)
+{
+  CGameClient* gameClient = static_cast<CGameClient*>(kodiInstance);
+  if (!gameClient)
+    return false;
+
+  if (event == nullptr)
+    return false;
+
+  return gameClient->Input().ReceiveInputEvent(*event);
+}
+
+std::pair<std::string, std::string> CGameClient::ParseLibretroName(const std::string& addonName)
+{
+  std::string emulatorName;
+  std::string platforms;
+
+  // libretro has a de-facto standard for naming their cores. If the
+  // core emulates one or more platforms, then the format is:
+  //
+  //   "Platforms (Emulator name)"
+  //
+  // Otherwise, the format is just the name with no platforms:
+  //
+  //   "Emulator name"
+  //
+  // The has been observed for all 130 cores we package.
+  //
+  size_t beginPos = addonName.find('(');
+  size_t endPos = addonName.find(')');
+
+  if (beginPos != std::string::npos && endPos != std::string::npos && beginPos < endPos)
+  {
+    emulatorName = addonName.substr(beginPos + 1, endPos - beginPos - 1);
+    platforms = addonName.substr(0, beginPos);
+    StringUtils::TrimRight(platforms);
+  }
+  else
+  {
+    emulatorName = addonName;
+    platforms.clear();
+  }
+
+  return std::make_pair(emulatorName, platforms);
+}
diff --git a/xbmc/games/addons/GameClient.h b/xbmc/games/addons/GameClient.h
new file mode 100644
index 0000000..12a0b61
--- /dev/null
+++ b/xbmc/games/addons/GameClient.h
@@ -0,0 +1,264 @@
+/*
+ *  Copyright (C) 2012-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 "GameClientSubsystem.h"
+#include "addons/binary-addons/AddonDll.h"
+#include "addons/kodi-dev-kit/include/kodi/addon-instance/Game.h"
+#include "threads/CriticalSection.h"
+
+#include <atomic>
+#include <memory>
+#include <set>
+#include <stdint.h>
+#include <string>
+#include <utility>
+
+class CFileItem;
+
+namespace KODI
+{
+namespace RETRO
+{
+class IStreamManager;
+}
+
+namespace GAME
+{
+
+class CGameClientCheevos;
+class CGameClientInGameSaves;
+class CGameClientInput;
+class CGameClientProperties;
+class IGameInputCallback;
+
+/*!
+ * \ingroup games
+ * \brief Helper class to have "C" struct created before other parts becomes his pointer.
+ */
+class CGameClientStruct
+{
+public:
+  CGameClientStruct()
+  {
+    // Create "C" interface structures, used as own parts to prevent API problems on update
+    KODI_ADDON_INSTANCE_INFO* info = new KODI_ADDON_INSTANCE_INFO();
+    info->id = "";
+    info->version = kodi::addon::GetTypeVersion(ADDON_INSTANCE_GAME);
+    info->type = ADDON_INSTANCE_GAME;
+    info->kodi = this;
+    info->parent = nullptr;
+    info->first_instance = true;
+    info->functions = new KODI_ADDON_INSTANCE_FUNC_CB();
+    m_ifc.info = info;
+    m_ifc.functions = new KODI_ADDON_INSTANCE_FUNC();
+
+    m_ifc.game = new AddonInstance_Game;
+    m_ifc.game->props = new AddonProps_Game();
+    m_ifc.game->toKodi = new AddonToKodiFuncTable_Game();
+    m_ifc.game->toAddon = new KodiToAddonFuncTable_Game();
+  }
+
+  ~CGameClientStruct()
+  {
+    delete m_ifc.functions;
+    if (m_ifc.info)
+      delete m_ifc.info->functions;
+    delete m_ifc.info;
+    if (m_ifc.game)
+    {
+      delete m_ifc.game->toAddon;
+      delete m_ifc.game->toKodi;
+      delete m_ifc.game->props;
+      delete m_ifc.game;
+    }
+  }
+
+  KODI_ADDON_INSTANCE_STRUCT m_ifc;
+};
+
+/*!
+ * \ingroup games
+ * \brief Interface between Kodi and Game add-ons.
+ *
+ * The game add-on system is extremely large. To make the code more manageable,
+ * a subsystem pattern has been put in place. This pattern takes functionality
+ * that would normally be placed in this class, and puts it in another class
+ * (a "subsystem").
+ *
+ * The architecture is relatively simple. Subsystems are placed in a flat
+ * struct and accessed by calling the subsystem name. For example,
+ * historically, OpenJoystick() was a member of this class. Now, the function
+ * is called like Input().OpenJoystick().
+ *
+ * Although this pattern adds a layer of complexity, it enforces modularity and
+ * separation of concerns by making it very clear when one subsystem becomes
+ * dependent on another. Subsystems are all given access to each other by the
+ * calling mechanism. However, calling a subsystem creates a dependency on it,
+ * and an engineering decision must be made to justify the dependency.
+ *
+ * CONTRIBUTING
+ *
+ * If you wish to contribute, a beneficial task would be to refactor anything
+ * in this class into a new subsystem:
+ *
+ * Using line count as a heuristic, the subsystem pattern has shrunk the .cpp
+ * from 1,200 lines to just over 600. Reducing this further is the challenge.
+ * You must now choose whether to accept.
+ */
+class CGameClient : public ADDON::CAddonDll, private CGameClientStruct
+{
+public:
+  explicit CGameClient(const ADDON::AddonInfoPtr& addonInfo);
+
+  ~CGameClient() override;
+
+  // Game subsystems (const)
+  const CGameClientCheevos& Cheevos() const { return *m_subsystems.Cheevos; }
+  const CGameClientInput& Input() const { return *m_subsystems.Input; }
+  const CGameClientProperties& AddonProperties() const { return *m_subsystems.AddonProperties; }
+  const CGameClientStreams& Streams() const { return *m_subsystems.Streams; }
+
+  // Game subsystems (mutable)
+  CGameClientCheevos& Cheevos() { return *m_subsystems.Cheevos; }
+  CGameClientInput& Input() { return *m_subsystems.Input; }
+  CGameClientProperties& AddonProperties() { return *m_subsystems.AddonProperties; }
+  CGameClientStreams& Streams() { return *m_subsystems.Streams; }
+
+  // Implementation of IAddon via CAddonDll
+  std::string LibPath() const override;
+  ADDON::AddonPtr GetRunningInstance() const override;
+
+  // Query properties of the game client
+  bool SupportsStandalone() const { return m_bSupportsStandalone; }
+  bool SupportsPath() const;
+  bool SupportsVFS() const { return m_bSupportsVFS; }
+  const std::set<std::string>& GetExtensions() const { return m_extensions; }
+  bool SupportsAllExtensions() const { return m_bSupportsAllExtensions; }
+  bool IsExtensionValid(const std::string& strExtension) const;
+  const std::string& GetEmulatorName() const { return m_emulatorName; }
+  const std::string& GetPlatforms() const { return m_platforms; }
+
+  // Start/stop gameplay
+  bool Initialize(void);
+  void Unload();
+  bool OpenFile(const CFileItem& file,
+                RETRO::IStreamManager& streamManager,
+                IGameInputCallback* input);
+  bool OpenStandalone(RETRO::IStreamManager& streamManager, IGameInputCallback* input);
+  void Reset();
+  void CloseFile();
+  const std::string& GetGamePath() const { return m_gamePath; }
+
+  // Playback control
+  bool RequiresGameLoop() const { return m_bRequiresGameLoop; }
+  bool IsPlaying() const { return m_bIsPlaying; }
+  size_t GetSerializeSize() const { return m_serializeSize; }
+  double GetFrameRate() const { return m_framerate; }
+  double GetSampleRate() const { return m_samplerate; }
+  void RunFrame();
+
+  // Access memory
+  size_t SerializeSize() const { return m_serializeSize; }
+  bool Serialize(uint8_t* data, size_t size);
+  bool Deserialize(const uint8_t* data, size_t size);
+
+  /*!
+   * @brief To get the interface table used between addon and kodi
+   * @todo This function becomes removed after old callback library system
+   * is removed.
+   */
+  AddonInstance_Game* GetInstanceInterface() { return m_ifc.game; }
+
+  // Helper functions
+  bool LogError(GAME_ERROR error, const char* strMethod) const;
+  void LogException(const char* strFunctionName) const;
+
+private:
+  // Private gameplay functions
+  bool InitializeGameplay(const std::string& gamePath,
+                          RETRO::IStreamManager& streamManager,
+                          IGameInputCallback* input);
+  bool LoadGameInfo();
+  void NotifyError(GAME_ERROR error);
+  std::string GetMissingResource();
+
+  // Helper functions
+  void LogAddonProperties(void) const;
+
+  /*!
+   * @brief Callback functions from addon to kodi
+   */
+  //@{
+  static void cb_close_game(KODI_HANDLE kodiInstance);
+  static KODI_GAME_STREAM_HANDLE cb_open_stream(KODI_HANDLE kodiInstance,
+                                                const game_stream_properties* properties);
+  static bool cb_get_stream_buffer(KODI_HANDLE kodiInstance,
+                                   KODI_GAME_STREAM_HANDLE stream,
+                                   unsigned int width,
+                                   unsigned int height,
+                                   game_stream_buffer* buffer);
+  static void cb_add_stream_data(KODI_HANDLE kodiInstance,
+                                 KODI_GAME_STREAM_HANDLE stream,
+                                 const game_stream_packet* packet);
+  static void cb_release_stream_buffer(KODI_HANDLE kodiInstance,
+                                       KODI_GAME_STREAM_HANDLE stream,
+                                       game_stream_buffer* buffer);
+  static void cb_close_stream(KODI_HANDLE kodiInstance, KODI_GAME_STREAM_HANDLE stream);
+  static game_proc_address_t cb_hw_get_proc_address(KODI_HANDLE kodiInstance, const char* sym);
+  static bool cb_input_event(KODI_HANDLE kodiInstance, const game_input_event* event);
+  //@}
+
+  /*!
+   * \brief Parse the name of a libretro game add-on into its emulator name
+   * and platforms
+   *
+   * \param addonName The name of the add-on, e.g. "Nintendo - SNES / SFC (Snes9x 2002)"
+   *
+   * \return A tuple of two strings:
+   *   - first:  the emulator name, e.g. "Snes9x 2002"
+   *   - second: the platforms, e.g. "Nintendo - SNES / SFC"
+   *
+   * For cores that don't emulate a platform, such as 2048 with the add-on name
+   * "2048", then the emulator name will be the add-on name and platforms
+   * will be empty, e.g.:
+   *   - first:  "2048"
+   *   - second: ""
+   */
+  static std::pair<std::string, std::string> ParseLibretroName(const std::string& addonName);
+
+  // Game subsystems
+  GameClientSubsystems m_subsystems;
+
+  // Game API xml parameters
+  bool m_bSupportsVFS;
+  bool m_bSupportsStandalone;
+  std::set<std::string> m_extensions;
+  bool m_bSupportsAllExtensions;
+  std::string m_emulatorName;
+  std::string m_platforms;
+
+  // Properties of the current playing file
+  std::atomic_bool m_bIsPlaying; // True between OpenFile() and CloseFile()
+  std::string m_gamePath;
+  bool m_bRequiresGameLoop = false;
+  size_t m_serializeSize;
+  IGameInputCallback* m_input = nullptr; // The input callback passed to OpenFile()
+  double m_framerate = 0.0; // Video frame rate (fps)
+  double m_samplerate = 0.0; // Audio sample rate (Hz)
+  GAME_REGION m_region; // Region of the loaded game
+
+  // In-game saves
+  std::unique_ptr<CGameClientInGameSaves> m_inGameSaves;
+
+  CCriticalSection m_critSection;
+};
+
+} // namespace GAME
+} // namespace KODI
diff --git a/xbmc/games/addons/GameClientCallbacks.h b/xbmc/games/addons/GameClientCallbacks.h
new file mode 100644
index 0000000..f4bbe2d
--- /dev/null
+++ b/xbmc/games/addons/GameClientCallbacks.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
+
+namespace KODI
+{
+namespace GAME
+{
+/*!
+ * \brief Input callbacks
+ *
+ * @todo Remove this file when Game API is updated for input polling
+ */
+class IGameInputCallback
+{
+public:
+  virtual ~IGameInputCallback() = default;
+
+  /*!
+   * \brief Return true if the input source accepts input
+   *
+   * \return True if input should be processed, false otherwise
+   */
+  virtual bool AcceptsInput() const = 0;
+
+  /*!
+   * \brief Poll the input source for input
+   */
+  virtual void PollInput() = 0;
+};
+} // namespace GAME
+} // namespace KODI
diff --git a/xbmc/games/addons/GameClientInGameSaves.cpp b/xbmc/games/addons/GameClientInGameSaves.cpp
new file mode 100644
index 0000000..802ebb7
--- /dev/null
+++ b/xbmc/games/addons/GameClientInGameSaves.cpp
@@ -0,0 +1,164 @@
+/*
+ *  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 "GameClientInGameSaves.h"
+
+#include "GameClient.h"
+#include "GameClientTranslator.h"
+#include "ServiceBroker.h"
+#include "filesystem/Directory.h"
+#include "filesystem/File.h"
+#include "games/GameServices.h"
+#include "utils/URIUtils.h"
+#include "utils/log.h"
+
+#include <assert.h>
+
+using namespace KODI;
+using namespace GAME;
+
+#define INGAME_SAVES_DIRECTORY "InGameSaves"
+#define INGAME_SAVES_EXTENSION_SAVE_RAM ".sav"
+#define INGAME_SAVES_EXTENSION_RTC ".rtc"
+
+CGameClientInGameSaves::CGameClientInGameSaves(CGameClient* addon,
+                                               const AddonInstance_Game* dllStruct)
+  : m_gameClient(addon), m_dllStruct(dllStruct)
+{
+  assert(m_gameClient != nullptr);
+  assert(m_dllStruct != nullptr);
+}
+
+void CGameClientInGameSaves::Load()
+{
+  Load(GAME_MEMORY_SAVE_RAM);
+  Load(GAME_MEMORY_RTC);
+}
+
+void CGameClientInGameSaves::Save()
+{
+  Save(GAME_MEMORY_SAVE_RAM);
+  Save(GAME_MEMORY_RTC);
+}
+
+std::string CGameClientInGameSaves::GetPath(GAME_MEMORY memoryType)
+{
+  const CGameServices& gameServices = CServiceBroker::GetGameServices();
+  std::string path =
+      URIUtils::AddFileToFolder(gameServices.GetSavestatesFolder(), INGAME_SAVES_DIRECTORY);
+  if (!XFILE::CDirectory::Exists(path))
+    XFILE::CDirectory::Create(path);
+
+  // Append save game filename
+  std::string gamePath = URIUtils::GetFileName(m_gameClient->GetGamePath());
+  path = URIUtils::AddFileToFolder(path, gamePath.empty() ? m_gameClient->ID() : gamePath);
+
+  // Append file extension
+  switch (memoryType)
+  {
+    case GAME_MEMORY_SAVE_RAM:
+      return path + INGAME_SAVES_EXTENSION_SAVE_RAM;
+    case GAME_MEMORY_RTC:
+      return path + INGAME_SAVES_EXTENSION_RTC;
+    default:
+      break;
+  }
+  return std::string();
+}
+
+void CGameClientInGameSaves::Load(GAME_MEMORY memoryType)
+{
+  uint8_t* gameMemory = nullptr;
+  size_t size = 0;
+
+  try
+  {
+    m_dllStruct->toAddon->GetMemory(m_dllStruct, memoryType, &gameMemory, &size);
+  }
+  catch (...)
+  {
+    CLog::Log(LOGERROR, "GAME: {}: Exception caught in GetMemory()", m_gameClient->ID());
+  }
+
+  const std::string path = GetPath(memoryType);
+  if (size > 0 && XFILE::CFile::Exists(path))
+  {
+    XFILE::CFile file;
+    if (file.Open(path))
+    {
+      ssize_t read = file.Read(gameMemory, size);
+      if (read == static_cast<ssize_t>(size))
+      {
+        CLog::Log(LOGINFO, "GAME: In-game saves ({}) loaded from {}",
+                  CGameClientTranslator::ToString(memoryType), path);
+      }
+      else
+      {
+        CLog::Log(LOGERROR, "GAME: Failed to read in-game saves ({}): {}/{} bytes read",
+                  CGameClientTranslator::ToString(memoryType), read, size);
+      }
+    }
+    else
+    {
+      CLog::Log(LOGERROR, "GAME: Unable to open in-game saves ({}) from file {}",
+                CGameClientTranslator::ToString(memoryType), path);
+    }
+  }
+  else
+  {
+    CLog::Log(LOGDEBUG, "GAME: No in-game saves ({}) to load",
+              CGameClientTranslator::ToString(memoryType));
+  }
+}
+
+void CGameClientInGameSaves::Save(GAME_MEMORY memoryType)
+{
+  uint8_t* gameMemory = nullptr;
+  size_t size = 0;
+
+  try
+  {
+    m_dllStruct->toAddon->GetMemory(m_dllStruct, memoryType, &gameMemory, &size);
+  }
+  catch (...)
+  {
+    CLog::Log(LOGERROR, "GAME: {}: Exception caught in GetMemory()", m_gameClient->ID());
+  }
+
+  if (size > 0)
+  {
+    const std::string path = GetPath(memoryType);
+    XFILE::CFile file;
+    if (file.OpenForWrite(path, true))
+    {
+      ssize_t written = 0;
+      written = file.Write(gameMemory, size);
+      file.Close();
+      if (written == static_cast<ssize_t>(size))
+      {
+        CLog::Log(LOGINFO, "GAME: In-game saves ({}) written to {}",
+                  CGameClientTranslator::ToString(memoryType), path);
+      }
+      else
+      {
+        CLog::Log(LOGERROR, "GAME: Failed to write in-game saves ({}): {}/{} bytes written",
+                  CGameClientTranslator::ToString(memoryType), written, size);
+      }
+    }
+    else
+    {
+      CLog::Log(LOGERROR, "GAME: Unable to open in-game saves ({}) from file {}",
+                CGameClientTranslator::ToString(memoryType), path);
+    }
+  }
+  else
+  {
+    CLog::Log(LOGDEBUG, "GAME: No in-game saves ({}) to save",
+              CGameClientTranslator::ToString(memoryType));
+  }
+}
diff --git a/xbmc/games/addons/GameClientInGameSaves.h b/xbmc/games/addons/GameClientInGameSaves.h
new file mode 100644
index 0000000..a75c155
--- /dev/null
+++ b/xbmc/games/addons/GameClientInGameSaves.h
@@ -0,0 +1,66 @@
+/*
+ *  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 "addons/kodi-dev-kit/include/kodi/addon-instance/Game.h"
+
+#include <string>
+
+struct GameClient;
+
+namespace KODI
+{
+namespace GAME
+{
+class CGameClient;
+
+/*!
+ * \brief This class implements in-game saves.
+ *
+ * \details Some games do not implement state persistence on their own, but rely on the frontend for
+ * saving their current memory state to disk. This is mostly the case for emulators for SRAM
+ * (battery backed up ram on cartridges) or memory cards.
+ *
+ * Differences to save states:
+ * - Works only for supported games (e.g. emulated games with SRAM support)
+ * - Often works emulator independent (and can be used to start a game with one emulator and
+ * continue with another)
+ * - Visible in-game (e.g. in-game save game selection menus)
+ */
+class CGameClientInGameSaves
+{
+public:
+  /*!
+   * \brief Constructor.
+   * \param addon The game client implementation.
+   * \param dllStruct The emulator or game for which the in-game saves are processed.
+   */
+  CGameClientInGameSaves(CGameClient* addon, const AddonInstance_Game* dllStruct);
+
+  /*!
+   * \brief Load in-game data.
+   */
+  void Load();
+
+  /*!
+   * \brief Save in-game data.
+   */
+  void Save();
+
+private:
+  std::string GetPath(GAME_MEMORY memoryType);
+
+  void Load(GAME_MEMORY memoryType);
+  void Save(GAME_MEMORY memoryType);
+
+  const CGameClient* const m_gameClient;
+  const AddonInstance_Game* const m_dllStruct;
+};
+} // namespace GAME
+} // namespace KODI
diff --git a/xbmc/games/addons/GameClientProperties.cpp b/xbmc/games/addons/GameClientProperties.cpp
new file mode 100644
index 0000000..4f7273a
--- /dev/null
+++ b/xbmc/games/addons/GameClientProperties.cpp
@@ -0,0 +1,292 @@
+/*
+ *  Copyright (C) 2012-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 "GameClientProperties.h"
+
+#include "FileItem.h"
+#include "GameClient.h"
+#include "ServiceBroker.h"
+#include "addons/AddonManager.h"
+#include "addons/GameResource.h"
+#include "addons/IAddon.h"
+#include "addons/addoninfo/AddonInfo.h"
+#include "addons/addoninfo/AddonType.h"
+#include "dialogs/GUIDialogYesNo.h"
+#include "filesystem/Directory.h"
+#include "filesystem/SpecialProtocol.h"
+#include "guilib/LocalizeStrings.h"
+#include "messaging/helpers/DialogOKHelper.h"
+#include "utils/StringUtils.h"
+#include "utils/Variant.h"
+#include "utils/log.h"
+
+#include <cstring>
+
+using namespace KODI;
+using namespace ADDON;
+using namespace GAME;
+using namespace XFILE;
+
+#define GAME_CLIENT_RESOURCES_DIRECTORY "resources"
+
+CGameClientProperties::CGameClientProperties(const CGameClient& parent, AddonProps_Game& props)
+  : m_parent(parent), m_properties(props)
+{
+}
+
+void CGameClientProperties::ReleaseResources(void)
+{
+  for (auto& it : m_proxyDllPaths)
+    delete[] it;
+  m_proxyDllPaths.clear();
+
+  for (auto& it : m_resourceDirectories)
+    delete[] it;
+  m_resourceDirectories.clear();
+
+  for (auto& it : m_extensions)
+    delete[] it;
+  m_extensions.clear();
+}
+
+bool CGameClientProperties::InitializeProperties(void)
+{
+  ReleaseResources();
+
+  ADDON::VECADDONS addons;
+  if (!GetProxyAddons(addons))
+    return false;
+
+  m_properties.game_client_dll_path = GetLibraryPath();
+  m_properties.proxy_dll_paths = GetProxyDllPaths(addons);
+  m_properties.proxy_dll_count = GetProxyDllCount();
+  m_properties.resource_directories = GetResourceDirectories();
+  m_properties.resource_directory_count = GetResourceDirectoryCount();
+  m_properties.profile_directory = GetProfileDirectory();
+  m_properties.supports_vfs = m_parent.SupportsVFS();
+  m_properties.extensions = GetExtensions();
+  m_properties.extension_count = GetExtensionCount();
+
+  return true;
+}
+
+const char* CGameClientProperties::GetLibraryPath(void)
+{
+  if (m_strLibraryPath.empty())
+  {
+    // Get the parent add-on's real path
+    std::string strLibPath = m_parent.CAddonDll::LibPath();
+    m_strLibraryPath = CSpecialProtocol::TranslatePath(strLibPath);
+    URIUtils::RemoveSlashAtEnd(m_strLibraryPath);
+  }
+  return m_strLibraryPath.c_str();
+}
+
+const char** CGameClientProperties::GetProxyDllPaths(const ADDON::VECADDONS& addons)
+{
+  if (m_proxyDllPaths.empty())
+  {
+    for (const auto& addon : addons)
+      AddProxyDll(std::static_pointer_cast<CGameClient>(addon));
+  }
+
+  if (!m_proxyDllPaths.empty())
+    return const_cast<const char**>(m_proxyDllPaths.data());
+
+  return nullptr;
+}
+
+unsigned int CGameClientProperties::GetProxyDllCount(void) const
+{
+  return static_cast<unsigned int>(m_proxyDllPaths.size());
+}
+
+const char** CGameClientProperties::GetResourceDirectories(void)
+{
+  if (m_resourceDirectories.empty())
+  {
+    // Add all other game resources
+    const auto& dependencies = m_parent.GetDependencies();
+    for (auto it = dependencies.begin(); it != dependencies.end(); ++it)
+    {
+      const std::string& strAddonId = it->id;
+      AddonPtr addon;
+      if (CServiceBroker::GetAddonMgr().GetAddon(strAddonId, addon, AddonType::RESOURCE_GAMES,
+                                                 OnlyEnabled::CHOICE_YES))
+      {
+        std::shared_ptr<CGameResource> resource = std::static_pointer_cast<CGameResource>(addon);
+
+        std::string resourcePath = resource->GetFullPath("");
+        URIUtils::RemoveSlashAtEnd(resourcePath);
+
+        char* resourceDir = new char[resourcePath.length() + 1];
+        std::strcpy(resourceDir, resourcePath.c_str());
+        m_resourceDirectories.push_back(resourceDir);
+      }
+    }
+
+    // Add resource directories for profile and path
+    std::string addonProfile = CSpecialProtocol::TranslatePath(m_parent.Profile());
+    std::string addonPath = m_parent.Path();
+
+    addonProfile = URIUtils::AddFileToFolder(addonProfile, GAME_CLIENT_RESOURCES_DIRECTORY);
+    addonPath = URIUtils::AddFileToFolder(addonPath, GAME_CLIENT_RESOURCES_DIRECTORY);
+
+    if (!CDirectory::Exists(addonProfile))
+    {
+      CLog::Log(LOGDEBUG, "Creating resource directory: {}", addonProfile);
+      CDirectory::Create(addonProfile);
+    }
+
+    // Only add user profile directory if non-empty
+    CFileItemList items;
+    if (CDirectory::GetDirectory(addonProfile, items, "", DIR_FLAG_DEFAULTS))
+    {
+      if (!items.IsEmpty())
+      {
+        char* addonProfileDir = new char[addonProfile.length() + 1];
+        std::strcpy(addonProfileDir, addonProfile.c_str());
+        m_resourceDirectories.push_back(addonProfileDir);
+      }
+    }
+
+    char* addonPathDir = new char[addonPath.length() + 1];
+    std::strcpy(addonPathDir, addonPath.c_str());
+    m_resourceDirectories.push_back(addonPathDir);
+  }
+
+  if (!m_resourceDirectories.empty())
+    return const_cast<const char**>(m_resourceDirectories.data());
+
+  return nullptr;
+}
+
+unsigned int CGameClientProperties::GetResourceDirectoryCount(void) const
+{
+  return static_cast<unsigned int>(m_resourceDirectories.size());
+}
+
+const char* CGameClientProperties::GetProfileDirectory(void)
+{
+  if (m_strProfileDirectory.empty())
+  {
+    m_strProfileDirectory = CSpecialProtocol::TranslatePath(m_parent.Profile());
+    URIUtils::RemoveSlashAtEnd(m_strProfileDirectory);
+  }
+
+  return m_strProfileDirectory.c_str();
+}
+
+const char** CGameClientProperties::GetExtensions(void)
+{
+  for (auto& extension : m_parent.GetExtensions())
+  {
+    char* ext = new char[extension.length() + 1];
+    std::strcpy(ext, extension.c_str());
+    m_extensions.push_back(ext);
+  }
+
+  return !m_extensions.empty() ? const_cast<const char**>(m_extensions.data()) : nullptr;
+}
+
+unsigned int CGameClientProperties::GetExtensionCount(void) const
+{
+  return static_cast<unsigned int>(m_extensions.size());
+}
+
+bool CGameClientProperties::GetProxyAddons(ADDON::VECADDONS& addons)
+{
+  ADDON::VECADDONS ret;
+  std::vector<std::string> missingDependencies; // ID or name of missing dependencies
+
+  for (const auto& dependency : m_parent.GetDependencies())
+  {
+    AddonPtr addon;
+    if (CServiceBroker::GetAddonMgr().GetAddon(dependency.id, addon, OnlyEnabled::CHOICE_NO))
+    {
+      // If add-on is disabled, ask the user to enable it
+      if (CServiceBroker::GetAddonMgr().IsAddonDisabled(dependency.id))
+      {
+        // "Failed to play game"
+        // "This game depends on a disabled add-on. Would you like to enable it?"
+        if (CGUIDialogYesNo::ShowAndGetInput(CVariant{35210}, CVariant{35215}))
+        {
+          if (!CServiceBroker::GetAddonMgr().EnableAddon(dependency.id))
+          {
+            CLog::Log(LOGERROR, "Failed to enable add-on {}", dependency.id);
+            missingDependencies.emplace_back(addon->Name());
+            addon.reset();
+          }
+        }
+        else
+        {
+          CLog::Log(LOGERROR, "User chose to not enable add-on {}", dependency.id);
+          missingDependencies.emplace_back(addon->Name());
+          addon.reset();
+        }
+      }
+
+      if (addon && addon->Type() == AddonType::GAMEDLL)
+        ret.emplace_back(std::move(addon));
+    }
+    else
+    {
+      if (dependency.optional)
+      {
+        CLog::Log(LOGDEBUG, "Missing optional dependency {}", dependency.id);
+      }
+      else
+      {
+        CLog::Log(LOGERROR, "Missing mandatory dependency {}", dependency.id);
+        missingDependencies.emplace_back(dependency.id);
+      }
+    }
+  }
+
+  if (!missingDependencies.empty())
+  {
+    std::string strDependencies = StringUtils::Join(missingDependencies, ", ");
+    std::string dialogText = StringUtils::Format(g_localizeStrings.Get(35223), strDependencies);
+
+    // "Failed to play game"
+    // "Add-on is incompatible due to unmet dependencies."
+    // ""
+    // "Missing: {0:s}"
+    MESSAGING::HELPERS::ShowOKDialogLines(CVariant{35210}, CVariant{24104}, CVariant{""},
+                                          CVariant{dialogText});
+
+    return false;
+  }
+
+  addons = std::move(ret);
+  return true;
+}
+
+void CGameClientProperties::AddProxyDll(const GameClientPtr& gameClient)
+{
+  // Get the add-on's real path
+  std::string strLibPath = gameClient->CAddon::LibPath();
+
+  // Ignore add-on if it is already added
+  if (!HasProxyDll(strLibPath))
+  {
+    char* libPath = new char[strLibPath.length() + 1];
+    std::strcpy(libPath, strLibPath.c_str());
+    m_proxyDllPaths.push_back(libPath);
+  }
+}
+
+bool CGameClientProperties::HasProxyDll(const std::string& strLibPath) const
+{
+  for (const auto& it : m_proxyDllPaths)
+  {
+    if (strLibPath == it)
+      return true;
+  }
+  return false;
+}
diff --git a/xbmc/games/addons/GameClientProperties.h b/xbmc/games/addons/GameClientProperties.h
new file mode 100644
index 0000000..5cb1c6a
--- /dev/null
+++ b/xbmc/games/addons/GameClientProperties.h
@@ -0,0 +1,93 @@
+/*
+ *  Copyright (C) 2012-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/kodi-dev-kit/include/kodi/addon-instance/Game.h"
+#include "games/GameTypes.h"
+
+#include <string>
+#include <vector>
+
+struct AddonProps_Game;
+
+namespace ADDON
+{
+class IAddon;
+using AddonPtr = std::shared_ptr<IAddon>;
+using VECADDONS = std::vector<AddonPtr>;
+} // namespace ADDON
+
+namespace KODI
+{
+namespace GAME
+{
+
+class CGameClient;
+
+/**
+ * \ingroup games
+ * \brief C++ wrapper for properties to pass to the DLL
+ *
+ * Game client properties declared in addon-instance/Game.h.
+ */
+class CGameClientProperties
+{
+public:
+  CGameClientProperties(const CGameClient& parent, AddonProps_Game& props);
+  ~CGameClientProperties(void) { ReleaseResources(); }
+
+  bool InitializeProperties(void);
+
+private:
+  // Release mutable resources
+  void ReleaseResources(void);
+
+  // Equal to parent's real library path
+  const char* GetLibraryPath(void);
+
+  // List of proxy DLLs needed to load the game client
+  const char** GetProxyDllPaths(const ADDON::VECADDONS& addons);
+
+  // Number of proxy DLLs needed to load the game client
+  unsigned int GetProxyDllCount(void) const;
+
+  // Paths to game resources
+  const char** GetResourceDirectories(void);
+
+  // Number of resource directories
+  unsigned int GetResourceDirectoryCount(void) const;
+
+  // Equal to special://profile/addon_data/<parent's id>
+  const char* GetProfileDirectory(void);
+
+  // List of extensions from addon.xml
+  const char** GetExtensions(void);
+
+  // Number of extensions
+  unsigned int GetExtensionCount(void) const;
+
+  // Helper functions
+  bool GetProxyAddons(ADDON::VECADDONS& addons);
+  void AddProxyDll(const GameClientPtr& gameClient);
+  bool HasProxyDll(const std::string& strLibPath) const;
+
+  // Construction parameters
+  const CGameClient& m_parent;
+  AddonProps_Game& m_properties;
+
+  // Buffers to hold the strings
+  std::string m_strLibraryPath;
+  std::vector<char*> m_proxyDllPaths;
+  std::vector<char*> m_resourceDirectories;
+  std::string m_strProfileDirectory;
+  std::vector<char*> m_extensions;
+};
+
+} // namespace GAME
+} // namespace KODI
diff --git a/xbmc/games/addons/GameClientSubsystem.cpp b/xbmc/games/addons/GameClientSubsystem.cpp
new file mode 100644
index 0000000..599125f
--- /dev/null
+++ b/xbmc/games/addons/GameClientSubsystem.cpp
@@ -0,0 +1,70 @@
+/*
+ *  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 "GameClientSubsystem.h"
+
+#include "GameClient.h"
+#include "GameClientProperties.h"
+#include "addons/kodi-dev-kit/include/kodi/addon-instance/Game.h"
+#include "games/addons/cheevos/GameClientCheevos.h"
+#include "games/addons/input/GameClientInput.h"
+#include "games/addons/streams/GameClientStreams.h"
+
+using namespace KODI;
+using namespace GAME;
+
+CGameClientSubsystem::CGameClientSubsystem(CGameClient& gameClient,
+                                           AddonInstance_Game& addonStruct,
+                                           CCriticalSection& clientAccess)
+  : m_gameClient(gameClient), m_struct(addonStruct), m_clientAccess(clientAccess)
+{
+}
+
+CGameClientSubsystem::~CGameClientSubsystem() = default;
+
+GameClientSubsystems CGameClientSubsystem::CreateSubsystems(CGameClient& gameClient,
+                                                            AddonInstance_Game& gameStruct,
+                                                            CCriticalSection& clientAccess)
+{
+  GameClientSubsystems subsystems = {};
+
+  subsystems.Cheevos = std::make_unique<CGameClientCheevos>(gameClient, gameStruct);
+  subsystems.Input.reset(new CGameClientInput(gameClient, gameStruct, clientAccess));
+  subsystems.AddonProperties.reset(new CGameClientProperties(gameClient, *gameStruct.props));
+  subsystems.Streams.reset(new CGameClientStreams(gameClient));
+
+  return subsystems;
+}
+
+void CGameClientSubsystem::DestroySubsystems(GameClientSubsystems& subsystems)
+{
+  subsystems.Cheevos.reset();
+  subsystems.Input.reset();
+  subsystems.AddonProperties.reset();
+  subsystems.Streams.reset();
+}
+
+CGameClientCheevos& CGameClientSubsystem::Cheevos() const
+{
+  return m_gameClient.Cheevos();
+}
+
+CGameClientInput& CGameClientSubsystem::Input() const
+{
+  return m_gameClient.Input();
+}
+
+CGameClientProperties& CGameClientSubsystem::AddonProperties() const
+{
+  return m_gameClient.AddonProperties();
+}
+
+CGameClientStreams& CGameClientSubsystem::Streams() const
+{
+  return m_gameClient.Streams();
+}
diff --git a/xbmc/games/addons/GameClientSubsystem.h b/xbmc/games/addons/GameClientSubsystem.h
new file mode 100644
index 0000000..4711011
--- /dev/null
+++ b/xbmc/games/addons/GameClientSubsystem.h
@@ -0,0 +1,81 @@
+/*
+ *  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 <memory>
+
+struct AddonInstance_Game;
+class CCriticalSection;
+
+namespace KODI
+{
+namespace GAME
+{
+class CGameClient;
+class CGameClientCheevos;
+class CGameClientInput;
+class CGameClientProperties;
+class CGameClientStreams;
+
+struct GameClientSubsystems
+{
+  std::unique_ptr<CGameClientCheevos> Cheevos;
+  std::unique_ptr<CGameClientInput> Input;
+  std::unique_ptr<CGameClientProperties> AddonProperties;
+  std::unique_ptr<CGameClientStreams> Streams;
+};
+
+/*!
+ * \brief Base class for game client subsystems
+ */
+class CGameClientSubsystem
+{
+protected:
+  CGameClientSubsystem(CGameClient& gameClient,
+                       AddonInstance_Game& addonStruct,
+                       CCriticalSection& clientAccess);
+
+  virtual ~CGameClientSubsystem();
+
+public:
+  /*!
+   * \brief Create a struct with the allocated subsystems
+   *
+   * \param gameClient The owner of the subsystems
+   * \param gameStruct The game client's add-on function table
+   * \param clientAccess Mutex guarding client function access
+   *
+   * \return A fully-allocated GameClientSubsystems struct
+   */
+  static GameClientSubsystems CreateSubsystems(CGameClient& gameClient,
+                                               AddonInstance_Game& gameStruct,
+                                               CCriticalSection& clientAccess);
+
+  /*!
+   * \brief Deallocate subsystems
+   *
+   * \param subsystems The subsystems created by CreateSubsystems()
+   */
+  static void DestroySubsystems(GameClientSubsystems& subsystems);
+
+protected:
+  // Subsystems
+  CGameClientCheevos& Cheevos() const;
+  CGameClientInput& Input() const;
+  CGameClientProperties& AddonProperties() const;
+  CGameClientStreams& Streams() const;
+
+  // Construction parameters
+  CGameClient& m_gameClient;
+  AddonInstance_Game& m_struct;
+  CCriticalSection& m_clientAccess;
+};
+
+} // namespace GAME
+} // namespace KODI
diff --git a/xbmc/games/addons/GameClientTranslator.cpp b/xbmc/games/addons/GameClientTranslator.cpp
new file mode 100644
index 0000000..c48ba4a
--- /dev/null
+++ b/xbmc/games/addons/GameClientTranslator.cpp
@@ -0,0 +1,256 @@
+/*
+ *  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 "GameClientTranslator.h"
+
+using namespace KODI;
+using namespace GAME;
+
+const char* CGameClientTranslator::ToString(GAME_ERROR error)
+{
+  switch (error)
+  {
+    case GAME_ERROR_NO_ERROR:
+      return "no error";
+    case GAME_ERROR_NOT_IMPLEMENTED:
+      return "not implemented";
+    case GAME_ERROR_REJECTED:
+      return "rejected by the client";
+    case GAME_ERROR_INVALID_PARAMETERS:
+      return "invalid parameters for this method";
+    case GAME_ERROR_FAILED:
+      return "the command failed";
+    case GAME_ERROR_NOT_LOADED:
+      return "no game is loaded";
+    case GAME_ERROR_RESTRICTED:
+      return "the required resources are restricted";
+    default:
+      break;
+  }
+  return "unknown error";
+}
+
+const char* CGameClientTranslator::ToString(GAME_MEMORY memory)
+{
+  switch (memory)
+  {
+    case GAME_MEMORY_SAVE_RAM:
+      return "save ram";
+    case GAME_MEMORY_RTC:
+      return "rtc";
+    case GAME_MEMORY_SYSTEM_RAM:
+      return "system ram";
+    case GAME_MEMORY_VIDEO_RAM:
+      return "video ram";
+    case GAME_MEMORY_SNES_BSX_RAM:
+      return "snes bsx ram";
+    case GAME_MEMORY_SNES_SUFAMI_TURBO_A_RAM:
+      return "snes sufami turbo a ram";
+    case GAME_MEMORY_SNES_SUFAMI_TURBO_B_RAM:
+      return "snes sufami turbo b ram";
+    case GAME_MEMORY_SNES_GAME_BOY_RAM:
+      return "snes game boy ram";
+    case GAME_MEMORY_SNES_GAME_BOY_RTC:
+      return "snes game boy rtc";
+    default:
+      break;
+  }
+  return "unknown memory";
+}
+
+bool CGameClientTranslator::TranslateStreamType(GAME_STREAM_TYPE gameType,
+                                                RETRO::StreamType& retroType)
+{
+  switch (gameType)
+  {
+    case GAME_STREAM_AUDIO:
+      retroType = RETRO::StreamType::AUDIO;
+      return true;
+    case GAME_STREAM_VIDEO:
+      retroType = RETRO::StreamType::VIDEO;
+      return true;
+    case GAME_STREAM_SW_FRAMEBUFFER:
+      retroType = RETRO::StreamType::SW_BUFFER;
+      return true;
+    case GAME_STREAM_HW_FRAMEBUFFER:
+      retroType = RETRO::StreamType::HW_BUFFER;
+      return true;
+    default:
+      break;
+  }
+  return false;
+}
+
+AVPixelFormat CGameClientTranslator::TranslatePixelFormat(GAME_PIXEL_FORMAT format)
+{
+  switch (format)
+  {
+    case GAME_PIXEL_FORMAT_0RGB8888:
+      return AV_PIX_FMT_0RGB32;
+    case GAME_PIXEL_FORMAT_RGB565:
+      return AV_PIX_FMT_RGB565;
+    case GAME_PIXEL_FORMAT_0RGB1555:
+      return AV_PIX_FMT_RGB555;
+    default:
+      break;
+  }
+  return AV_PIX_FMT_NONE;
+}
+
+GAME_PIXEL_FORMAT CGameClientTranslator::TranslatePixelFormat(AVPixelFormat format)
+{
+  switch (format)
+  {
+    case AV_PIX_FMT_0RGB32:
+      return GAME_PIXEL_FORMAT_0RGB8888;
+    case AV_PIX_FMT_RGB565:
+      return GAME_PIXEL_FORMAT_RGB565;
+    case AV_PIX_FMT_RGB555:
+      return GAME_PIXEL_FORMAT_0RGB1555;
+    default:
+      break;
+  }
+  return GAME_PIXEL_FORMAT_UNKNOWN;
+}
+
+RETRO::PCMFormat CGameClientTranslator::TranslatePCMFormat(GAME_PCM_FORMAT format)
+{
+  switch (format)
+  {
+    case GAME_PCM_FORMAT_S16NE:
+      return RETRO::PCMFormat::FMT_S16NE;
+    default:
+      break;
+  }
+  return RETRO::PCMFormat::FMT_UNKNOWN;
+}
+
+RETRO::AudioChannel CGameClientTranslator::TranslateAudioChannel(GAME_AUDIO_CHANNEL channel)
+{
+  switch (channel)
+  {
+    case GAME_CH_FL:
+      return RETRO::AudioChannel::CH_FL;
+    case GAME_CH_FR:
+      return RETRO::AudioChannel::CH_FR;
+    case GAME_CH_FC:
+      return RETRO::AudioChannel::CH_FC;
+    case GAME_CH_LFE:
+      return RETRO::AudioChannel::CH_LFE;
+    case GAME_CH_BL:
+      return RETRO::AudioChannel::CH_BL;
+    case GAME_CH_BR:
+      return RETRO::AudioChannel::CH_BR;
+    case GAME_CH_FLOC:
+      return RETRO::AudioChannel::CH_FLOC;
+    case GAME_CH_FROC:
+      return RETRO::AudioChannel::CH_FROC;
+    case GAME_CH_BC:
+      return RETRO::AudioChannel::CH_BC;
+    case GAME_CH_SL:
+      return RETRO::AudioChannel::CH_SL;
+    case GAME_CH_SR:
+      return RETRO::AudioChannel::CH_SR;
+    case GAME_CH_TFL:
+      return RETRO::AudioChannel::CH_TFL;
+    case GAME_CH_TFR:
+      return RETRO::AudioChannel::CH_TFR;
+    case GAME_CH_TFC:
+      return RETRO::AudioChannel::CH_TFC;
+    case GAME_CH_TC:
+      return RETRO::AudioChannel::CH_TC;
+    case GAME_CH_TBL:
+      return RETRO::AudioChannel::CH_TBL;
+    case GAME_CH_TBR:
+      return RETRO::AudioChannel::CH_TBR;
+    case GAME_CH_TBC:
+      return RETRO::AudioChannel::CH_TBC;
+    case GAME_CH_BLOC:
+      return RETRO::AudioChannel::CH_BLOC;
+    case GAME_CH_BROC:
+      return RETRO::AudioChannel::CH_BROC;
+    default:
+      break;
+  }
+  return RETRO::AudioChannel::CH_NULL;
+}
+
+RETRO::VideoRotation CGameClientTranslator::TranslateRotation(GAME_VIDEO_ROTATION rotation)
+{
+  switch (rotation)
+  {
+    case GAME_VIDEO_ROTATION_90_CCW:
+      return RETRO::VideoRotation::ROTATION_90_CCW;
+    case GAME_VIDEO_ROTATION_180_CCW:
+      return RETRO::VideoRotation::ROTATION_180_CCW;
+    case GAME_VIDEO_ROTATION_270_CCW:
+      return RETRO::VideoRotation::ROTATION_270_CCW;
+    default:
+      break;
+  }
+  return RETRO::VideoRotation::ROTATION_0;
+}
+
+GAME_KEY_MOD CGameClientTranslator::GetModifiers(KEYBOARD::Modifier modifier)
+{
+  using namespace KEYBOARD;
+
+  unsigned int mods = GAME_KEY_MOD_NONE;
+
+  if (modifier & Modifier::MODIFIER_CTRL)
+    mods |= GAME_KEY_MOD_CTRL;
+  if (modifier & Modifier::MODIFIER_SHIFT)
+    mods |= GAME_KEY_MOD_SHIFT;
+  if (modifier & Modifier::MODIFIER_ALT)
+    mods |= GAME_KEY_MOD_ALT;
+  if (modifier & Modifier::MODIFIER_RALT)
+    mods |= GAME_KEY_MOD_ALT;
+  if (modifier & Modifier::MODIFIER_META)
+    mods |= GAME_KEY_MOD_META;
+  if (modifier & Modifier::MODIFIER_SUPER)
+    mods |= GAME_KEY_MOD_SUPER;
+  if (modifier & Modifier::MODIFIER_NUMLOCK)
+    mods |= GAME_KEY_MOD_NUMLOCK;
+  if (modifier & Modifier::MODIFIER_CAPSLOCK)
+    mods |= GAME_KEY_MOD_CAPSLOCK;
+  if (modifier & Modifier::MODIFIER_SCROLLLOCK)
+    mods |= GAME_KEY_MOD_SCROLLOCK;
+
+  return static_cast<GAME_KEY_MOD>(mods);
+}
+
+const char* CGameClientTranslator::TranslateRegion(GAME_REGION region)
+{
+  switch (region)
+  {
+    case GAME_REGION_NTSC:
+      return "NTSC";
+    case GAME_REGION_PAL:
+      return "PAL";
+    default:
+      break;
+  }
+  return "Unknown";
+}
+
+PORT_TYPE CGameClientTranslator::TranslatePortType(GAME_PORT_TYPE portType)
+{
+  switch (portType)
+  {
+    case GAME_PORT_KEYBOARD:
+      return PORT_TYPE::KEYBOARD;
+    case GAME_PORT_MOUSE:
+      return PORT_TYPE::MOUSE;
+    case GAME_PORT_CONTROLLER:
+      return PORT_TYPE::CONTROLLER;
+    default:
+      break;
+  }
+
+  return PORT_TYPE::UNKNOWN;
+}
diff --git a/xbmc/games/addons/GameClientTranslator.h b/xbmc/games/addons/GameClientTranslator.h
new file mode 100644
index 0000000..6b6b448
--- /dev/null
+++ b/xbmc/games/addons/GameClientTranslator.h
@@ -0,0 +1,115 @@
+/*
+ *  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 "addons/kodi-dev-kit/include/kodi/addon-instance/Game.h"
+#include "cores/RetroPlayer/streams/RetroPlayerStreamTypes.h"
+#include "games/controllers/ControllerTypes.h"
+#include "input/keyboard/KeyboardTypes.h"
+
+extern "C"
+{
+#include <libavutil/pixfmt.h>
+}
+
+namespace KODI
+{
+namespace GAME
+{
+/*!
+ * \ingroup games
+ * \brief Translates data types from Game API to the corresponding format in Kodi.
+ *
+ * This class is stateless.
+ */
+class CGameClientTranslator
+{
+  CGameClientTranslator() = delete;
+
+public:
+  /*!
+   * \brief Translates game errors to string representation (e.g. for logging).
+   * \param error The error to translate.
+   * \return Translated error.
+   */
+  static const char* ToString(GAME_ERROR error);
+
+  /*!
+   * \brief Translates game memory types to string representation (e.g. for logging).
+   * \param memory The memory type to translate.
+   * \return Translated memory type.
+   */
+  static const char* ToString(GAME_MEMORY error);
+
+  /*!
+   * \brief Translate stream type (Game API to RetroPlayer).
+   * \param gameType The stream type to translate.
+   * \param[out] retroType The translated stream type.
+   * \return True if the Game API type was translated to a valid RetroPlayer type
+   */
+  static bool TranslateStreamType(GAME_STREAM_TYPE gameType, RETRO::StreamType& retroType);
+
+  /*!
+   * \brief Translate pixel format (Game API to RetroPlayer/FFMPEG).
+   * \param format The pixel format to translate.
+   * \return Translated pixel format.
+   */
+  static AVPixelFormat TranslatePixelFormat(GAME_PIXEL_FORMAT format);
+
+  /*!
+   * \brief Translate pixel format (RetroPlayer/FFMPEG to Game API).
+   * \param format The pixel format to translate.
+   * \return Translated pixel format.
+   */
+  static GAME_PIXEL_FORMAT TranslatePixelFormat(AVPixelFormat format);
+
+  /*!
+   * \brief Translate audio PCM format (Game API to RetroPlayer).
+   * \param format The audio PCM format to translate.
+   * \return Translated audio PCM format.
+   */
+  static RETRO::PCMFormat TranslatePCMFormat(GAME_PCM_FORMAT format);
+
+  /*!
+   * \brief Translate audio channels (Game API to RetroPlayer).
+   * \param format The audio channels to translate.
+   * \return Translated audio channels.
+   */
+  static RETRO::AudioChannel TranslateAudioChannel(GAME_AUDIO_CHANNEL channel);
+
+  /*!
+   * \brief Translate video rotation (Game API to RetroPlayer).
+   * \param rotation The video rotation to translate.
+   * \return Translated video rotation.
+   */
+  static RETRO::VideoRotation TranslateRotation(GAME_VIDEO_ROTATION rotation);
+
+  /*!
+   * \brief Translate key modifiers (Kodi to Game API).
+   * \param modifiers The key modifiers to translate (e.g. Shift, Ctrl).
+   * \return Translated key modifiers.
+   */
+  static GAME_KEY_MOD GetModifiers(KEYBOARD::Modifier modifier);
+
+  /*!
+   * \brief Translate region to string representation (e.g. for logging).
+   * \param error The region to translate (e.g. PAL, NTSC).
+   * \return Translated region.
+   */
+  static const char* TranslateRegion(GAME_REGION region);
+
+  /*!
+   * \brief Translate port type (Game API to Kodi)
+   * \param portType  The port type to translate
+   * \return Translated port type
+   */
+  static PORT_TYPE TranslatePortType(GAME_PORT_TYPE portType);
+};
+} // namespace GAME
+} // namespace KODI
diff --git a/xbmc/games/addons/cheevos/CMakeLists.txt b/xbmc/games/addons/cheevos/CMakeLists.txt
new file mode 100644
index 0000000..826fc04
--- /dev/null
+++ b/xbmc/games/addons/cheevos/CMakeLists.txt
@@ -0,0 +1,5 @@
+set(SOURCES GameClientCheevos.cpp)
+
+set(HEADERS GameClientCheevos.h)
+
+core_add_library(gamecheevos)
diff --git a/xbmc/games/addons/cheevos/GameClientCheevos.cpp b/xbmc/games/addons/cheevos/GameClientCheevos.cpp
new file mode 100644
index 0000000..e9d457b
--- /dev/null
+++ b/xbmc/games/addons/cheevos/GameClientCheevos.cpp
@@ -0,0 +1,191 @@
+/*
+ *  Copyright (C) 2020-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 "GameClientCheevos.h"
+
+#include "addons/kodi-dev-kit/include/kodi/c-api/addon-instance/game.h"
+#include "cores/RetroPlayer/cheevos/RConsoleIDs.h"
+#include "games/addons/GameClient.h"
+
+using namespace KODI;
+using namespace GAME;
+
+CGameClientCheevos::CGameClientCheevos(CGameClient& gameClient, AddonInstance_Game& addonStruct)
+  : m_gameClient(gameClient), m_struct(addonStruct)
+{
+}
+
+bool CGameClientCheevos::RCGenerateHashFromFile(std::string& hash,
+                                                RETRO::RConsoleID consoleID,
+                                                const std::string& filePath)
+{
+  char* _hash = nullptr;
+  GAME_ERROR error = GAME_ERROR_NO_ERROR;
+
+  try
+  {
+    m_gameClient.LogError(
+        error = m_struct.toAddon->RCGenerateHashFromFile(
+            &m_struct, &_hash, static_cast<unsigned int>(consoleID), filePath.c_str()),
+        "RCGenerateHashFromFile()");
+  }
+  catch (...)
+  {
+    m_gameClient.LogException("RCGetGameIDUrl()");
+  }
+
+  if (_hash)
+  {
+    hash = _hash;
+    m_struct.toAddon->FreeString(&m_struct, _hash);
+  }
+
+  return error == GAME_ERROR_NO_ERROR;
+}
+
+bool CGameClientCheevos::RCGetGameIDUrl(std::string& url, const std::string& hash)
+{
+  char* _url = nullptr;
+  GAME_ERROR error = GAME_ERROR_NO_ERROR;
+
+  try
+  {
+    m_gameClient.LogError(error = m_struct.toAddon->RCGetGameIDUrl(&m_struct, &_url, hash.c_str()),
+                          "RCGetGameIDUrl()");
+  }
+  catch (...)
+  {
+    m_gameClient.LogException("RCGetGameIDUrl()");
+  }
+
+  if (_url)
+  {
+    url = _url;
+    m_struct.toAddon->FreeString(&m_struct, _url);
+  }
+
+  return error == GAME_ERROR_NO_ERROR;
+}
+
+bool CGameClientCheevos::RCGetPatchFileUrl(std::string& url,
+                                           const std::string& username,
+                                           const std::string& token,
+                                           unsigned int gameID)
+{
+  char* _url = nullptr;
+  GAME_ERROR error = GAME_ERROR_NO_ERROR;
+
+  try
+  {
+    m_gameClient.LogError(error = m_struct.toAddon->RCGetPatchFileUrl(
+                              &m_struct, &_url, username.c_str(), token.c_str(), gameID),
+                          "RCGetPatchFileUrl()");
+  }
+  catch (...)
+  {
+    m_gameClient.LogException("RCGetPatchFileUrl()");
+  }
+
+  if (_url)
+  {
+    url = _url;
+    m_struct.toAddon->FreeString(&m_struct, _url);
+  }
+
+  return error == GAME_ERROR_NO_ERROR;
+}
+
+bool CGameClientCheevos::RCPostRichPresenceUrl(std::string& url,
+                                               std::string& postData,
+                                               const std::string& username,
+                                               const std::string& token,
+                                               unsigned gameID,
+                                               const std::string& richPresence)
+{
+  char* _url = nullptr;
+  char* _postData = nullptr;
+  GAME_ERROR error = GAME_ERROR_NO_ERROR;
+
+  try
+  {
+    m_gameClient.LogError(error = m_struct.toAddon->RCPostRichPresenceUrl(
+                              &m_struct, &_url, &_postData, username.c_str(), token.c_str(), gameID,
+                              richPresence.c_str()),
+                          "RCPostRichPresenceUrl()");
+  }
+  catch (...)
+  {
+    m_gameClient.LogException("RCPostRichPresenceUrl()");
+  }
+
+  if (_url)
+  {
+    url = _url;
+    m_struct.toAddon->FreeString(&m_struct, _url);
+  }
+  if (_postData)
+  {
+    postData = _postData;
+    m_struct.toAddon->FreeString(&m_struct, _postData);
+  }
+
+  return error == GAME_ERROR_NO_ERROR;
+}
+
+void CGameClientCheevos::RCEnableRichPresence(const std::string& script)
+{
+  GAME_ERROR error = GAME_ERROR_NO_ERROR;
+
+  try
+  {
+    m_gameClient.LogError(error = m_struct.toAddon->RCEnableRichPresence(&m_struct, script.c_str()),
+                          "RCEnableRichPresence()");
+  }
+  catch (...)
+  {
+    m_gameClient.LogException("RCEnableRichPresence()");
+  }
+}
+
+void CGameClientCheevos::RCGetRichPresenceEvaluation(std::string& evaluation,
+                                                     RETRO::RConsoleID consoleID)
+{
+  char* _evaluation = nullptr;
+  GAME_ERROR error = GAME_ERROR_NO_ERROR;
+
+  try
+  {
+    m_gameClient.LogError(error = m_struct.toAddon->RCGetRichPresenceEvaluation(
+                              &m_struct, &_evaluation, static_cast<unsigned int>(consoleID)),
+                          "RCGetRichPresenceEvaluation()");
+
+    if (_evaluation)
+    {
+      evaluation = _evaluation;
+      m_struct.toAddon->FreeString(&m_struct, _evaluation);
+    }
+  }
+  catch (...)
+  {
+    m_gameClient.LogException("RCGetRichPresenceEvaluation()");
+  }
+}
+
+void CGameClientCheevos::RCResetRuntime()
+{
+  GAME_ERROR error = GAME_ERROR_NO_ERROR;
+
+  try
+  {
+    m_gameClient.LogError(error = m_struct.toAddon->RCResetRuntime(&m_struct), "RCResetRuntime()");
+  }
+  catch (...)
+  {
+    m_gameClient.LogException("RCResetRuntime()");
+  }
+}
diff --git a/xbmc/games/addons/cheevos/GameClientCheevos.h b/xbmc/games/addons/cheevos/GameClientCheevos.h
new file mode 100644
index 0000000..2be8c7a
--- /dev/null
+++ b/xbmc/games/addons/cheevos/GameClientCheevos.h
@@ -0,0 +1,57 @@
+/*
+ *  Copyright (C) 2020-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 <stddef.h> /* size_t */
+#include <string>
+
+struct AddonInstance_Game;
+
+namespace KODI
+{
+namespace RETRO
+{
+enum class RConsoleID;
+}
+
+namespace GAME
+{
+
+class CGameClient;
+
+class CGameClientCheevos
+{
+public:
+  CGameClientCheevos(CGameClient& gameClient, AddonInstance_Game& addonStruct);
+
+  bool RCGenerateHashFromFile(std::string& hash,
+                              RETRO::RConsoleID consoleID,
+                              const std::string& filePath);
+  bool RCGetGameIDUrl(std::string& url, const std::string& hash);
+  bool RCGetPatchFileUrl(std::string& url,
+                         const std::string& username,
+                         const std::string& token,
+                         unsigned int gameID);
+  bool RCPostRichPresenceUrl(std::string& url,
+                             std::string& postData,
+                             const std::string& username,
+                             const std::string& token,
+                             unsigned gameID,
+                             const std::string& richPresence);
+  void RCEnableRichPresence(const std::string& script);
+  void RCGetRichPresenceEvaluation(std::string& evaluation, RETRO::RConsoleID consoleID);
+  // When the game is reset, the runtime should also be reset
+  void RCResetRuntime();
+
+private:
+  CGameClient& m_gameClient;
+  AddonInstance_Game& m_struct;
+};
+} // namespace GAME
+} // namespace KODI
diff --git a/xbmc/games/addons/input/CMakeLists.txt b/xbmc/games/addons/input/CMakeLists.txt
new file mode 100644
index 0000000..69cc342
--- /dev/null
+++ b/xbmc/games/addons/input/CMakeLists.txt
@@ -0,0 +1,23 @@
+set(SOURCES GameClientController.cpp
+            GameClientDevice.cpp
+            GameClientHardware.cpp
+            GameClientInput.cpp
+            GameClientJoystick.cpp
+            GameClientKeyboard.cpp
+            GameClientMouse.cpp
+            GameClientPort.cpp
+            GameClientTopology.cpp
+)
+
+set(HEADERS GameClientController.h
+            GameClientDevice.h
+            GameClientHardware.h
+            GameClientInput.h
+            GameClientJoystick.h
+            GameClientKeyboard.h
+            GameClientMouse.h
+            GameClientPort.h
+            GameClientTopology.h
+)
+
+core_add_library(gameinput)
diff --git a/xbmc/games/addons/input/GameClientController.cpp b/xbmc/games/addons/input/GameClientController.cpp
new file mode 100644
index 0000000..435e277
--- /dev/null
+++ b/xbmc/games/addons/input/GameClientController.cpp
@@ -0,0 +1,138 @@
+/*
+ *      Copyright (C) 2018 Team Kodi
+ *      http://kodi.tv
+ *
+ *  This Program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2, or (at your option)
+ *  any later version.
+ *
+ *  This Program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this Program; see the file COPYING.  If not, see
+ *  <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "GameClientController.h"
+
+#include "GameClientInput.h"
+#include "games/controllers/Controller.h"
+#include "games/controllers/ControllerLayout.h"
+#include "games/controllers/input/PhysicalFeature.h"
+#include "games/controllers/input/PhysicalTopology.h"
+
+#include <algorithm>
+#include <vector>
+
+using namespace KODI;
+using namespace GAME;
+
+CGameClientController::CGameClientController(CGameClientInput& input, ControllerPtr controller)
+  : m_input(input), m_controller(std::move(controller)), m_controllerId(m_controller->ID())
+{
+  // Generate arrays of features
+  for (const CPhysicalFeature& feature : m_controller->Features())
+  {
+    // Skip feature if not supported by the game client
+    if (!m_input.HasFeature(m_controller->ID(), feature.Name()))
+      continue;
+
+    // Add feature to array of the appropriate type
+    switch (feature.Type())
+    {
+      case FEATURE_TYPE::SCALAR:
+      {
+        switch (feature.InputType())
+        {
+          case JOYSTICK::INPUT_TYPE::DIGITAL:
+            m_digitalButtons.emplace_back(const_cast<char*>(feature.Name().c_str()));
+            break;
+          case JOYSTICK::INPUT_TYPE::ANALOG:
+            m_analogButtons.emplace_back(const_cast<char*>(feature.Name().c_str()));
+            break;
+          default:
+            break;
+        }
+        break;
+      }
+      case FEATURE_TYPE::ANALOG_STICK:
+        m_analogSticks.emplace_back(const_cast<char*>(feature.Name().c_str()));
+        break;
+      case FEATURE_TYPE::ACCELEROMETER:
+        m_accelerometers.emplace_back(const_cast<char*>(feature.Name().c_str()));
+        break;
+      case FEATURE_TYPE::KEY:
+        m_keys.emplace_back(const_cast<char*>(feature.Name().c_str()));
+        break;
+      case FEATURE_TYPE::RELPOINTER:
+        m_relPointers.emplace_back(const_cast<char*>(feature.Name().c_str()));
+        break;
+      case FEATURE_TYPE::ABSPOINTER:
+        m_absPointers.emplace_back(const_cast<char*>(feature.Name().c_str()));
+        break;
+      case FEATURE_TYPE::MOTOR:
+        m_motors.emplace_back(const_cast<char*>(feature.Name().c_str()));
+        break;
+      default:
+        break;
+    }
+  }
+
+  //! @todo Sort vectors
+}
+
+game_controller_layout CGameClientController::TranslateController() const
+{
+  game_controller_layout controllerStruct{};
+
+  controllerStruct.controller_id = const_cast<char*>(m_controllerId.c_str());
+  controllerStruct.provides_input = m_controller->Layout().Topology().ProvidesInput();
+
+  if (!m_digitalButtons.empty())
+  {
+    controllerStruct.digital_buttons = const_cast<char**>(m_digitalButtons.data());
+    controllerStruct.digital_button_count = static_cast<unsigned int>(m_digitalButtons.size());
+  }
+  if (!m_analogButtons.empty())
+  {
+    controllerStruct.analog_buttons = const_cast<char**>(m_analogButtons.data());
+    controllerStruct.analog_button_count = static_cast<unsigned int>(m_analogButtons.size());
+  }
+  if (!m_analogSticks.empty())
+  {
+    controllerStruct.analog_sticks = const_cast<char**>(m_analogSticks.data());
+    controllerStruct.analog_stick_count = static_cast<unsigned int>(m_analogSticks.size());
+  }
+  if (!m_accelerometers.empty())
+  {
+    controllerStruct.accelerometers = const_cast<char**>(m_accelerometers.data());
+    controllerStruct.accelerometer_count = static_cast<unsigned int>(m_accelerometers.size());
+  }
+  if (!m_keys.empty())
+  {
+    controllerStruct.keys = const_cast<char**>(m_keys.data());
+    controllerStruct.key_count = static_cast<unsigned int>(m_keys.size());
+  }
+  if (!m_relPointers.empty())
+  {
+    controllerStruct.rel_pointers = const_cast<char**>(m_relPointers.data());
+    controllerStruct.rel_pointer_count = static_cast<unsigned int>(m_relPointers.size());
+  }
+  if (!m_absPointers.empty())
+  {
+    controllerStruct.abs_pointers = const_cast<char**>(m_absPointers.data());
+    controllerStruct.abs_pointer_count = static_cast<unsigned int>(m_absPointers.size());
+  }
+  if (!m_motors.empty())
+  {
+    controllerStruct.motors = const_cast<char**>(m_motors.data());
+    controllerStruct.motor_count = static_cast<unsigned int>(m_motors.size());
+  }
+
+  return controllerStruct;
+}
diff --git a/xbmc/games/addons/input/GameClientController.h b/xbmc/games/addons/input/GameClientController.h
new file mode 100644
index 0000000..5445868
--- /dev/null
+++ b/xbmc/games/addons/input/GameClientController.h
@@ -0,0 +1,71 @@
+/*
+ *      Copyright (C) 2018 Team Kodi
+ *      http://kodi.tv
+ *
+ *  This Program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2, or (at your option)
+ *  any later version.
+ *
+ *  This Program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this Program; see the file COPYING.  If not, see
+ *  <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#pragma once
+
+#include "addons/kodi-dev-kit/include/kodi/addon-instance/Game.h"
+#include "games/controllers/ControllerTypes.h"
+
+#include <string>
+#include <vector>
+
+namespace KODI
+{
+namespace GAME
+{
+class CGameClientInput;
+
+/*!
+ * \brief A container for the layout of a controller connected to a game
+ *        client input port
+ */
+class CGameClientController
+{
+public:
+  /*!
+   * \brief Construct a controller layout
+   *
+   * \brief controller The controller add-on
+   */
+  CGameClientController(CGameClientInput& input, ControllerPtr controller);
+
+  /*!
+   * \brief Get a controller layout for the Game API
+   */
+  game_controller_layout TranslateController() const;
+
+private:
+  // Construction parameters
+  CGameClientInput& m_input;
+  const ControllerPtr m_controller;
+
+  // Buffer parameters
+  std::string m_controllerId;
+  std::vector<char*> m_digitalButtons;
+  std::vector<char*> m_analogButtons;
+  std::vector<char*> m_analogSticks;
+  std::vector<char*> m_accelerometers;
+  std::vector<char*> m_keys;
+  std::vector<char*> m_relPointers;
+  std::vector<char*> m_absPointers;
+  std::vector<char*> m_motors;
+};
+} // namespace GAME
+} // namespace KODI
diff --git a/xbmc/games/addons/input/GameClientDevice.cpp b/xbmc/games/addons/input/GameClientDevice.cpp
new file mode 100644
index 0000000..589fb66
--- /dev/null
+++ b/xbmc/games/addons/input/GameClientDevice.cpp
@@ -0,0 +1,73 @@
+/*
+ *  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 "GameClientDevice.h"
+
+#include "GameClientPort.h"
+#include "ServiceBroker.h"
+#include "addons/kodi-dev-kit/include/kodi/addon-instance/Game.h"
+#include "games/GameServices.h"
+#include "games/controllers/Controller.h"
+#include "games/controllers/input/PhysicalTopology.h"
+#include "utils/StringUtils.h"
+#include "utils/log.h"
+
+#include <algorithm>
+
+using namespace KODI;
+using namespace GAME;
+
+CGameClientDevice::CGameClientDevice(const game_input_device& device)
+  : m_controller(GetController(device.controller_id))
+{
+  if (m_controller && device.available_ports != nullptr)
+  {
+    // Look for matching ports. We enumerate in physical order because logical
+    // order can change per emulator.
+    for (const auto& physicalPort : m_controller->Topology().Ports())
+    {
+      for (unsigned int i = 0; i < device.port_count; i++)
+      {
+        const auto& logicalPort = device.available_ports[i];
+        if (logicalPort.port_id != nullptr && logicalPort.port_id == physicalPort.ID())
+        {
+          // Handle matching ports
+          AddPort(logicalPort, physicalPort);
+          break;
+        }
+      }
+    }
+  }
+}
+
+CGameClientDevice::CGameClientDevice(const ControllerPtr& controller) : m_controller(controller)
+{
+}
+
+CGameClientDevice::~CGameClientDevice() = default;
+
+void CGameClientDevice::AddPort(const game_input_port& logicalPort,
+                                const CPhysicalPort& physicalPort)
+{
+  std::unique_ptr<CGameClientPort> port(new CGameClientPort(logicalPort, physicalPort));
+  m_ports.emplace_back(std::move(port));
+}
+
+ControllerPtr CGameClientDevice::GetController(const char* controllerId)
+{
+  ControllerPtr controller;
+
+  if (controllerId != nullptr)
+  {
+    controller = CServiceBroker::GetGameServices().GetController(controllerId);
+    if (!controller)
+      CLog::Log(LOGERROR, "Invalid controller ID: {}", controllerId);
+  }
+
+  return controller;
+}
diff --git a/xbmc/games/addons/input/GameClientDevice.h b/xbmc/games/addons/input/GameClientDevice.h
new file mode 100644
index 0000000..403d76c
--- /dev/null
+++ b/xbmc/games/addons/input/GameClientDevice.h
@@ -0,0 +1,77 @@
+/*
+ *  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/GameTypes.h"
+#include "games/controllers/ControllerTypes.h"
+
+#include <string>
+
+struct game_input_device;
+struct game_input_port;
+
+namespace KODI
+{
+namespace GAME
+{
+class CPhysicalPort;
+
+/*!
+ * \ingroup games
+ * \brief Represents a device connected to a port
+ */
+class CGameClientDevice
+{
+public:
+  /*!
+   * \brief Construct a device
+   *
+   * \param device The device Game API struct
+   */
+  CGameClientDevice(const game_input_device& device);
+
+  /*!
+   * \brief Construct a device from a controller add-on
+   *
+   * \param controller The controller add-on
+   */
+  CGameClientDevice(const ControllerPtr& controller);
+
+  /*!
+   * \brief Destructor
+   */
+  ~CGameClientDevice();
+
+  /*!
+   * \brief The controller profile
+   */
+  const ControllerPtr& Controller() const { return m_controller; }
+
+  /*!
+   * \brief The ports on this device
+   */
+  const GameClientPortVec& Ports() const { return m_ports; }
+
+private:
+  /*!
+   * \brief Add a controller port
+   *
+   * \param logicalPort The logical port Game API struct
+   * \param physicalPort The physical port definition
+   */
+  void AddPort(const game_input_port& logicalPort, const CPhysicalPort& physicalPort);
+
+  // Helper function
+  static ControllerPtr GetController(const char* controllerId);
+
+  ControllerPtr m_controller;
+  GameClientPortVec m_ports;
+};
+} // namespace GAME
+} // namespace KODI
diff --git a/xbmc/games/addons/input/GameClientHardware.cpp b/xbmc/games/addons/input/GameClientHardware.cpp
new file mode 100644
index 0000000..bacff90
--- /dev/null
+++ b/xbmc/games/addons/input/GameClientHardware.cpp
@@ -0,0 +1,25 @@
+/*
+ *  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 "GameClientHardware.h"
+
+#include "games/addons/GameClient.h"
+#include "utils/log.h"
+
+using namespace KODI;
+using namespace GAME;
+
+CGameClientHardware::CGameClientHardware(CGameClient& gameClient) : m_gameClient(gameClient)
+{
+}
+
+void CGameClientHardware::OnResetButton()
+{
+  CLog::Log(LOGDEBUG, "{}: Sending hardware reset", m_gameClient.ID());
+  m_gameClient.Reset();
+}
diff --git a/xbmc/games/addons/input/GameClientHardware.h b/xbmc/games/addons/input/GameClientHardware.h
new file mode 100644
index 0000000..1ffc96b
--- /dev/null
+++ b/xbmc/games/addons/input/GameClientHardware.h
@@ -0,0 +1,43 @@
+/*
+ *  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/hardware/IHardwareInput.h"
+
+namespace KODI
+{
+namespace GAME
+{
+class CGameClient;
+
+/*!
+ * \ingroup games
+ * \brief Handles events for hardware such as reset buttons
+ */
+class CGameClientHardware : public HARDWARE::IHardwareInput
+{
+public:
+  /*!
+   * \brief Constructor
+   *
+   * \param gameClient The game client implementation
+   */
+  explicit CGameClientHardware(CGameClient& gameClient);
+
+  ~CGameClientHardware() override = default;
+
+  // Implementation of IHardwareInput
+  void OnResetButton() override;
+
+private:
+  // Construction parameter
+  CGameClient& m_gameClient;
+};
+} // namespace GAME
+} // namespace KODI
diff --git a/xbmc/games/addons/input/GameClientInput.cpp b/xbmc/games/addons/input/GameClientInput.cpp
new file mode 100644
index 0000000..5805cbf
--- /dev/null
+++ b/xbmc/games/addons/input/GameClientInput.cpp
@@ -0,0 +1,697 @@
+/*
+ *  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 "GameClientInput.h"
+
+#include "GameClientController.h"
+#include "GameClientHardware.h"
+#include "GameClientJoystick.h"
+#include "GameClientKeyboard.h"
+#include "GameClientMouse.h"
+#include "GameClientPort.h"
+#include "GameClientTopology.h"
+#include "ServiceBroker.h"
+#include "addons/addoninfo/AddonInfo.h"
+#include "addons/kodi-dev-kit/include/kodi/addon-instance/Game.h"
+#include "games/GameServices.h"
+#include "games/addons/GameClient.h"
+#include "games/addons/GameClientCallbacks.h"
+#include "games/controllers/Controller.h"
+#include "games/controllers/ControllerLayout.h"
+#include "games/controllers/input/PhysicalTopology.h"
+#include "games/controllers/types/ControllerHub.h"
+#include "games/controllers/types/ControllerNode.h"
+#include "games/controllers/types/ControllerTree.h"
+#include "games/ports/input/PortManager.h"
+#include "games/ports/types/PortNode.h"
+#include "input/joysticks/JoystickTypes.h"
+#include "peripherals/EventLockHandle.h"
+#include "peripherals/Peripherals.h"
+#include "utils/log.h"
+
+#include <algorithm>
+#include <mutex>
+
+using namespace KODI;
+using namespace GAME;
+
+CGameClientInput::CGameClientInput(CGameClient& gameClient,
+                                   AddonInstance_Game& addonStruct,
+                                   CCriticalSection& clientAccess)
+  : CGameClientSubsystem(gameClient, addonStruct, clientAccess),
+    m_topology(new CGameClientTopology),
+    m_portManager(std::make_unique<CPortManager>())
+{
+}
+
+CGameClientInput::~CGameClientInput()
+{
+  Deinitialize();
+}
+
+void CGameClientInput::Initialize()
+{
+  LoadTopology();
+
+  // Send controller layouts to game client
+  SetControllerLayouts(m_topology->GetControllerTree().GetControllers());
+
+  // Reset ports to default state (first accepted controller is connected)
+  ActivateControllers(m_topology->GetControllerTree());
+
+  // Initialize the port manager
+  m_portManager->Initialize(m_gameClient.Profile());
+  m_portManager->SetControllerTree(m_topology->GetControllerTree());
+  m_portManager->LoadXML();
+}
+
+void CGameClientInput::Start(IGameInputCallback* input)
+{
+  m_inputCallback = input;
+
+  // Connect/disconnect active controllers
+  for (const CPortNode& port : GetActiveControllerTree().GetPorts())
+  {
+    if (port.IsConnected())
+    {
+      const ControllerPtr& activeController = port.GetActiveController().GetController();
+      if (activeController)
+        ConnectController(port.GetAddress(), activeController);
+    }
+    else
+      DisconnectController(port.GetAddress());
+  }
+
+  // Ensure hardware is open to receive events
+  m_hardware.reset(new CGameClientHardware(m_gameClient));
+
+  // Notify observers of the initial port configuration
+  NotifyObservers(ObservableMessageGamePortsChanged);
+}
+
+void CGameClientInput::Deinitialize()
+{
+  Stop();
+
+  m_topology->Clear();
+  m_controllerLayouts.clear();
+  m_portManager->Clear();
+}
+
+void CGameClientInput::Stop()
+{
+  m_hardware.reset();
+
+  CloseMouse();
+
+  CloseKeyboard();
+
+  PERIPHERALS::EventLockHandlePtr inputHandlingLock;
+  CloseJoysticks(inputHandlingLock);
+
+  // If a port was closed, then this blocks until all peripheral input has
+  // been handled
+  inputHandlingLock.reset();
+
+  m_inputCallback = nullptr;
+}
+
+bool CGameClientInput::HasFeature(const std::string& controllerId,
+                                  const std::string& featureName) const
+{
+  bool bHasFeature = false;
+
+  try
+  {
+    bHasFeature =
+        m_struct.toAddon->HasFeature(&m_struct, controllerId.c_str(), featureName.c_str());
+  }
+  catch (...)
+  {
+    CLog::Log(LOGERROR, "GAME: {}: exception caught in HasFeature()", m_gameClient.ID());
+
+    // Fail gracefully
+    bHasFeature = true;
+  }
+
+  return bHasFeature;
+}
+
+bool CGameClientInput::AcceptsInput() const
+{
+  if (m_inputCallback != nullptr)
+    return m_inputCallback->AcceptsInput();
+
+  return false;
+}
+
+bool CGameClientInput::InputEvent(const game_input_event& event)
+{
+  bool bHandled = false;
+
+  try
+  {
+    bHandled = m_struct.toAddon->InputEvent(&m_struct, &event);
+  }
+  catch (...)
+  {
+    CLog::Log(LOGERROR, "GAME: {}: exception caught in InputEvent()", m_gameClient.ID());
+  }
+
+  return bHandled;
+}
+
+void CGameClientInput::LoadTopology()
+{
+  game_input_topology* topologyStruct = nullptr;
+
+  if (m_gameClient.Initialized())
+  {
+    try
+    {
+      topologyStruct = m_struct.toAddon->GetTopology(&m_struct);
+    }
+    catch (...)
+    {
+      m_gameClient.LogException("GetTopology()");
+    }
+  }
+
+  GameClientPortVec hardwarePorts;
+  int playerLimit = -1;
+
+  if (topologyStruct != nullptr)
+  {
+    //! @todo Guard against infinite loops provided by the game client
+
+    game_input_port* ports = topologyStruct->ports;
+    if (ports != nullptr)
+    {
+      for (unsigned int i = 0; i < topologyStruct->port_count; i++)
+        hardwarePorts.emplace_back(new CGameClientPort(ports[i]));
+    }
+
+    playerLimit = topologyStruct->player_limit;
+
+    try
+    {
+      m_struct.toAddon->FreeTopology(&m_struct, topologyStruct);
+    }
+    catch (...)
+    {
+      m_gameClient.LogException("FreeTopology()");
+    }
+  }
+
+  // If no topology is available, create a default one with a single port that
+  // accepts all controllers imported by addon.xml
+  if (hardwarePorts.empty())
+    hardwarePorts.emplace_back(new CGameClientPort(GetControllers(m_gameClient)));
+
+  m_topology.reset(new CGameClientTopology(std::move(hardwarePorts), playerLimit));
+}
+
+void CGameClientInput::ActivateControllers(CControllerHub& hub)
+{
+  for (auto& port : hub.GetPorts())
+  {
+    if (port.GetCompatibleControllers().empty())
+      continue;
+
+    port.SetConnected(true);
+    port.SetActiveController(0);
+    for (auto& controller : port.GetCompatibleControllers())
+      ActivateControllers(controller.GetHub());
+  }
+}
+
+void CGameClientInput::SetControllerLayouts(const ControllerVector& controllers)
+{
+  if (controllers.empty())
+    return;
+
+  for (const auto& controller : controllers)
+  {
+    const std::string controllerId = controller->ID();
+    if (m_controllerLayouts.find(controllerId) == m_controllerLayouts.end())
+      m_controllerLayouts[controllerId].reset(new CGameClientController(*this, controller));
+  }
+
+  std::vector<game_controller_layout> controllerStructs;
+  for (const auto& it : m_controllerLayouts)
+    controllerStructs.emplace_back(it.second->TranslateController());
+
+  try
+  {
+    m_struct.toAddon->SetControllerLayouts(&m_struct, controllerStructs.data(),
+                                           static_cast<unsigned int>(controllerStructs.size()));
+  }
+  catch (...)
+  {
+    m_gameClient.LogException("SetControllerLayouts()");
+  }
+}
+
+const CControllerTree& CGameClientInput::GetDefaultControllerTree() const
+{
+  return m_topology->GetControllerTree();
+}
+
+const CControllerTree& CGameClientInput::GetActiveControllerTree() const
+{
+  return m_portManager->GetControllerTree();
+}
+
+bool CGameClientInput::SupportsKeyboard() const
+{
+  const CControllerTree& controllers = GetDefaultControllerTree();
+
+  auto it =
+      std::find_if(controllers.GetPorts().begin(), controllers.GetPorts().end(),
+                   [](const CPortNode& port) { return port.GetPortType() == PORT_TYPE::KEYBOARD; });
+
+  return it != controllers.GetPorts().end() && !it->GetCompatibleControllers().empty();
+}
+
+bool CGameClientInput::SupportsMouse() const
+{
+  const CControllerTree& controllers = GetDefaultControllerTree();
+
+  auto it =
+      std::find_if(controllers.GetPorts().begin(), controllers.GetPorts().end(),
+                   [](const CPortNode& port) { return port.GetPortType() == PORT_TYPE::MOUSE; });
+
+  return it != controllers.GetPorts().end() && !it->GetCompatibleControllers().empty();
+}
+
+int CGameClientInput::GetPlayerLimit() const
+{
+  return m_topology->GetPlayerLimit();
+}
+
+bool CGameClientInput::ConnectController(const std::string& portAddress,
+                                         const ControllerPtr& controller)
+{
+  // Validate parameters
+  if (portAddress.empty() || !controller)
+    return false;
+
+  const CControllerTree& controllerTree = GetDefaultControllerTree();
+
+  // Validate controller
+  const CPortNode& port = controllerTree.GetPort(portAddress);
+  if (!port.IsControllerAccepted(portAddress, controller->ID()))
+  {
+    CLog::Log(LOGERROR, "Failed to open port: Invalid controller \"{}\" on port \"{}\"",
+              controller->ID(), portAddress);
+    return false;
+  }
+
+  const CPortNode& currentPort = GetActiveControllerTree().GetPort(portAddress);
+
+  // Close current ports if any are open
+  PERIPHERALS::EventLockHandlePtr inputHandlingLock;
+  CloseJoysticks(currentPort, inputHandlingLock);
+  inputHandlingLock.reset();
+
+  {
+    std::unique_lock<CCriticalSection> lock(m_clientAccess);
+
+    if (!m_gameClient.Initialized())
+      return false;
+
+    try
+    {
+      if (!m_struct.toAddon->ConnectController(&m_struct, true, portAddress.c_str(),
+                                               controller->ID().c_str()))
+      {
+        return false;
+      }
+    }
+    catch (...)
+    {
+      m_gameClient.LogException("ConnectController()");
+      return false;
+    }
+  }
+
+  // Update port state
+  m_portManager->ConnectController(portAddress, true, controller->ID());
+  SetChanged();
+
+  // Update agent input
+  if (controller->Layout().Topology().ProvidesInput())
+    OpenJoystick(portAddress, controller);
+
+  bool bSuccess = true;
+
+  // If port is a multitap, we need to activate its children
+  const CPortNode& updatedPort = GetActiveControllerTree().GetPort(portAddress);
+  const PortVec& childPorts = updatedPort.GetActiveController().GetHub().GetPorts();
+  for (const CPortNode& childPort : childPorts)
+  {
+    const ControllerPtr& childController = childPort.GetActiveController().GetController();
+    if (childController)
+      bSuccess &= ConnectController(childPort.GetAddress(), childController);
+  }
+
+  return bSuccess;
+}
+
+bool CGameClientInput::DisconnectController(const std::string& portAddress)
+{
+  PERIPHERALS::EventLockHandlePtr inputHandlingLock;
+
+  // If port is a multitap, we need to deactivate its children
+  const CPortNode& currentPort = GetActiveControllerTree().GetPort(portAddress);
+  CloseJoysticks(currentPort, inputHandlingLock);
+
+  // If a port was closed, then destroying the lock will block until all
+  // peripheral input handling is complete to avoid invalidating the port's
+  // input handler
+  inputHandlingLock.reset();
+
+  {
+    std::unique_lock<CCriticalSection> lock(m_clientAccess);
+
+    if (!m_gameClient.Initialized())
+      return false;
+
+    try
+    {
+      if (!m_struct.toAddon->ConnectController(&m_struct, false, portAddress.c_str(), ""))
+        return false;
+    }
+    catch (...)
+    {
+      m_gameClient.LogException("ConnectController()");
+      return false;
+    }
+  }
+
+  // Update port state
+  m_portManager->ConnectController(portAddress, false);
+  SetChanged();
+
+  // Update agent input
+  CloseJoystick(portAddress, inputHandlingLock);
+  inputHandlingLock.reset();
+
+  return true;
+}
+
+void CGameClientInput::SavePorts()
+{
+  // Save port state
+  m_portManager->SaveXMLAsync();
+
+  // Let the observers know that ports have changed
+  NotifyObservers(ObservableMessageGamePortsChanged);
+}
+
+void CGameClientInput::ResetPorts()
+{
+  const CControllerTree& controllerTree = GetDefaultControllerTree();
+  for (const CPortNode& port : controllerTree.GetPorts())
+    ConnectController(port.GetAddress(), port.GetActiveController().GetController());
+}
+
+bool CGameClientInput::HasAgent() const
+{
+  if (!m_joysticks.empty())
+    return true;
+
+  if (m_keyboard)
+    return true;
+
+  if (m_mouse)
+    return true;
+
+  return false;
+}
+
+bool CGameClientInput::OpenKeyboard(const ControllerPtr& controller,
+                                    const PERIPHERALS::PeripheralPtr& keyboard)
+{
+  using namespace JOYSTICK;
+
+  if (!controller)
+  {
+    CLog::Log(LOGERROR, "Failed to open keyboard, no controller given");
+    return false;
+  }
+
+  if (!keyboard)
+    return false;
+
+  bool bSuccess = false;
+
+  {
+    std::unique_lock<CCriticalSection> lock(m_clientAccess);
+
+    if (m_gameClient.Initialized())
+    {
+      try
+      {
+        bSuccess = m_struct.toAddon->EnableKeyboard(&m_struct, true, controller->ID().c_str());
+      }
+      catch (...)
+      {
+        m_gameClient.LogException("EnableKeyboard()");
+      }
+    }
+  }
+
+  if (bSuccess)
+  {
+    m_keyboard =
+        std::make_unique<CGameClientKeyboard>(m_gameClient, controller->ID(), keyboard.get());
+    m_keyboard->SetSource(keyboard);
+    return true;
+  }
+
+  return false;
+}
+
+bool CGameClientInput::IsKeyboardOpen() const
+{
+  return static_cast<bool>(m_keyboard);
+}
+
+void CGameClientInput::CloseKeyboard()
+{
+  if (m_keyboard)
+  {
+    m_keyboard.reset();
+
+    std::unique_lock<CCriticalSection> lock(m_clientAccess);
+
+    if (m_gameClient.Initialized())
+    {
+      try
+      {
+        m_struct.toAddon->EnableKeyboard(&m_struct, false, "");
+      }
+      catch (...)
+      {
+        m_gameClient.LogException("EnableKeyboard()");
+      }
+    }
+  }
+}
+
+bool CGameClientInput::OpenMouse(const ControllerPtr& controller,
+                                 const PERIPHERALS::PeripheralPtr& mouse)
+{
+  using namespace JOYSTICK;
+
+  if (!controller)
+  {
+    CLog::Log(LOGERROR, "Failed to open mouse, no controller given");
+    return false;
+  }
+
+  if (!mouse)
+    return false;
+
+  bool bSuccess = false;
+
+  {
+    std::unique_lock<CCriticalSection> lock(m_clientAccess);
+
+    if (m_gameClient.Initialized())
+    {
+      try
+      {
+        bSuccess = m_struct.toAddon->EnableMouse(&m_struct, true, controller->ID().c_str());
+      }
+      catch (...)
+      {
+        m_gameClient.LogException("EnableMouse()");
+      }
+    }
+  }
+
+  if (bSuccess)
+  {
+    m_mouse = std::make_unique<CGameClientMouse>(m_gameClient, controller->ID(), mouse.get());
+    m_mouse->SetSource(mouse);
+    return true;
+  }
+
+  return false;
+}
+
+bool CGameClientInput::IsMouseOpen() const
+{
+  return static_cast<bool>(m_mouse);
+}
+
+void CGameClientInput::CloseMouse()
+{
+  if (m_mouse)
+  {
+    m_mouse.reset();
+
+    std::unique_lock<CCriticalSection> lock(m_clientAccess);
+
+    if (m_gameClient.Initialized())
+    {
+      try
+      {
+        m_struct.toAddon->EnableMouse(&m_struct, false, "");
+      }
+      catch (...)
+      {
+        m_gameClient.LogException("EnableMouse()");
+      }
+    }
+  }
+}
+
+bool CGameClientInput::OpenJoystick(const std::string& portAddress, const ControllerPtr& controller)
+{
+  using namespace JOYSTICK;
+
+  if (!controller)
+  {
+    CLog::Log(LOGERROR, "Failed to open port \"{}\", no controller given", portAddress);
+    return false;
+  }
+
+  if (m_joysticks.find(portAddress) != m_joysticks.end())
+  {
+    CLog::Log(LOGERROR, "Failed to open port \"{}\", already open", portAddress);
+    return false;
+  }
+
+  m_joysticks[portAddress].reset(new CGameClientJoystick(m_gameClient, portAddress, controller));
+
+  return true;
+}
+
+void CGameClientInput::CloseJoysticks(PERIPHERALS::EventLockHandlePtr& inputHandlingLock)
+{
+  std::vector<std::string> portAddresses;
+  for (const auto& it : m_joysticks)
+    portAddresses.emplace_back(it.first);
+
+  for (const std::string& portAddress : portAddresses)
+    CloseJoystick(portAddress, inputHandlingLock);
+}
+
+void CGameClientInput::CloseJoysticks(const CPortNode& port,
+                                      PERIPHERALS::EventLockHandlePtr& inputHandlingLock)
+{
+  const PortVec& childPorts = port.GetActiveController().GetHub().GetPorts();
+  for (const CPortNode& childPort : childPorts)
+    CloseJoysticks(childPort, inputHandlingLock);
+
+  CloseJoystick(port.GetAddress(), inputHandlingLock);
+}
+
+void CGameClientInput::CloseJoystick(const std::string& portAddress,
+                                     PERIPHERALS::EventLockHandlePtr& inputHandlingLock)
+{
+  auto it = m_joysticks.find(portAddress);
+  if (it != m_joysticks.end())
+  {
+    if (!inputHandlingLock)
+    {
+      // An input handler is being destroyed. Disable input until the lock is
+      // released. Note: acquiring the lock blocks until all peripheral input
+      // has been handled.
+      inputHandlingLock = CServiceBroker::GetPeripherals().RegisterEventLock();
+    }
+
+    m_joysticks.erase(it);
+  }
+}
+
+void CGameClientInput::HardwareReset()
+{
+  if (m_hardware)
+    m_hardware->OnResetButton();
+}
+
+bool CGameClientInput::ReceiveInputEvent(const game_input_event& event)
+{
+  bool bHandled = false;
+
+  switch (event.type)
+  {
+    case GAME_INPUT_EVENT_MOTOR:
+      if (event.port_address != nullptr && event.feature_name != nullptr)
+        bHandled = SetRumble(event.port_address, event.feature_name, event.motor.magnitude);
+      break;
+    default:
+      break;
+  }
+
+  return bHandled;
+}
+
+bool CGameClientInput::SetRumble(const std::string& portAddress,
+                                 const std::string& feature,
+                                 float magnitude)
+{
+  bool bHandled = false;
+
+  auto it = m_joysticks.find(portAddress);
+  if (it != m_joysticks.end())
+    bHandled = it->second->SetRumble(feature, magnitude);
+
+  return bHandled;
+}
+
+ControllerVector CGameClientInput::GetControllers(const CGameClient& gameClient)
+{
+  using namespace ADDON;
+
+  ControllerVector controllers;
+
+  CGameServices& gameServices = CServiceBroker::GetGameServices();
+
+  const auto& dependencies = gameClient.GetDependencies();
+  for (auto it = dependencies.begin(); it != dependencies.end(); ++it)
+  {
+    ControllerPtr controller = gameServices.GetController(it->id);
+    if (controller)
+      controllers.push_back(controller);
+  }
+
+  if (controllers.empty())
+  {
+    // Use the default controller
+    ControllerPtr controller = gameServices.GetDefaultController();
+    if (controller)
+      controllers.push_back(controller);
+  }
+
+  return controllers;
+}
diff --git a/xbmc/games/addons/input/GameClientInput.h b/xbmc/games/addons/input/GameClientInput.h
new file mode 100644
index 0000000..be7e71c
--- /dev/null
+++ b/xbmc/games/addons/input/GameClientInput.h
@@ -0,0 +1,160 @@
+/*
+ *  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/addons/GameClientSubsystem.h"
+#include "games/controllers/ControllerTypes.h"
+#include "games/controllers/types/ControllerTree.h"
+#include "peripherals/PeripheralTypes.h"
+#include "utils/Observer.h"
+
+#include <map>
+#include <memory>
+#include <string>
+
+class CCriticalSection;
+struct game_input_event;
+
+namespace KODI
+{
+namespace JOYSTICK
+{
+class IInputProvider;
+}
+
+namespace GAME
+{
+class CGameClient;
+class CGameClientController;
+class CGameClientHardware;
+class CGameClientJoystick;
+class CGameClientKeyboard;
+class CGameClientMouse;
+class CGameClientTopology;
+class CPortManager;
+class IGameInputCallback;
+
+class CGameClientInput : protected CGameClientSubsystem, public Observable
+{
+public:
+  //! @todo de-duplicate
+  using PortAddress = std::string;
+  using JoystickMap = std::map<PortAddress, std::shared_ptr<CGameClientJoystick>>;
+
+  CGameClientInput(CGameClient& gameClient,
+                   AddonInstance_Game& addonStruct,
+                   CCriticalSection& clientAccess);
+  ~CGameClientInput() override;
+
+  void Initialize();
+  void Deinitialize();
+
+  void Start(IGameInputCallback* input);
+  void Stop();
+
+  // Input functions
+  bool HasFeature(const std::string& controllerId, const std::string& featureName) const;
+  bool AcceptsInput() const;
+  bool InputEvent(const game_input_event& event);
+
+  // Topology functions
+  const CControllerTree& GetDefaultControllerTree() const;
+  const CControllerTree& GetActiveControllerTree() const;
+  bool SupportsKeyboard() const;
+  bool SupportsMouse() const;
+  int GetPlayerLimit() const;
+  bool ConnectController(const std::string& portAddress, const ControllerPtr& controller);
+  bool DisconnectController(const std::string& portAddress);
+  void SavePorts();
+  void ResetPorts();
+
+  // Joystick functions
+  const JoystickMap& GetJoystickMap() const { return m_joysticks; }
+  void CloseJoysticks(PERIPHERALS::EventLockHandlePtr& inputHandlingLock);
+
+  // Keyboard functions
+  bool OpenKeyboard(const ControllerPtr& controller, const PERIPHERALS::PeripheralPtr& keyboard);
+  bool IsKeyboardOpen() const;
+  void CloseKeyboard();
+
+  // Mouse functions
+  bool OpenMouse(const ControllerPtr& controller, const PERIPHERALS::PeripheralPtr& mouse);
+  bool IsMouseOpen() const;
+  void CloseMouse();
+
+  // Agent functions
+  bool HasAgent() const;
+
+  // Hardware input functions
+  void HardwareReset();
+
+  // Input callbacks
+  bool ReceiveInputEvent(const game_input_event& eventStruct);
+
+private:
+  // Private input helpers
+  void LoadTopology();
+  void SetControllerLayouts(const ControllerVector& controllers);
+  bool OpenJoystick(const std::string& portAddress, const ControllerPtr& controller);
+  void CloseJoysticks(const CPortNode& port, PERIPHERALS::EventLockHandlePtr& inputHandlingLock);
+  void CloseJoystick(const std::string& portAddress,
+                     PERIPHERALS::EventLockHandlePtr& inputHandlingLock);
+
+  // Private callback helpers
+  bool SetRumble(const std::string& portAddress, const std::string& feature, float magnitude);
+
+  // Helper functions
+  static ControllerVector GetControllers(const CGameClient& gameClient);
+  static void ActivateControllers(CControllerHub& hub);
+
+  // Input properties
+  IGameInputCallback* m_inputCallback = nullptr;
+  std::unique_ptr<CGameClientTopology> m_topology;
+  using ControllerLayoutMap = std::map<std::string, std::unique_ptr<CGameClientController>>;
+  ControllerLayoutMap m_controllerLayouts;
+
+  /*!
+   * \brief Map of port address to joystick handler
+   *
+   * The port address is a string that identifies the adress of the port.
+   *
+   * The joystick handler connects to joystick input of the game client.
+   *
+   * This property is always populated with the default joystick configuration
+   * (i.e. all ports are connected to the first controller they accept).
+   */
+  JoystickMap m_joysticks;
+
+  // TODO: Guard with a mutex
+  std::unique_ptr<CPortManager> m_portManager;
+
+  /*!
+   * \brief Keyboard handler
+   *
+   * This connects to the keyboard input of the game client.
+   */
+  std::unique_ptr<CGameClientKeyboard> m_keyboard;
+
+  /*!
+   * \brief Mouse handler
+   *
+   * This connects to the mouse input of the game client.
+   */
+  std::unique_ptr<CGameClientMouse> m_mouse;
+
+  /*!
+   * \brief Hardware input handler
+   *
+   * This connects to input from game console hardware belonging to the game
+   * client.
+   */
+  std::unique_ptr<CGameClientHardware> m_hardware;
+};
+} // namespace GAME
+} // namespace KODI
diff --git a/xbmc/games/addons/input/GameClientJoystick.cpp b/xbmc/games/addons/input/GameClientJoystick.cpp
new file mode 100644
index 0000000..d4f083b
--- /dev/null
+++ b/xbmc/games/addons/input/GameClientJoystick.cpp
@@ -0,0 +1,205 @@
+/*
+ *  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 "GameClientJoystick.h"
+
+#include "GameClientInput.h"
+#include "GameClientTopology.h"
+#include "games/addons/GameClient.h"
+#include "games/controllers/Controller.h"
+#include "games/ports/input/PortInput.h"
+#include "input/joysticks/interfaces/IInputReceiver.h"
+#include "peripherals/devices/Peripheral.h"
+#include "utils/log.h"
+
+#include <assert.h>
+
+using namespace KODI;
+using namespace GAME;
+
+CGameClientJoystick::CGameClientJoystick(CGameClient& gameClient,
+                                         const std::string& portAddress,
+                                         const ControllerPtr& controller)
+  : m_gameClient(gameClient),
+    m_portAddress(portAddress),
+    m_controller(controller),
+    m_portInput(new CPortInput(this))
+{
+  assert(m_controller.get() != NULL);
+}
+
+CGameClientJoystick::~CGameClientJoystick() = default;
+
+void CGameClientJoystick::RegisterInput(JOYSTICK::IInputProvider* inputProvider)
+{
+  m_portInput->RegisterInput(inputProvider);
+}
+
+void CGameClientJoystick::UnregisterInput(JOYSTICK::IInputProvider* inputProvider)
+{
+  m_portInput->UnregisterInput(inputProvider);
+}
+
+std::string CGameClientJoystick::ControllerID(void) const
+{
+  return m_controller->ID();
+}
+
+bool CGameClientJoystick::HasFeature(const std::string& feature) const
+{
+  return m_gameClient.Input().HasFeature(m_controller->ID(), feature);
+}
+
+bool CGameClientJoystick::AcceptsInput(const std::string& feature) const
+{
+  return m_gameClient.Input().AcceptsInput();
+}
+
+bool CGameClientJoystick::OnButtonPress(const std::string& feature, bool bPressed)
+{
+  game_input_event event;
+
+  std::string controllerId = m_controller->ID();
+
+  event.type = GAME_INPUT_EVENT_DIGITAL_BUTTON;
+  event.controller_id = controllerId.c_str();
+  event.port_type = GAME_PORT_CONTROLLER;
+  event.port_address = m_portAddress.c_str();
+  event.feature_name = feature.c_str();
+  event.digital_button.pressed = bPressed;
+
+  return m_gameClient.Input().InputEvent(event);
+}
+
+bool CGameClientJoystick::OnButtonMotion(const std::string& feature,
+                                         float magnitude,
+                                         unsigned int motionTimeMs)
+{
+  game_input_event event;
+
+  std::string controllerId = m_controller->ID();
+
+  event.type = GAME_INPUT_EVENT_ANALOG_BUTTON;
+  event.controller_id = controllerId.c_str();
+  event.port_type = GAME_PORT_CONTROLLER;
+  event.port_address = m_portAddress.c_str();
+  event.feature_name = feature.c_str();
+  event.analog_button.magnitude = magnitude;
+
+  return m_gameClient.Input().InputEvent(event);
+}
+
+bool CGameClientJoystick::OnAnalogStickMotion(const std::string& feature,
+                                              float x,
+                                              float y,
+                                              unsigned int motionTimeMs)
+{
+  game_input_event event;
+
+  std::string controllerId = m_controller->ID();
+
+  event.type = GAME_INPUT_EVENT_ANALOG_STICK;
+  event.controller_id = controllerId.c_str();
+  event.port_type = GAME_PORT_CONTROLLER;
+  event.port_address = m_portAddress.c_str();
+  event.feature_name = feature.c_str();
+  event.analog_stick.x = x;
+  event.analog_stick.y = y;
+
+  return m_gameClient.Input().InputEvent(event);
+}
+
+bool CGameClientJoystick::OnAccelerometerMotion(const std::string& feature,
+                                                float x,
+                                                float y,
+                                                float z)
+{
+  game_input_event event;
+
+  std::string controllerId = m_controller->ID();
+
+  event.type = GAME_INPUT_EVENT_ACCELEROMETER;
+  event.controller_id = controllerId.c_str();
+  event.port_type = GAME_PORT_CONTROLLER;
+  event.port_address = m_portAddress.c_str();
+  event.feature_name = feature.c_str();
+  event.accelerometer.x = x;
+  event.accelerometer.y = y;
+  event.accelerometer.z = z;
+
+  return m_gameClient.Input().InputEvent(event);
+}
+
+bool CGameClientJoystick::OnWheelMotion(const std::string& feature,
+                                        float position,
+                                        unsigned int motionTimeMs)
+{
+  game_input_event event;
+
+  std::string controllerId = m_controller->ID();
+
+  event.type = GAME_INPUT_EVENT_AXIS;
+  event.controller_id = controllerId.c_str();
+  event.port_type = GAME_PORT_CONTROLLER;
+  event.port_address = m_portAddress.c_str();
+  event.feature_name = feature.c_str();
+  event.axis.position = position;
+
+  return m_gameClient.Input().InputEvent(event);
+}
+
+bool CGameClientJoystick::OnThrottleMotion(const std::string& feature,
+                                           float position,
+                                           unsigned int motionTimeMs)
+{
+  game_input_event event;
+
+  std::string controllerId = m_controller->ID();
+
+  event.type = GAME_INPUT_EVENT_AXIS;
+  event.controller_id = controllerId.c_str();
+  event.port_type = GAME_PORT_CONTROLLER;
+  event.port_address = m_portAddress.c_str();
+  event.feature_name = feature.c_str();
+  event.axis.position = position;
+
+  return m_gameClient.Input().InputEvent(event);
+}
+
+std::string CGameClientJoystick::GetControllerAddress() const
+{
+  return CGameClientTopology::MakeAddress(m_portAddress, m_controller->ID());
+}
+
+std::string CGameClientJoystick::GetSourceLocation() const
+{
+  if (m_sourcePeripheral)
+    return m_sourcePeripheral->Location();
+
+  return "";
+}
+
+void CGameClientJoystick::SetSource(PERIPHERALS::PeripheralPtr sourcePeripheral)
+{
+  m_sourcePeripheral = std::move(sourcePeripheral);
+}
+
+void CGameClientJoystick::ClearSource()
+{
+  m_sourcePeripheral.reset();
+}
+
+bool CGameClientJoystick::SetRumble(const std::string& feature, float magnitude)
+{
+  bool bHandled = false;
+
+  if (InputReceiver())
+    bHandled = InputReceiver()->SetRumbleState(feature, magnitude);
+
+  return bHandled;
+}
diff --git a/xbmc/games/addons/input/GameClientJoystick.h b/xbmc/games/addons/input/GameClientJoystick.h
new file mode 100644
index 0000000..cfb1709
--- /dev/null
+++ b/xbmc/games/addons/input/GameClientJoystick.h
@@ -0,0 +1,101 @@
+/*
+ *  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/interfaces/IInputHandler.h"
+#include "peripherals/PeripheralTypes.h"
+
+#include <memory>
+
+namespace KODI
+{
+namespace JOYSTICK
+{
+class IInputProvider;
+}
+
+namespace GAME
+{
+class CGameClient;
+class CPortInput;
+
+/*!
+ * \ingroup games
+ * \brief Handles game controller events for games.
+ *
+ * Listens to game controller events and forwards them to the games (as game_input_event).
+ */
+class CGameClientJoystick : public JOYSTICK::IInputHandler
+{
+public:
+  /*!
+   * \brief Constructor.
+   * \param addon The game client implementation.
+   * \param port The port this game controller is associated with.
+   * \param controller The game controller which is used (for controller mapping).
+   * \param dllStruct The emulator or game to which the events are sent.
+   */
+  CGameClientJoystick(CGameClient& addon,
+                      const std::string& portAddress,
+                      const ControllerPtr& controller);
+
+  ~CGameClientJoystick() override;
+
+  void RegisterInput(JOYSTICK::IInputProvider* inputProvider);
+  void UnregisterInput(JOYSTICK::IInputProvider* inputProvider);
+
+  // Implementation of IInputHandler
+  std::string ControllerID() const override;
+  bool HasFeature(const std::string& feature) const override;
+  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 {}
+
+  // Input accessors
+  const std::string& GetPortAddress() const { return m_portAddress; }
+  const ControllerPtr& GetController() const { return m_controller; }
+  std::string GetControllerAddress() const;
+  const PERIPHERALS::PeripheralPtr& GetSource() const { return m_sourcePeripheral; }
+  std::string GetSourceLocation() const;
+
+  // Input mutators
+  void SetSource(PERIPHERALS::PeripheralPtr sourcePeripheral);
+  void ClearSource();
+
+  // Input handlers
+  bool SetRumble(const std::string& feature, float magnitude);
+
+private:
+  // Construction parameters
+  CGameClient& m_gameClient;
+  const std::string m_portAddress;
+  const ControllerPtr m_controller;
+
+  // Input parameters
+  std::unique_ptr<CPortInput> m_portInput;
+  PERIPHERALS::PeripheralPtr m_sourcePeripheral;
+};
+} // namespace GAME
+} // namespace KODI
diff --git a/xbmc/games/addons/input/GameClientKeyboard.cpp b/xbmc/games/addons/input/GameClientKeyboard.cpp
new file mode 100644
index 0000000..e6f48c9
--- /dev/null
+++ b/xbmc/games/addons/input/GameClientKeyboard.cpp
@@ -0,0 +1,101 @@
+/*
+ *  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 "GameClientKeyboard.h"
+
+#include "GameClientInput.h"
+#include "addons/kodi-dev-kit/include/kodi/addon-instance/Game.h"
+#include "games/addons/GameClient.h"
+#include "games/addons/GameClientTranslator.h"
+#include "input/keyboard/interfaces/IKeyboardInputProvider.h"
+#include "utils/log.h"
+
+#include <utility>
+
+using namespace KODI;
+using namespace GAME;
+
+#define BUTTON_INDEX_MASK 0x01ff
+
+CGameClientKeyboard::CGameClientKeyboard(CGameClient& gameClient,
+                                         std::string controllerId,
+                                         KEYBOARD::IKeyboardInputProvider* inputProvider)
+  : m_gameClient(gameClient),
+    m_controllerId(std::move(controllerId)),
+    m_inputProvider(inputProvider)
+{
+  m_inputProvider->RegisterKeyboardHandler(this, false);
+}
+
+CGameClientKeyboard::~CGameClientKeyboard()
+{
+  m_inputProvider->UnregisterKeyboardHandler(this);
+}
+
+std::string CGameClientKeyboard::ControllerID() const
+{
+  return m_controllerId;
+}
+
+bool CGameClientKeyboard::HasKey(const KEYBOARD::KeyName& key) const
+{
+  return m_gameClient.Input().HasFeature(ControllerID(), key);
+}
+
+bool CGameClientKeyboard::OnKeyPress(const KEYBOARD::KeyName& key,
+                                     KEYBOARD::Modifier mod,
+                                     uint32_t unicode)
+{
+  // Only allow activated input in fullscreen game
+  if (!m_gameClient.Input().AcceptsInput())
+  {
+    CLog::Log(LOGDEBUG, "GAME: key press ignored, not in fullscreen game");
+    return false;
+  }
+
+  game_input_event event;
+
+  event.type = GAME_INPUT_EVENT_KEY;
+  event.controller_id = m_controllerId.c_str();
+  event.port_type = GAME_PORT_KEYBOARD;
+  event.port_address = ""; // Not used
+  event.feature_name = key.c_str();
+  event.key.pressed = true;
+  event.key.unicode = unicode;
+  event.key.modifiers = CGameClientTranslator::GetModifiers(mod);
+
+  return m_gameClient.Input().InputEvent(event);
+}
+
+void CGameClientKeyboard::OnKeyRelease(const KEYBOARD::KeyName& key,
+                                       KEYBOARD::Modifier mod,
+                                       uint32_t unicode)
+{
+  game_input_event event;
+
+  event.type = GAME_INPUT_EVENT_KEY;
+  event.controller_id = m_controllerId.c_str();
+  event.port_type = GAME_PORT_KEYBOARD;
+  event.port_address = ""; // Not used
+  event.feature_name = key.c_str();
+  event.key.pressed = false;
+  event.key.unicode = unicode;
+  event.key.modifiers = CGameClientTranslator::GetModifiers(mod);
+
+  m_gameClient.Input().InputEvent(event);
+}
+
+void CGameClientKeyboard::SetSource(PERIPHERALS::PeripheralPtr sourcePeripheral)
+{
+  m_sourcePeripheral = std::move(sourcePeripheral);
+}
+
+void CGameClientKeyboard::ClearSource()
+{
+  m_sourcePeripheral.reset();
+}
diff --git a/xbmc/games/addons/input/GameClientKeyboard.h b/xbmc/games/addons/input/GameClientKeyboard.h
new file mode 100644
index 0000000..a6103f2
--- /dev/null
+++ b/xbmc/games/addons/input/GameClientKeyboard.h
@@ -0,0 +1,76 @@
+/*
+ *  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/keyboard/interfaces/IKeyboardInputHandler.h"
+#include "peripherals/PeripheralTypes.h"
+
+namespace KODI
+{
+namespace KEYBOARD
+{
+class IKeyboardInputProvider;
+}
+
+namespace GAME
+{
+class CGameClient;
+
+/*!
+ * \ingroup games
+ * \brief Handles keyboard events for games.
+ *
+ * Listens to keyboard events and forwards them to the games (as game_input_event).
+ */
+class CGameClientKeyboard : public KEYBOARD::IKeyboardInputHandler
+{
+public:
+  /*!
+   * \brief Constructor registers for keyboard events at CInputManager.
+   * \param gameClient The game client implementation.
+   * \param controllerId The controller profile used for input
+   * \param dllStruct The emulator or game to which the events are sent.
+   * \param inputProvider The interface providing us with keyboard input.
+   */
+  CGameClientKeyboard(CGameClient& gameClient,
+                      std::string controllerId,
+                      KEYBOARD::IKeyboardInputProvider* inputProvider);
+
+  /*!
+   * \brief Destructor unregisters from keyboard events from CInputManager.
+   */
+  ~CGameClientKeyboard() override;
+
+  // implementation of IKeyboardInputHandler
+  std::string ControllerID() const override;
+  bool HasKey(const KEYBOARD::KeyName& key) const override;
+  bool OnKeyPress(const KEYBOARD::KeyName& key, KEYBOARD::Modifier mod, uint32_t unicode) override;
+  void OnKeyRelease(const KEYBOARD::KeyName& key,
+                    KEYBOARD::Modifier mod,
+                    uint32_t unicode) override;
+
+  // Input accessors
+  const std::string& GetControllerID() const { return m_controllerId; }
+  const PERIPHERALS::PeripheralPtr& GetSource() const { return m_sourcePeripheral; }
+
+  // Input mutators
+  void SetSource(PERIPHERALS::PeripheralPtr sourcePeripheral);
+  void ClearSource();
+
+private:
+  // Construction parameters
+  CGameClient& m_gameClient;
+  const std::string m_controllerId;
+  KEYBOARD::IKeyboardInputProvider* const m_inputProvider;
+
+  // Input parameters
+  PERIPHERALS::PeripheralPtr m_sourcePeripheral;
+};
+} // namespace GAME
+} // namespace KODI
diff --git a/xbmc/games/addons/input/GameClientMouse.cpp b/xbmc/games/addons/input/GameClientMouse.cpp
new file mode 100644
index 0000000..5cc9676
--- /dev/null
+++ b/xbmc/games/addons/input/GameClientMouse.cpp
@@ -0,0 +1,106 @@
+/*
+ *  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 "GameClientMouse.h"
+
+#include "GameClientInput.h"
+#include "addons/kodi-dev-kit/include/kodi/addon-instance/Game.h"
+#include "games/addons/GameClient.h"
+#include "input/mouse/interfaces/IMouseInputProvider.h"
+
+#include <utility>
+
+using namespace KODI;
+using namespace GAME;
+
+CGameClientMouse::CGameClientMouse(CGameClient& gameClient,
+                                   std::string controllerId,
+                                   MOUSE::IMouseInputProvider* inputProvider)
+  : m_gameClient(gameClient),
+    m_controllerId(std::move(controllerId)),
+    m_inputProvider(inputProvider)
+{
+  inputProvider->RegisterMouseHandler(this, false);
+}
+
+CGameClientMouse::~CGameClientMouse()
+{
+  m_inputProvider->UnregisterMouseHandler(this);
+}
+
+std::string CGameClientMouse::ControllerID(void) const
+{
+  return m_controllerId;
+}
+
+bool CGameClientMouse::OnMotion(const std::string& relpointer, int dx, int dy)
+{
+  // Only allow activated input in fullscreen game
+  if (!m_gameClient.Input().AcceptsInput())
+  {
+    return false;
+  }
+
+  const std::string controllerId = ControllerID();
+
+  game_input_event event;
+
+  event.type = GAME_INPUT_EVENT_RELATIVE_POINTER;
+  event.controller_id = m_controllerId.c_str();
+  event.port_type = GAME_PORT_MOUSE;
+  event.port_address = ""; // Not used
+  event.feature_name = relpointer.c_str();
+  event.rel_pointer.x = dx;
+  event.rel_pointer.y = dy;
+
+  return m_gameClient.Input().InputEvent(event);
+}
+
+bool CGameClientMouse::OnButtonPress(const std::string& button)
+{
+  // Only allow activated input in fullscreen game
+  if (!m_gameClient.Input().AcceptsInput())
+  {
+    return false;
+  }
+
+  game_input_event event;
+
+  event.type = GAME_INPUT_EVENT_DIGITAL_BUTTON;
+  event.controller_id = m_controllerId.c_str();
+  event.port_type = GAME_PORT_MOUSE;
+  event.port_address = ""; // Not used
+  event.feature_name = button.c_str();
+  event.digital_button.pressed = true;
+
+  return m_gameClient.Input().InputEvent(event);
+}
+
+void CGameClientMouse::OnButtonRelease(const std::string& button)
+{
+  game_input_event event;
+
+  event.type = GAME_INPUT_EVENT_DIGITAL_BUTTON;
+  event.controller_id = m_controllerId.c_str();
+  event.port_type = GAME_PORT_MOUSE;
+  event.port_address = ""; // Not used
+  event.feature_name = button.c_str();
+  event.digital_button.pressed = false;
+
+  m_gameClient.Input().InputEvent(event);
+}
+
+void CGameClientMouse::SetSource(PERIPHERALS::PeripheralPtr sourcePeripheral)
+{
+  m_sourcePeripheral = std::move(sourcePeripheral);
+}
+
+void CGameClientMouse::ClearSource()
+{
+  m_sourcePeripheral.reset();
+}
diff --git a/xbmc/games/addons/input/GameClientMouse.h b/xbmc/games/addons/input/GameClientMouse.h
new file mode 100644
index 0000000..4da592f
--- /dev/null
+++ b/xbmc/games/addons/input/GameClientMouse.h
@@ -0,0 +1,74 @@
+/*
+ *  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/mouse/interfaces/IMouseInputHandler.h"
+#include "peripherals/PeripheralTypes.h"
+
+namespace KODI
+{
+namespace MOUSE
+{
+class IMouseInputProvider;
+}
+
+namespace GAME
+{
+class CGameClient;
+
+/*!
+ * \ingroup games
+ * \brief Handles mouse events for games.
+ *
+ * Listens to mouse events and forwards them to the games (as game_input_event).
+ */
+class CGameClientMouse : public MOUSE::IMouseInputHandler
+{
+public:
+  /*!
+   * \brief Constructor registers for mouse events at CInputManager.
+   * \param gameClient The game client implementation.
+   * \param controllerId The controller profile used for input
+   * \param dllStruct The emulator or game to which the events are sent.
+   * \param inputProvider The interface providing us with mouse input.
+   */
+  CGameClientMouse(CGameClient& gameClient,
+                   std::string controllerId,
+                   MOUSE::IMouseInputProvider* inputProvider);
+
+  /*!
+   * \brief Destructor unregisters from mouse events from CInputManager.
+   */
+  ~CGameClientMouse() override;
+
+  // implementation of IMouseInputHandler
+  std::string ControllerID() const override;
+  bool OnMotion(const std::string& relpointer, int dx, int dy) override;
+  bool OnButtonPress(const std::string& button) override;
+  void OnButtonRelease(const std::string& button) override;
+
+  // Input accessors
+  const std::string& GetControllerID() const { return m_controllerId; }
+  const PERIPHERALS::PeripheralPtr& GetSource() const { return m_sourcePeripheral; }
+
+  // Input mutators
+  void SetSource(PERIPHERALS::PeripheralPtr sourcePeripheral);
+  void ClearSource();
+
+private:
+  // Construction parameters
+  CGameClient& m_gameClient;
+  const std::string m_controllerId;
+  MOUSE::IMouseInputProvider* const m_inputProvider;
+
+  // Input parameters
+  PERIPHERALS::PeripheralPtr m_sourcePeripheral;
+};
+} // namespace GAME
+} // namespace KODI
diff --git a/xbmc/games/addons/input/GameClientPort.cpp b/xbmc/games/addons/input/GameClientPort.cpp
new file mode 100644
index 0000000..c582fff
--- /dev/null
+++ b/xbmc/games/addons/input/GameClientPort.cpp
@@ -0,0 +1,72 @@
+/*
+ *  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 "GameClientPort.h"
+
+#include "GameClientDevice.h"
+#include "addons/kodi-dev-kit/include/kodi/addon-instance/Game.h"
+#include "games/addons/GameClientTranslator.h"
+#include "games/controllers/Controller.h"
+#include "games/controllers/input/PhysicalTopology.h"
+#include "utils/StringUtils.h"
+
+#include <algorithm>
+
+using namespace KODI;
+using namespace GAME;
+
+CGameClientPort::CGameClientPort(const game_input_port& port)
+  : m_type(CGameClientTranslator::TranslatePortType(port.type)),
+    m_portId(port.port_id ? port.port_id : ""),
+    m_forceConnected(port.force_connected)
+{
+  if (port.accepted_devices != nullptr)
+  {
+    for (unsigned int i = 0; i < port.device_count; i++)
+    {
+      std::unique_ptr<CGameClientDevice> device(new CGameClientDevice(port.accepted_devices[i]));
+
+      if (device->Controller() != CController::EmptyPtr)
+        m_acceptedDevices.emplace_back(std::move(device));
+    }
+  }
+}
+
+CGameClientPort::CGameClientPort(const ControllerVector& controllers)
+  : m_type(PORT_TYPE::CONTROLLER), m_portId(DEFAULT_PORT_ID)
+{
+  for (const auto& controller : controllers)
+    m_acceptedDevices.emplace_back(new CGameClientDevice(controller));
+}
+
+CGameClientPort::CGameClientPort(const game_input_port& logicalPort,
+                                 const CPhysicalPort& physicalPort)
+  : m_type(PORT_TYPE::CONTROLLER),
+    m_portId(physicalPort.ID()),
+    m_forceConnected(logicalPort.force_connected)
+{
+  if (logicalPort.accepted_devices != nullptr)
+  {
+    for (unsigned int i = 0; i < logicalPort.device_count; i++)
+    {
+      // Ensure device is physically compatible
+      const game_input_device& deviceStruct = logicalPort.accepted_devices[i];
+      std::string controllerId = deviceStruct.controller_id ? deviceStruct.controller_id : "";
+
+      if (physicalPort.IsCompatible(controllerId))
+      {
+        std::unique_ptr<CGameClientDevice> device(new CGameClientDevice(deviceStruct));
+
+        if (device->Controller() != CController::EmptyPtr)
+          m_acceptedDevices.emplace_back(std::move(device));
+      }
+    }
+  }
+}
+
+CGameClientPort::~CGameClientPort() = default;
diff --git a/xbmc/games/addons/input/GameClientPort.h b/xbmc/games/addons/input/GameClientPort.h
new file mode 100644
index 0000000..80fccef
--- /dev/null
+++ b/xbmc/games/addons/input/GameClientPort.h
@@ -0,0 +1,103 @@
+/*
+ *  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/GameTypes.h"
+#include "games/controllers/ControllerTypes.h"
+
+#include <string>
+
+struct game_input_device;
+struct game_input_port;
+
+namespace KODI
+{
+namespace GAME
+{
+class CPhysicalPort;
+
+/*!
+ * \ingroup games
+ * \brief Represents a port that devices can connect to
+ */
+class CGameClientPort
+{
+public:
+  /*!
+   * \brief Construct a hardware port
+   *
+   * \param port The hardware port Game API struct
+   */
+  CGameClientPort(const game_input_port& port);
+
+  /*!
+   * \brief Construct a hardware port that accepts the given controllers
+   *
+   * \param controllers List of accepted controller profiles
+   *
+   * The port is given the ID specified by DEFAULT_PORT_ID.
+   */
+  CGameClientPort(const ControllerVector& controllers);
+
+  /*!
+   * \brief Construct a controller port
+   *
+   * \param logicalPort The logical port Game API struct
+   * \param physicalPort The physical port definition
+   *
+   * The physical port is defined by the controller profile. This definition
+   * specifies which controllers the port is physically compatible with.
+   *
+   * The logical port is defined by the emulator's input topology. This
+   * definition specifies which controllers the emulator's logic can handle.
+   *
+   * Obviously, the controllers specified by the logical port must be a subset
+   * of the controllers supported by the physical port.
+   */
+  CGameClientPort(const game_input_port& logicalPort, const CPhysicalPort& physicalPort);
+
+  /*!
+   * \brief Destructor
+   */
+  ~CGameClientPort();
+
+  /*!
+   * \brief Get the port type
+   *
+   * The port type identifies if this port is for a keyboard, mouse, or
+   * controller.
+   */
+  PORT_TYPE PortType() const { return m_type; }
+
+  /*!
+   * \brief Get the ID of the port
+   *
+   * The ID is used when creating a toplogical address for the port.
+   */
+  const std::string& ID() const { return m_portId; }
+
+  /*!
+   * \brief True if a controller must be connected, preventing the disconnected
+   * option from being shown to the user
+   */
+  bool ForceConnected() const { return m_forceConnected; }
+
+  /*!
+   * \brief Get the list of devices accepted by this port
+   */
+  const GameClientDeviceVec& Devices() const { return m_acceptedDevices; }
+
+private:
+  PORT_TYPE m_type;
+  std::string m_portId;
+  bool m_forceConnected{false};
+  GameClientDeviceVec m_acceptedDevices;
+};
+} // namespace GAME
+} // namespace KODI
diff --git a/xbmc/games/addons/input/GameClientTopology.cpp b/xbmc/games/addons/input/GameClientTopology.cpp
new file mode 100644
index 0000000..e1e9757
--- /dev/null
+++ b/xbmc/games/addons/input/GameClientTopology.cpp
@@ -0,0 +1,110 @@
+/*
+ *  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 "GameClientTopology.h"
+
+#include "GameClientDevice.h"
+#include "GameClientPort.h"
+#include "games/controllers/Controller.h"
+
+#include <sstream>
+#include <utility>
+
+using namespace KODI;
+using namespace GAME;
+
+#define CONTROLLER_ADDRESS_SEPARATOR "/"
+
+CGameClientTopology::CGameClientTopology(GameClientPortVec ports, int playerLimit)
+  : m_ports(std::move(ports)), m_playerLimit(playerLimit), m_controllers(GetControllerTree(m_ports))
+{
+}
+
+void CGameClientTopology::Clear()
+{
+  m_ports.clear();
+  m_controllers.Clear();
+}
+
+CControllerTree CGameClientTopology::GetControllerTree(const GameClientPortVec& ports)
+{
+  CControllerTree tree;
+
+  PortVec controllerPorts;
+  for (const GameClientPortPtr& port : ports)
+  {
+    CPortNode portNode = GetPortNode(port, "");
+    controllerPorts.emplace_back(std::move(portNode));
+  }
+
+  tree.SetPorts(std::move(controllerPorts));
+
+  return tree;
+}
+
+CPortNode CGameClientTopology::GetPortNode(const GameClientPortPtr& port,
+                                           const std::string& controllerAddress)
+{
+  CPortNode portNode;
+
+  std::string portAddress = MakeAddress(controllerAddress, port->ID());
+
+  portNode.SetConnected(false);
+  portNode.SetPortType(port->PortType());
+  portNode.SetPortID(port->ID());
+  portNode.SetAddress(portAddress);
+  portNode.SetForceConnected(port->ForceConnected());
+
+  ControllerNodeVec nodes;
+  for (const GameClientDevicePtr& device : port->Devices())
+  {
+    CControllerNode controllerNode = GetControllerNode(device, portAddress);
+    nodes.emplace_back(std::move(controllerNode));
+  }
+  portNode.SetCompatibleControllers(std::move(nodes));
+
+  return portNode;
+}
+
+CControllerNode CGameClientTopology::GetControllerNode(const GameClientDevicePtr& device,
+                                                       const std::string& portAddress)
+{
+  CControllerNode controllerNode;
+
+  const std::string controllerAddress = MakeAddress(portAddress, device->Controller()->ID());
+
+  controllerNode.SetController(device->Controller());
+  controllerNode.SetPortAddress(portAddress);
+  controllerNode.SetControllerAddress(controllerAddress);
+
+  PortVec ports;
+  for (const GameClientPortPtr& port : device->Ports())
+  {
+    CPortNode portNode = GetPortNode(port, controllerAddress);
+    ports.emplace_back(std::move(portNode));
+  }
+
+  CControllerHub controllerHub;
+  controllerHub.SetPorts(std::move(ports));
+  controllerNode.SetHub(std::move(controllerHub));
+
+  return controllerNode;
+}
+
+std::string CGameClientTopology::MakeAddress(const std::string& baseAddress,
+                                             const std::string& nodeId)
+{
+  std::ostringstream address;
+
+  if (!baseAddress.empty())
+    address << baseAddress;
+
+  address << CONTROLLER_ADDRESS_SEPARATOR << nodeId;
+
+  return address.str();
+}
diff --git a/xbmc/games/addons/input/GameClientTopology.h b/xbmc/games/addons/input/GameClientTopology.h
new file mode 100644
index 0000000..10b40f1
--- /dev/null
+++ b/xbmc/games/addons/input/GameClientTopology.h
@@ -0,0 +1,50 @@
+/*
+ *  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/GameTypes.h"
+#include "games/controllers/types/ControllerTree.h"
+
+#include <memory>
+
+namespace KODI
+{
+namespace GAME
+{
+class CGameClientTopology
+{
+public:
+  CGameClientTopology() = default;
+  CGameClientTopology(GameClientPortVec ports, int playerLimit);
+
+  void Clear();
+
+  int GetPlayerLimit() const { return m_playerLimit; }
+
+  const CControllerTree& GetControllerTree() const { return m_controllers; }
+  CControllerTree& GetControllerTree() { return m_controllers; }
+
+  // Utility function
+  static std::string MakeAddress(const std::string& baseAddress, const std::string& nodeId);
+
+private:
+  static CControllerTree GetControllerTree(const GameClientPortVec& ports);
+  static CPortNode GetPortNode(const GameClientPortPtr& port, const std::string& controllerAddress);
+  static CControllerNode GetControllerNode(const GameClientDevicePtr& device,
+                                           const std::string& portAddress);
+
+  // Game API parameters
+  GameClientPortVec m_ports;
+  int m_playerLimit = -1;
+
+  // Controller parameters
+  CControllerTree m_controllers;
+};
+} // namespace GAME
+} // namespace KODI
diff --git a/xbmc/games/addons/streams/CMakeLists.txt b/xbmc/games/addons/streams/CMakeLists.txt
new file mode 100644
index 0000000..f8de0e6
--- /dev/null
+++ b/xbmc/games/addons/streams/CMakeLists.txt
@@ -0,0 +1,14 @@
+set(SOURCES GameClientStreamAudio.cpp
+            GameClientStreams.cpp
+            GameClientStreamSwFramebuffer.cpp
+            GameClientStreamVideo.cpp
+)
+
+set(HEADERS GameClientStreamAudio.h
+            GameClientStreams.h
+            GameClientStreamSwFramebuffer.h
+            GameClientStreamVideo.h
+            IGameClientStream.h
+)
+
+core_add_library(game_addon_streams)
diff --git a/xbmc/games/addons/streams/GameClientStreamAudio.cpp b/xbmc/games/addons/streams/GameClientStreamAudio.cpp
new file mode 100644
index 0000000..a38f054
--- /dev/null
+++ b/xbmc/games/addons/streams/GameClientStreamAudio.cpp
@@ -0,0 +1,105 @@
+/*
+ *  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 "GameClientStreamAudio.h"
+
+#include "cores/RetroPlayer/streams/RetroPlayerAudio.h"
+#include "games/addons/GameClientTranslator.h"
+#include "utils/log.h"
+
+using namespace KODI;
+using namespace GAME;
+
+CGameClientStreamAudio::CGameClientStreamAudio(double sampleRate) : m_sampleRate(sampleRate)
+{
+}
+
+bool CGameClientStreamAudio::OpenStream(RETRO::IRetroPlayerStream* stream,
+                                        const game_stream_properties& properties)
+{
+  RETRO::CRetroPlayerAudio* audioStream = dynamic_cast<RETRO::CRetroPlayerAudio*>(stream);
+  if (audioStream == nullptr)
+  {
+    CLog::Log(LOGERROR, "GAME: RetroPlayer stream is not an audio stream");
+    return false;
+  }
+
+  std::unique_ptr<RETRO::AudioStreamProperties> audioProperties(
+      TranslateProperties(properties.audio, m_sampleRate));
+  if (audioProperties)
+  {
+    if (audioStream->OpenStream(static_cast<const RETRO::StreamProperties&>(*audioProperties)))
+      m_stream = stream;
+  }
+
+  return m_stream != nullptr;
+}
+
+void CGameClientStreamAudio::CloseStream()
+{
+  if (m_stream != nullptr)
+  {
+    m_stream->CloseStream();
+    m_stream = nullptr;
+  }
+}
+
+void CGameClientStreamAudio::AddData(const game_stream_packet& packet)
+{
+  if (packet.type != GAME_STREAM_AUDIO)
+    return;
+
+  if (m_stream != nullptr)
+  {
+    const game_stream_audio_packet& audio = packet.audio;
+
+    RETRO::AudioStreamPacket audioPacket{audio.data, audio.size};
+
+    m_stream->AddStreamData(static_cast<RETRO::StreamPacket&>(audioPacket));
+  }
+}
+
+RETRO::AudioStreamProperties* CGameClientStreamAudio::TranslateProperties(
+    const game_stream_audio_properties& properties, double sampleRate)
+{
+  const RETRO::PCMFormat pcmFormat = CGameClientTranslator::TranslatePCMFormat(properties.format);
+  if (pcmFormat == RETRO::PCMFormat::FMT_UNKNOWN)
+  {
+    CLog::Log(LOGERROR, "GAME: Unknown PCM format: {}", static_cast<int>(properties.format));
+    return nullptr;
+  }
+
+  RETRO::AudioChannelMap channelMap = {{RETRO::AudioChannel::CH_NULL}};
+  unsigned int i = 0;
+  if (properties.channel_map != nullptr)
+  {
+    for (const GAME_AUDIO_CHANNEL* channelPtr = properties.channel_map; *channelPtr != GAME_CH_NULL;
+         channelPtr++)
+    {
+      RETRO::AudioChannel channel = CGameClientTranslator::TranslateAudioChannel(*channelPtr);
+      if (channel == RETRO::AudioChannel::CH_NULL)
+      {
+        CLog::Log(LOGERROR, "GAME: Unknown channel ID: {}", static_cast<int>(*channelPtr));
+        return nullptr;
+      }
+
+      channelMap[i++] = channel;
+      if (i + 1 >= channelMap.size())
+        break;
+    }
+  }
+  channelMap[i] = RETRO::AudioChannel::CH_NULL;
+
+  if (channelMap[0] == RETRO::AudioChannel::CH_NULL)
+  {
+    CLog::Log(LOGERROR, "GAME: Empty channel layout");
+    return nullptr;
+  }
+
+  return new RETRO::AudioStreamProperties{pcmFormat, sampleRate, channelMap};
+}
diff --git a/xbmc/games/addons/streams/GameClientStreamAudio.h b/xbmc/games/addons/streams/GameClientStreamAudio.h
new file mode 100644
index 0000000..d48b0a6
--- /dev/null
+++ b/xbmc/games/addons/streams/GameClientStreamAudio.h
@@ -0,0 +1,52 @@
+/*
+ *  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 "IGameClientStream.h"
+#include "addons/kodi-dev-kit/include/kodi/addon-instance/Game.h"
+
+#include <vector>
+
+namespace KODI
+{
+namespace RETRO
+{
+class IRetroPlayerStream;
+struct AudioStreamProperties;
+} // namespace RETRO
+
+namespace GAME
+{
+
+class CGameClientStreamAudio : public IGameClientStream
+{
+public:
+  CGameClientStreamAudio(double sampleRate);
+  ~CGameClientStreamAudio() override { CloseStream(); }
+
+  // Implementation of IGameClientStream
+  bool OpenStream(RETRO::IRetroPlayerStream* stream,
+                  const game_stream_properties& properties) override;
+  void CloseStream() override;
+  void AddData(const game_stream_packet& packet) override;
+
+private:
+  // Utility functions
+  static RETRO::AudioStreamProperties* TranslateProperties(
+      const game_stream_audio_properties& properties, double sampleRate);
+
+  // Construction parameters
+  const double m_sampleRate;
+
+  // Stream parameters
+  RETRO::IRetroPlayerStream* m_stream = nullptr;
+};
+
+} // namespace GAME
+} // namespace KODI
diff --git a/xbmc/games/addons/streams/GameClientStreamSwFramebuffer.cpp b/xbmc/games/addons/streams/GameClientStreamSwFramebuffer.cpp
new file mode 100644
index 0000000..4d1e8af
--- /dev/null
+++ b/xbmc/games/addons/streams/GameClientStreamSwFramebuffer.cpp
@@ -0,0 +1,40 @@
+/*
+ *  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 "GameClientStreamSwFramebuffer.h"
+
+#include "addons/kodi-dev-kit/include/kodi/addon-instance/Game.h"
+#include "cores/RetroPlayer/streams/RetroPlayerVideo.h"
+#include "games/addons/GameClientTranslator.h"
+
+using namespace KODI;
+using namespace GAME;
+
+bool CGameClientStreamSwFramebuffer::GetBuffer(unsigned int width,
+                                               unsigned int height,
+                                               game_stream_buffer& buffer)
+{
+  if (m_stream != nullptr)
+  {
+    RETRO::VideoStreamBuffer streamBuffer;
+    if (m_stream->GetStreamBuffer(width, height, static_cast<RETRO::StreamBuffer&>(streamBuffer)))
+    {
+      buffer.type = GAME_STREAM_SW_FRAMEBUFFER;
+
+      game_stream_sw_framebuffer_buffer& framebuffer = buffer.sw_framebuffer;
+
+      framebuffer.format = CGameClientTranslator::TranslatePixelFormat(streamBuffer.pixfmt);
+      framebuffer.data = streamBuffer.data;
+      framebuffer.size = streamBuffer.size;
+
+      return true;
+    }
+  }
+
+  return false;
+}
diff --git a/xbmc/games/addons/streams/GameClientStreamSwFramebuffer.h b/xbmc/games/addons/streams/GameClientStreamSwFramebuffer.h
new file mode 100644
index 0000000..2b17dac
--- /dev/null
+++ b/xbmc/games/addons/streams/GameClientStreamSwFramebuffer.h
@@ -0,0 +1,29 @@
+/*
+ *  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 "GameClientStreamVideo.h"
+
+namespace KODI
+{
+namespace GAME
+{
+
+class CGameClientStreamSwFramebuffer : public CGameClientStreamVideo
+{
+public:
+  CGameClientStreamSwFramebuffer() = default;
+  ~CGameClientStreamSwFramebuffer() override = default;
+
+  // Implementation of IGameClientStream via CGameClientStreamVideo
+  bool GetBuffer(unsigned int width, unsigned int height, game_stream_buffer& buffer) override;
+};
+
+} // namespace GAME
+} // namespace KODI
diff --git a/xbmc/games/addons/streams/GameClientStreamVideo.cpp b/xbmc/games/addons/streams/GameClientStreamVideo.cpp
new file mode 100644
index 0000000..d110b28
--- /dev/null
+++ b/xbmc/games/addons/streams/GameClientStreamVideo.cpp
@@ -0,0 +1,108 @@
+/*
+ *  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 "GameClientStreamVideo.h"
+
+#include "cores/RetroPlayer/streams/RetroPlayerVideo.h"
+#include "games/addons/GameClientTranslator.h"
+#include "utils/log.h"
+
+using namespace KODI;
+using namespace GAME;
+
+bool CGameClientStreamVideo::OpenStream(RETRO::IRetroPlayerStream* stream,
+                                        const game_stream_properties& properties)
+{
+  RETRO::CRetroPlayerVideo* videoStream = dynamic_cast<RETRO::CRetroPlayerVideo*>(stream);
+  if (videoStream == nullptr)
+  {
+    CLog::Log(LOGERROR, "GAME: RetroPlayer stream is not a video stream");
+    return false;
+  }
+
+  std::unique_ptr<RETRO::VideoStreamProperties> videoProperties(
+      TranslateProperties(properties.video));
+  if (videoProperties)
+  {
+    if (videoStream->OpenStream(static_cast<const RETRO::StreamProperties&>(*videoProperties)))
+      m_stream = stream;
+  }
+
+  return m_stream != nullptr;
+}
+
+void CGameClientStreamVideo::CloseStream()
+{
+  if (m_stream != nullptr)
+  {
+    m_stream->CloseStream();
+    m_stream = nullptr;
+  }
+}
+
+void CGameClientStreamVideo::AddData(const game_stream_packet& packet)
+{
+  if (packet.type != GAME_STREAM_VIDEO && packet.type != GAME_STREAM_SW_FRAMEBUFFER)
+    return;
+
+  if (m_stream != nullptr)
+  {
+    const game_stream_video_packet& video = packet.video;
+
+    RETRO::VideoRotation rotation = CGameClientTranslator::TranslateRotation(video.rotation);
+
+    RETRO::VideoStreamPacket videoPacket{
+        video.width, video.height, rotation, video.data, video.size,
+    };
+
+    m_stream->AddStreamData(static_cast<const RETRO::StreamPacket&>(videoPacket));
+  }
+}
+
+RETRO::VideoStreamProperties* CGameClientStreamVideo::TranslateProperties(
+    const game_stream_video_properties& properties)
+{
+  const AVPixelFormat pixelFormat = CGameClientTranslator::TranslatePixelFormat(properties.format);
+  if (pixelFormat == AV_PIX_FMT_NONE)
+  {
+    CLog::Log(LOGERROR, "GAME: Unknown pixel format: {}", properties.format);
+    return nullptr;
+  }
+
+  const unsigned int nominalWidth = properties.nominal_width;
+  const unsigned int nominalHeight = properties.nominal_height;
+  if (nominalWidth == 0 || nominalHeight == 0)
+  {
+    CLog::Log(LOGERROR, "GAME: Invalid nominal dimensions: {}x{}", nominalWidth, nominalHeight);
+    return nullptr;
+  }
+
+  const unsigned int maxWidth = properties.max_width;
+  const unsigned int maxHeight = properties.max_height;
+  if (maxWidth == 0 || maxHeight == 0)
+  {
+    CLog::Log(LOGERROR, "GAME: Invalid max dimensions: {}x{}", maxWidth, maxHeight);
+    return nullptr;
+  }
+
+  if (nominalWidth > maxWidth || nominalHeight > maxHeight)
+    CLog::Log(LOGERROR, "GAME: Nominal dimensions ({}x{}) bigger than max dimensions ({}x{})",
+              nominalWidth, nominalHeight, maxWidth, maxHeight);
+
+  float pixelAspectRatio;
+
+  // Game API: If aspect_ratio is <= 0.0, an aspect ratio of
+  // (nominal_width / nominal_height) is assumed
+  if (properties.aspect_ratio <= 0.0f)
+    pixelAspectRatio = 1.0f;
+  else
+    pixelAspectRatio = properties.aspect_ratio * nominalHeight / nominalWidth;
+
+  return new RETRO::VideoStreamProperties{pixelFormat, nominalWidth, nominalHeight,
+                                          maxWidth,    maxHeight,    pixelAspectRatio};
+}
diff --git a/xbmc/games/addons/streams/GameClientStreamVideo.h b/xbmc/games/addons/streams/GameClientStreamVideo.h
new file mode 100644
index 0000000..4c90c2c
--- /dev/null
+++ b/xbmc/games/addons/streams/GameClientStreamVideo.h
@@ -0,0 +1,49 @@
+/*
+ *  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 "IGameClientStream.h"
+
+struct game_stream_video_properties;
+
+namespace KODI
+{
+namespace RETRO
+{
+class IRetroPlayerStream;
+struct VideoStreamProperties;
+} // namespace RETRO
+
+namespace GAME
+{
+
+class CGameClientStreamVideo : public IGameClientStream
+{
+public:
+  CGameClientStreamVideo() = default;
+  ~CGameClientStreamVideo() override { CloseStream(); }
+
+  // Implementation of IGameClientStream
+  bool OpenStream(RETRO::IRetroPlayerStream* stream,
+                  const game_stream_properties& properties) override;
+  void CloseStream() override;
+  void AddData(const game_stream_packet& packet) override;
+
+protected:
+  // Stream parameters
+  RETRO::IRetroPlayerStream* m_stream = nullptr;
+
+private:
+  // Utility functions
+  static RETRO::VideoStreamProperties* TranslateProperties(
+      const game_stream_video_properties& properties);
+};
+
+} // namespace GAME
+} // namespace KODI
diff --git a/xbmc/games/addons/streams/GameClientStreams.cpp b/xbmc/games/addons/streams/GameClientStreams.cpp
new file mode 100644
index 0000000..7d005ea
--- /dev/null
+++ b/xbmc/games/addons/streams/GameClientStreams.cpp
@@ -0,0 +1,118 @@
+/*
+ *  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 "GameClientStreams.h"
+
+#include "GameClientStreamAudio.h"
+#include "GameClientStreamSwFramebuffer.h"
+#include "GameClientStreamVideo.h"
+#include "cores/RetroPlayer/streams/IRetroPlayerStream.h"
+#include "cores/RetroPlayer/streams/IStreamManager.h"
+#include "cores/RetroPlayer/streams/RetroPlayerStreamTypes.h"
+#include "games/addons/GameClient.h"
+#include "games/addons/GameClientTranslator.h"
+#include "utils/log.h"
+
+#include <memory>
+
+using namespace KODI;
+using namespace GAME;
+
+CGameClientStreams::CGameClientStreams(CGameClient& gameClient) : m_gameClient(gameClient)
+{
+}
+
+void CGameClientStreams::Initialize(RETRO::IStreamManager& streamManager)
+{
+  m_streamManager = &streamManager;
+}
+
+void CGameClientStreams::Deinitialize()
+{
+  m_streamManager = nullptr;
+}
+
+IGameClientStream* CGameClientStreams::OpenStream(const game_stream_properties& properties)
+{
+  if (m_streamManager == nullptr)
+    return nullptr;
+
+  RETRO::StreamType retroStreamType;
+  if (!CGameClientTranslator::TranslateStreamType(properties.type, retroStreamType))
+  {
+    CLog::Log(LOGERROR, "GAME: Invalid stream type: {}", static_cast<int>(properties.type));
+    return nullptr;
+  }
+
+  std::unique_ptr<IGameClientStream> gameStream = CreateStream(properties.type);
+  if (!gameStream)
+  {
+    CLog::Log(LOGERROR, "GAME: No stream implementation for type: {}",
+              static_cast<int>(properties.type));
+    return nullptr;
+  }
+
+  RETRO::StreamPtr retroStream = m_streamManager->CreateStream(retroStreamType);
+  if (!retroStream)
+  {
+    CLog::Log(LOGERROR, "GAME:  Invalid RetroPlayer stream type: {}",
+              static_cast<int>(retroStreamType));
+    return nullptr;
+  }
+
+  if (!gameStream->OpenStream(retroStream.get(), properties))
+  {
+    CLog::Log(LOGERROR, "GAME: Failed to open audio stream");
+    return nullptr;
+  }
+
+  m_streams[gameStream.get()] = std::move(retroStream);
+
+  return gameStream.release();
+}
+
+void CGameClientStreams::CloseStream(IGameClientStream* stream)
+{
+  if (stream != nullptr)
+  {
+    std::unique_ptr<IGameClientStream> streamHolder(stream);
+    streamHolder->CloseStream();
+
+    m_streamManager->CloseStream(std::move(m_streams[stream]));
+    m_streams.erase(stream);
+  }
+}
+
+std::unique_ptr<IGameClientStream> CGameClientStreams::CreateStream(
+    GAME_STREAM_TYPE streamType) const
+{
+  std::unique_ptr<IGameClientStream> gameStream;
+
+  switch (streamType)
+  {
+    case GAME_STREAM_AUDIO:
+    {
+      gameStream.reset(new CGameClientStreamAudio(m_gameClient.GetSampleRate()));
+      break;
+    }
+    case GAME_STREAM_VIDEO:
+    {
+      gameStream.reset(new CGameClientStreamVideo);
+      break;
+    }
+    case GAME_STREAM_SW_FRAMEBUFFER:
+    {
+      gameStream.reset(new CGameClientStreamSwFramebuffer);
+      break;
+    }
+    default:
+      break;
+  }
+
+  return gameStream;
+}
diff --git a/xbmc/games/addons/streams/GameClientStreams.h b/xbmc/games/addons/streams/GameClientStreams.h
new file mode 100644
index 0000000..6f3f639
--- /dev/null
+++ b/xbmc/games/addons/streams/GameClientStreams.h
@@ -0,0 +1,55 @@
+/*
+ *  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 "addons/kodi-dev-kit/include/kodi/addon-instance/Game.h"
+#include "cores/RetroPlayer/streams/RetroPlayerStreamTypes.h"
+
+#include <map>
+
+namespace KODI
+{
+namespace RETRO
+{
+class IStreamManager;
+}
+
+namespace GAME
+{
+
+class CGameClient;
+class IGameClientStream;
+
+class CGameClientStreams
+{
+public:
+  CGameClientStreams(CGameClient& gameClient);
+
+  void Initialize(RETRO::IStreamManager& streamManager);
+  void Deinitialize();
+
+  IGameClientStream* OpenStream(const game_stream_properties& properties);
+  void CloseStream(IGameClientStream* stream);
+
+private:
+  // Utility functions
+  std::unique_ptr<IGameClientStream> CreateStream(GAME_STREAM_TYPE streamType) const;
+
+  // Construction parameters
+  CGameClient& m_gameClient;
+
+  // Initialization parameters
+  RETRO::IStreamManager* m_streamManager = nullptr;
+
+  // Stream parameters
+  std::map<IGameClientStream*, RETRO::StreamPtr> m_streams;
+};
+
+} // namespace GAME
+} // namespace KODI
diff --git a/xbmc/games/addons/streams/IGameClientStream.h b/xbmc/games/addons/streams/IGameClientStream.h
new file mode 100644
index 0000000..c2374bc
--- /dev/null
+++ b/xbmc/games/addons/streams/IGameClientStream.h
@@ -0,0 +1,77 @@
+/*
+ *  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
+
+struct game_stream_buffer;
+struct game_stream_packet;
+struct game_stream_properties;
+
+namespace KODI
+{
+namespace RETRO
+{
+class IRetroPlayerStream;
+}
+
+namespace GAME
+{
+
+class IGameClientStream
+{
+public:
+  virtual ~IGameClientStream() = default;
+
+  /*!
+   * \brief Open the stream
+   *
+   * \param stream The RetroPlayer resource to take ownership of
+   *
+   * \return True if the stream was opened, false otherwise
+   */
+  virtual bool OpenStream(RETRO::IRetroPlayerStream* stream,
+                          const game_stream_properties& properties) = 0;
+
+  /*!
+   * \brief Release the RetroPlayer stream resource
+   */
+  virtual void CloseStream() = 0;
+
+  /*!
+   * \brief Get a buffer for zero-copy stream data
+   *
+   * \param width The framebuffer width, or 0 for no width specified
+   * \param height The framebuffer height, or 0 for no height specified
+   * \param[out] buffer The buffer, or unmodified if false is returned
+   *
+   * If this returns true, buffer must be freed using ReleaseBuffer().
+   *
+   * \return True if buffer was set, false otherwise
+   */
+  virtual bool GetBuffer(unsigned int width, unsigned int height, game_stream_buffer& buffer)
+  {
+    return false;
+  }
+
+  /*!
+   * \brief Free an allocated buffer
+   *
+   * \param buffer The buffer returned from GetBuffer()
+   */
+  virtual void ReleaseBuffer(game_stream_buffer& buffer) {}
+
+  /*!
+   * \brief Add a data packet to a stream
+   *
+   * \param packet The data packet
+   */
+  virtual void AddData(const game_stream_packet& packet) = 0;
+};
+
+} // namespace GAME
+} // namespace KODI
diff --git a/xbmc/games/agents/CMakeLists.txt b/xbmc/games/agents/CMakeLists.txt
new file mode 100644
index 0000000..e66ee2f
--- /dev/null
+++ b/xbmc/games/agents/CMakeLists.txt
@@ -0,0 +1,7 @@
+set(SOURCES GameAgentManager.cpp
+)
+
+set(HEADERS GameAgentManager.h
+)
+
+core_add_library(games_agents)
diff --git a/xbmc/games/agents/GameAgentManager.cpp b/xbmc/games/agents/GameAgentManager.cpp
new file mode 100644
index 0000000..5b72fbf
--- /dev/null
+++ b/xbmc/games/agents/GameAgentManager.cpp
@@ -0,0 +1,547 @@
+/*
+ *  Copyright (C) 2017-2022 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 "GameAgentManager.h"
+
+#include "ServiceBroker.h"
+#include "games/addons/GameClient.h"
+#include "games/addons/input/GameClientInput.h"
+#include "games/addons/input/GameClientJoystick.h"
+#include "input/InputManager.h"
+#include "peripherals/EventLockHandle.h"
+#include "peripherals/Peripherals.h"
+#include "peripherals/devices/Peripheral.h"
+#include "peripherals/devices/PeripheralJoystick.h"
+#include "utils/log.h"
+
+#include <array>
+
+using namespace KODI;
+using namespace GAME;
+
+CGameAgentManager::CGameAgentManager(PERIPHERALS::CPeripherals& peripheralManager,
+                                     CInputManager& inputManager)
+  : m_peripheralManager(peripheralManager), m_inputManager(inputManager)
+{
+  // Register callbacks
+  m_peripheralManager.RegisterObserver(this);
+  m_inputManager.RegisterKeyboardDriverHandler(this);
+  m_inputManager.RegisterMouseDriverHandler(this);
+}
+
+CGameAgentManager::~CGameAgentManager()
+{
+  // Unregister callbacks in reverse order
+  m_inputManager.UnregisterMouseDriverHandler(this);
+  m_inputManager.UnregisterKeyboardDriverHandler(this);
+  m_peripheralManager.UnregisterObserver(this);
+}
+
+void CGameAgentManager::Start(GameClientPtr gameClient)
+{
+  // Initialize state
+  m_gameClient = std::move(gameClient);
+
+  // Register callbacks
+  if (m_gameClient)
+    m_gameClient->Input().RegisterObserver(this);
+}
+
+void CGameAgentManager::Stop()
+{
+  // Unregister callbacks in reverse order
+  if (m_gameClient)
+    m_gameClient->Input().UnregisterObserver(this);
+
+  // Close open joysticks
+  {
+    PERIPHERALS::EventLockHandlePtr inputHandlingLock;
+
+    for (const auto& [inputProvider, joystick] : m_portMap)
+    {
+      if (!inputHandlingLock)
+        inputHandlingLock = CServiceBroker::GetPeripherals().RegisterEventLock();
+
+      joystick->UnregisterInput(inputProvider);
+
+      SetChanged(true);
+    }
+
+    m_portMap.clear();
+    m_peripheralMap.clear();
+    m_disconnectedPeripherals.clear();
+  }
+
+  // Notify observers if anything changed
+  NotifyObservers(ObservableMessageGameAgentsChanged);
+
+  // Reset state
+  m_gameClient.reset();
+}
+
+void CGameAgentManager::Refresh()
+{
+  if (m_gameClient)
+  {
+    // Open keyboard
+    ProcessKeyboard();
+
+    // Open mouse
+    ProcessMouse();
+
+    // Open/close joysticks
+    PERIPHERALS::EventLockHandlePtr inputHandlingLock;
+    ProcessJoysticks(inputHandlingLock);
+  }
+
+  // Notify observers if anything changed
+  NotifyObservers(ObservableMessageGameAgentsChanged);
+}
+
+void CGameAgentManager::Notify(const Observable& obs, const ObservableMessage msg)
+{
+  switch (msg)
+  {
+    case ObservableMessageGamePortsChanged:
+    case ObservableMessagePeripheralsChanged:
+    {
+      Refresh();
+      break;
+    }
+    default:
+      break;
+  }
+}
+
+bool CGameAgentManager::OnKeyPress(const CKey& key)
+{
+  m_bHasKeyboard = true;
+  return false;
+}
+
+bool CGameAgentManager::OnPosition(int x, int y)
+{
+  m_bHasMouse = true;
+  return false;
+}
+
+bool CGameAgentManager::OnButtonPress(MOUSE::BUTTON_ID button)
+{
+  m_bHasMouse = true;
+  return false;
+}
+
+void CGameAgentManager::ProcessJoysticks(PERIPHERALS::EventLockHandlePtr& inputHandlingLock)
+{
+  // Get system joysticks.
+  //
+  // It's important to hold these shared pointers for the function scope
+  // because we call into the input handlers in m_portMap.
+  //
+  // The input handlers are upcasted from their peripheral object, so the
+  // peripheral object must persist through this function.
+  //
+  PERIPHERALS::PeripheralVector joysticks;
+  m_peripheralManager.GetPeripheralsWithFeature(joysticks, PERIPHERALS::FEATURE_JOYSTICK);
+
+  // Remove "virtual" Android joysticks
+  //
+  // The heuristic used to identify these is to check if the device name is all
+  // lowercase letters and dashes (and contains at least one dash). The
+  // following virtual devices have been observed:
+  //
+  //   shield-ask-remote
+  //   sunxi-ir-uinput
+  //   virtual-search
+  //
+  // Additionally, we specifically allow the following devices:
+  //
+  //   virtual-remote
+  //
+  joysticks.erase(
+      std::remove_if(joysticks.begin(), joysticks.end(),
+                     [](const PERIPHERALS::PeripheralPtr& joystick)
+                     {
+                       const std::string& joystickName = joystick->DeviceName();
+
+                       // Skip joysticks in the allowlist
+                       static const std::array<std::string, 1> peripheralAllowlist = {
+                           "virtual-remote",
+                       };
+                       if (std::find_if(peripheralAllowlist.begin(), peripheralAllowlist.end(),
+                                        [&joystickName](const std::string& allowedJoystick) {
+                                          return allowedJoystick == joystickName;
+                                        }) != peripheralAllowlist.end())
+                       {
+                         return false;
+                       }
+
+                       // Require at least one dash
+                       if (std::find_if(joystickName.begin(), joystickName.end(),
+                                        [](char c) { return c == '-'; }) == joystickName.end())
+                       {
+                         return false;
+                       }
+
+                       // Require all lowercase letters or dashes
+                       if (std::find_if(joystickName.begin(), joystickName.end(),
+                                        [](char c)
+                                        {
+                                          const bool isLowercase = ('a' <= c && c <= 'z');
+                                          const bool isDash = (c == '-');
+                                          return !(isLowercase || isDash);
+                                        }) != joystickName.end())
+                       {
+                         return false;
+                       }
+
+                       // Joystick matches the pattern, remove it
+                       return true;
+                     }),
+      joysticks.end());
+
+  // Update expired joysticks
+  UpdateExpiredJoysticks(joysticks, inputHandlingLock);
+
+  // Perform the port mapping
+  PortMap newPortMap =
+      MapJoysticks(joysticks, m_gameClient->Input().GetJoystickMap(), m_currentPorts,
+                   m_currentPeripherals, m_gameClient->Input().GetPlayerLimit());
+
+  // Update connected joysticks
+  std::set<PERIPHERALS::PeripheralPtr> disconnectedPeripherals;
+  UpdateConnectedJoysticks(joysticks, newPortMap, inputHandlingLock, disconnectedPeripherals);
+
+  // Rebuild peripheral map
+  PeripheralMap peripheralMap;
+  for (const auto& [inputProvider, joystick] : m_portMap)
+    peripheralMap[joystick->GetControllerAddress()] = joystick->GetSource();
+
+  // Log peripheral map if there were any changes
+  if (peripheralMap != m_peripheralMap || disconnectedPeripherals != m_disconnectedPeripherals)
+  {
+    m_peripheralMap = std::move(peripheralMap);
+    m_disconnectedPeripherals = std::move(disconnectedPeripherals);
+    LogPeripheralMap(m_peripheralMap, m_disconnectedPeripherals);
+  }
+}
+
+void CGameAgentManager::ProcessKeyboard()
+{
+  if (m_bHasKeyboard && m_gameClient->Input().SupportsKeyboard() &&
+      !m_gameClient->Input().IsKeyboardOpen())
+  {
+    PERIPHERALS::PeripheralVector keyboards;
+    CServiceBroker::GetPeripherals().GetPeripheralsWithFeature(keyboards,
+                                                               PERIPHERALS::FEATURE_KEYBOARD);
+    if (!keyboards.empty())
+    {
+      const CControllerTree& controllers = m_gameClient->Input().GetActiveControllerTree();
+
+      auto it = std::find_if(
+          controllers.GetPorts().begin(), controllers.GetPorts().end(),
+          [](const CPortNode& port) { return port.GetPortType() == PORT_TYPE::KEYBOARD; });
+
+      PERIPHERALS::PeripheralPtr keyboard = std::move(keyboards.at(0));
+      m_gameClient->Input().OpenKeyboard(it->GetActiveController().GetController(), keyboard);
+
+      SetChanged(true);
+    }
+  }
+}
+
+void CGameAgentManager::ProcessMouse()
+{
+  if (m_bHasMouse && m_gameClient->Input().SupportsMouse() && !m_gameClient->Input().IsMouseOpen())
+  {
+    PERIPHERALS::PeripheralVector mice;
+    CServiceBroker::GetPeripherals().GetPeripheralsWithFeature(mice, PERIPHERALS::FEATURE_MOUSE);
+    if (!mice.empty())
+    {
+      const CControllerTree& controllers = m_gameClient->Input().GetActiveControllerTree();
+
+      auto it = std::find_if(
+          controllers.GetPorts().begin(), controllers.GetPorts().end(),
+          [](const CPortNode& port) { return port.GetPortType() == PORT_TYPE::MOUSE; });
+
+      PERIPHERALS::PeripheralPtr mouse = std::move(mice.at(0));
+      m_gameClient->Input().OpenMouse(it->GetActiveController().GetController(), mouse);
+
+      SetChanged(true);
+    }
+  }
+}
+
+void CGameAgentManager::UpdateExpiredJoysticks(const PERIPHERALS::PeripheralVector& joysticks,
+                                               PERIPHERALS::EventLockHandlePtr& inputHandlingLock)
+{
+  // Make a copy - expired joysticks are removed from m_portMap
+  PortMap portMapCopy = m_portMap;
+
+  for (const auto& [inputProvider, joystick] : portMapCopy)
+  {
+    // Structured binding cannot be captured, so make a copy
+    JOYSTICK::IInputProvider* const inputProviderCopy = inputProvider;
+
+    // Search peripheral vector for input provider
+    auto it2 = std::find_if(joysticks.begin(), joysticks.end(),
+                            [inputProviderCopy](const PERIPHERALS::PeripheralPtr& joystick) {
+                              // Upcast peripheral to input interface
+                              JOYSTICK::IInputProvider* peripheralInput = joystick.get();
+
+                              // Compare
+                              return inputProviderCopy == peripheralInput;
+                            });
+
+    // If peripheral wasn't found, then it was disconnected
+    const bool bDisconnected = (it2 == joysticks.end());
+
+    // Erase joystick from port map if its peripheral becomes disconnected
+    if (bDisconnected)
+    {
+      // Must use nullptr because peripheral has likely fallen out of scope,
+      // destroying the object
+      joystick->UnregisterInput(nullptr);
+
+      if (!inputHandlingLock)
+        inputHandlingLock = CServiceBroker::GetPeripherals().RegisterEventLock();
+      m_portMap.erase(inputProvider);
+
+      SetChanged(true);
+    }
+  }
+}
+
+void CGameAgentManager::UpdateConnectedJoysticks(
+    const PERIPHERALS::PeripheralVector& joysticks,
+    const PortMap& newPortMap,
+    PERIPHERALS::EventLockHandlePtr& inputHandlingLock,
+    std::set<PERIPHERALS::PeripheralPtr>& disconnectedPeripherals)
+{
+  for (auto& peripheralJoystick : joysticks)
+  {
+    // Upcast peripheral to input interface
+    JOYSTICK::IInputProvider* inputProvider = peripheralJoystick.get();
+
+    // Get connection states
+    auto itConnectedPort = newPortMap.find(inputProvider);
+    auto itDisconnectedPort = m_portMap.find(inputProvider);
+
+    // Get possibly connected joystick
+    std::shared_ptr<CGameClientJoystick> newJoystick;
+    if (itConnectedPort != newPortMap.end())
+      newJoystick = itConnectedPort->second;
+
+    // Get possibly disconnected joystick
+    std::shared_ptr<CGameClientJoystick> oldJoystick;
+    if (itDisconnectedPort != m_portMap.end())
+      oldJoystick = itDisconnectedPort->second;
+
+    // Check for a change in joysticks
+    if (oldJoystick != newJoystick)
+    {
+      // Unregister old input handler
+      if (oldJoystick != nullptr)
+      {
+        oldJoystick->UnregisterInput(inputProvider);
+
+        if (!inputHandlingLock)
+          inputHandlingLock = CServiceBroker::GetPeripherals().RegisterEventLock();
+        m_portMap.erase(itDisconnectedPort);
+
+        SetChanged(true);
+      }
+
+      // Register new handler
+      if (newJoystick != nullptr)
+      {
+        newJoystick->RegisterInput(inputProvider);
+
+        m_portMap[inputProvider] = std::move(newJoystick);
+
+        SetChanged(true);
+      }
+    }
+  }
+
+  // Record disconnected peripherals
+  for (const auto& peripheral : joysticks)
+  {
+    // Upcast peripheral to input interface
+    JOYSTICK::IInputProvider* inputProvider = peripheral.get();
+
+    // Check if peripheral is disconnected
+    if (m_portMap.find(inputProvider) == m_portMap.end())
+      disconnectedPeripherals.emplace(peripheral);
+  }
+}
+
+CGameAgentManager::PortMap CGameAgentManager::MapJoysticks(
+    const PERIPHERALS::PeripheralVector& peripheralJoysticks,
+    const JoystickMap& gameClientjoysticks,
+    CurrentPortMap& currentPorts,
+    CurrentPeripheralMap& currentPeripherals,
+    int playerLimit)
+{
+  PortMap result;
+
+  // First, create a map of the current ports to attempt to preserve
+  // player numbers
+  for (const auto& [portAddress, joystick] : gameClientjoysticks)
+  {
+    std::string sourceLocation = joystick->GetSourceLocation();
+    if (!sourceLocation.empty())
+      currentPorts[portAddress] = std::move(sourceLocation);
+  }
+
+  // Allow reverse lookups by peripheral location
+  for (const auto& [portAddress, sourceLocation] : currentPorts)
+    currentPeripherals[sourceLocation] = portAddress;
+
+  // Next, create a list of joystick peripherals sorted by order of last
+  // button press. Joysticks without a current port are assigned in this
+  // order.
+  PERIPHERALS::PeripheralVector availableJoysticks = peripheralJoysticks;
+  std::sort(availableJoysticks.begin(), availableJoysticks.end(),
+            [](const PERIPHERALS::PeripheralPtr& lhs, const PERIPHERALS::PeripheralPtr& rhs) {
+              if (lhs->LastActive().IsValid() && !rhs->LastActive().IsValid())
+                return true;
+              if (!lhs->LastActive().IsValid() && rhs->LastActive().IsValid())
+                return false;
+
+              return lhs->LastActive() > rhs->LastActive();
+            });
+
+  // Loop through the active ports and assign joysticks
+  unsigned int iJoystick = 0;
+  for (const auto& [portAddress, gameClientJoystick] : gameClientjoysticks)
+  {
+    const unsigned int joystickCount = ++iJoystick;
+
+    // Check if we're out of joystick peripherals or over the topology limit
+    if (availableJoysticks.empty() ||
+        (playerLimit >= 0 && static_cast<int>(joystickCount) > playerLimit))
+    {
+      gameClientJoystick->ClearSource();
+      continue;
+    }
+
+    PERIPHERALS::PeripheralVector::iterator itJoystick = availableJoysticks.end();
+
+    // Attempt to preserve player numbers
+    auto itCurrentPort = currentPorts.find(portAddress);
+    if (itCurrentPort != currentPorts.end())
+    {
+      const PeripheralLocation& currentPeripheral = itCurrentPort->second;
+
+      // Find peripheral with matching source location
+      itJoystick = std::find_if(availableJoysticks.begin(), availableJoysticks.end(),
+                                [&currentPeripheral](const PERIPHERALS::PeripheralPtr& joystick) {
+                                  return joystick->Location() == currentPeripheral;
+                                });
+    }
+
+    if (itJoystick == availableJoysticks.end())
+    {
+      // Get the next most recently active joystick that doesn't have a current port
+      itJoystick = std::find_if(
+          availableJoysticks.begin(), availableJoysticks.end(),
+          [&currentPeripherals, &gameClientjoysticks](const PERIPHERALS::PeripheralPtr& joystick) {
+            const PeripheralLocation& joystickLocation = joystick->Location();
+
+            // If joystick doesn't have a current port, use it
+            auto itPeripheral = currentPeripherals.find(joystickLocation);
+            if (itPeripheral == currentPeripherals.end())
+              return true;
+
+            // Get the address of the last port this joystick was connected to
+            const PortAddress& portAddress = itPeripheral->second;
+
+            // If port is disconnected, use this joystick
+            if (gameClientjoysticks.find(portAddress) == gameClientjoysticks.end())
+              return true;
+
+            return false;
+          });
+    }
+
+    // If found, assign the port and remove from the lists
+    if (itJoystick != availableJoysticks.end())
+    {
+      // Dereference iterator
+      PERIPHERALS::PeripheralPtr peripheralJoystick = *itJoystick;
+
+      // Map joystick
+      MapJoystick(std::move(peripheralJoystick), gameClientJoystick, result);
+
+      // Remove from availableJoysticks list
+      availableJoysticks.erase(itJoystick);
+    }
+    else
+    {
+      // No joystick found, clear the port
+      gameClientJoystick->ClearSource();
+    }
+  }
+
+  return result;
+}
+
+void CGameAgentManager::MapJoystick(PERIPHERALS::PeripheralPtr peripheralJoystick,
+                                    std::shared_ptr<CGameClientJoystick> gameClientJoystick,
+                                    PortMap& result)
+{
+  // Upcast peripheral joystick to input provider
+  JOYSTICK::IInputProvider* inputProvider = peripheralJoystick.get();
+
+  // Update game joystick's source peripheral
+  gameClientJoystick->SetSource(std::move(peripheralJoystick));
+
+  // Map input provider to input handler
+  result[inputProvider] = std::move(gameClientJoystick);
+}
+
+void CGameAgentManager::LogPeripheralMap(
+    const PeripheralMap& peripheralMap,
+    const std::set<PERIPHERALS::PeripheralPtr>& disconnectedPeripherals)
+{
+  CLog::Log(LOGDEBUG, "===== Peripheral Map =====");
+
+  unsigned int line = 0;
+
+  if (!peripheralMap.empty())
+  {
+    for (const auto& [controllerAddress, peripheral] : peripheralMap)
+    {
+      if (line != 0)
+        CLog::Log(LOGDEBUG, "");
+      CLog::Log(LOGDEBUG, "{}:", controllerAddress);
+      CLog::Log(LOGDEBUG, "    {} [{}]", peripheral->Location(), peripheral->DeviceName());
+
+      ++line;
+    }
+  }
+
+  if (!disconnectedPeripherals.empty())
+  {
+    if (line != 0)
+      CLog::Log(LOGDEBUG, "");
+    CLog::Log(LOGDEBUG, "Disconnected:");
+
+    // Sort by peripheral location
+    std::map<std::string, std::string> disconnectedPeripheralMap;
+    for (const auto& peripheral : disconnectedPeripherals)
+      disconnectedPeripheralMap[peripheral->Location()] = peripheral->DeviceName();
+
+    // Log location and device name for disconnected peripherals
+    for (const auto& [location, deviceName] : disconnectedPeripheralMap)
+      CLog::Log(LOGDEBUG, "    {} [{}]", location, deviceName);
+  }
+
+  CLog::Log(LOGDEBUG, "==========================");
+}
diff --git a/xbmc/games/agents/GameAgentManager.h b/xbmc/games/agents/GameAgentManager.h
new file mode 100644
index 0000000..901a492
--- /dev/null
+++ b/xbmc/games/agents/GameAgentManager.h
@@ -0,0 +1,171 @@
+/*
+ *  Copyright (C) 2017-2022 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/GameTypes.h"
+#include "input/keyboard/interfaces/IKeyboardDriverHandler.h"
+#include "input/mouse/interfaces/IMouseDriverHandler.h"
+#include "peripherals/PeripheralTypes.h"
+#include "utils/Observer.h"
+
+#include <map>
+#include <memory>
+#include <set>
+#include <string>
+
+class CInputManager;
+
+namespace PERIPHERALS
+{
+class CPeripheral;
+class CPeripherals;
+} // namespace PERIPHERALS
+
+namespace KODI
+{
+namespace JOYSTICK
+{
+class IInputProvider;
+}
+
+namespace GAME
+{
+class CGameAgent;
+class CGameClient;
+class CGameClientJoystick;
+
+/*!
+ * \brief Class to manage game-playing agents for a running game client
+ *
+ * Currently, port mapping is controller-based and does not take into account
+ * the human belonging to the controller. In the future, humans and possibly
+ * bots will be managed here.
+ *
+ * To map ports to controllers, a list of controllers is retrieved in
+ * ProcessJoysticks(). After expired controllers are removed, the port mapping
+ * occurs in the static function MapJoysticks(). The strategy is to simply
+ * sort controllers by heuristics and greedily assign to game ports.
+ */
+class CGameAgentManager : public Observable,
+                          public Observer,
+                          KEYBOARD::IKeyboardDriverHandler,
+                          MOUSE::IMouseDriverHandler
+{
+public:
+  CGameAgentManager(PERIPHERALS::CPeripherals& peripheralManager, CInputManager& inputManager);
+
+  virtual ~CGameAgentManager();
+
+  // Lifecycle functions
+  void Start(GameClientPtr gameClient);
+  void Stop();
+  void Refresh();
+
+  // Implementation of Observer
+  void Notify(const Observable& obs, const ObservableMessage msg) override;
+
+  // Implementation of IKeyboardDriverHandler
+  bool OnKeyPress(const CKey& key) override;
+  void OnKeyRelease(const CKey& key) override {}
+
+  // Implementation of IMouseDriverHandler
+  bool OnPosition(int x, int y) override;
+  bool OnButtonPress(MOUSE::BUTTON_ID button) override;
+  void OnButtonRelease(MOUSE::BUTTON_ID button) override {}
+
+private:
+  //! @todo De-duplicate these types
+  using PortAddress = std::string;
+  using JoystickMap = std::map<PortAddress, std::shared_ptr<CGameClientJoystick>>;
+  using PortMap = std::map<JOYSTICK::IInputProvider*, std::shared_ptr<CGameClientJoystick>>;
+
+  using PeripheralLocation = std::string;
+  using CurrentPortMap = std::map<PortAddress, PeripheralLocation>;
+  using CurrentPeripheralMap = std::map<PeripheralLocation, PortAddress>;
+
+  using ControllerAddress = std::string;
+  using PeripheralMap = std::map<ControllerAddress, PERIPHERALS::PeripheralPtr>;
+
+  // Internal interface
+  void ProcessJoysticks(PERIPHERALS::EventLockHandlePtr& inputHandlingLock);
+  void ProcessKeyboard();
+  void ProcessMouse();
+
+  // Internal helpers
+  void UpdateExpiredJoysticks(const PERIPHERALS::PeripheralVector& joysticks,
+                              PERIPHERALS::EventLockHandlePtr& inputHandlingLock);
+  void UpdateConnectedJoysticks(const PERIPHERALS::PeripheralVector& joysticks,
+                                const PortMap& newPortMap,
+                                PERIPHERALS::EventLockHandlePtr& inputHandlingLock,
+                                std::set<PERIPHERALS::PeripheralPtr>& disconnectedJoysticks);
+
+  // Static functionals
+  static PortMap MapJoysticks(const PERIPHERALS::PeripheralVector& peripheralJoysticks,
+                              const JoystickMap& gameClientjoysticks,
+                              CurrentPortMap& currentPorts,
+                              CurrentPeripheralMap& currentPeripherals,
+                              int playerLimit);
+  static void MapJoystick(PERIPHERALS::PeripheralPtr peripheralJoystick,
+                          std::shared_ptr<CGameClientJoystick> gameClientJoystick,
+                          PortMap& result);
+  static void LogPeripheralMap(const PeripheralMap& peripheralMap,
+                               const std::set<PERIPHERALS::PeripheralPtr>& disconnectedPeripherals);
+
+  // Construction parameters
+  PERIPHERALS::CPeripherals& m_peripheralManager;
+  CInputManager& m_inputManager;
+
+  // State parameters
+  GameClientPtr m_gameClient;
+  bool m_bHasKeyboard = false;
+  bool m_bHasMouse = false;
+
+  /*!
+   * \brief Map of input provider to joystick handler
+   *
+   * The input provider is a handle to agent input.
+   *
+   * The joystick handler connects to joystick input of the game client.
+   *
+   * This property remembers which joysticks are actually being controlled by
+   * agents.
+   *
+   * Not exposed to the game.
+   */
+  PortMap m_portMap;
+
+  /*!
+   * \brief Map of the current ports to their peripheral
+   *
+   * This allows attempt to preserve player numbers.
+   */
+  CurrentPortMap m_currentPorts;
+
+  /*!
+   * \brief Map of the current peripherals to their port
+   *
+   * This allows attempt to preserve player numbers.
+   */
+  CurrentPeripheralMap m_currentPeripherals;
+
+  /*!
+   * Map of controller address to source peripheral
+   *
+   * Source peripherals are not exposed to the game.
+   */
+  PeripheralMap m_peripheralMap;
+
+  /*!
+   * Collection of disconnected joysticks
+   *
+   * Source peripherals are not exposed to the game.
+   */
+  std::set<PERIPHERALS::PeripheralPtr> m_disconnectedPeripherals;
+};
+} // namespace GAME
+} // namespace KODI
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
diff --git a/xbmc/games/dialogs/CMakeLists.txt b/xbmc/games/dialogs/CMakeLists.txt
new file mode 100644
index 0000000..d6c9a16
--- /dev/null
+++ b/xbmc/games/dialogs/CMakeLists.txt
@@ -0,0 +1,10 @@
+set(SOURCES GUIDialogSelectGameClient.cpp
+            GUIDialogSelectSavestate.cpp
+)
+
+set(HEADERS DialogGameDefines.h
+            GUIDialogSelectGameClient.h
+            GUIDialogSelectSavestate.h
+)
+
+core_add_library(gamedialogs)
diff --git a/xbmc/games/dialogs/DialogGameDefines.h b/xbmc/games/dialogs/DialogGameDefines.h
new file mode 100644
index 0000000..60dc99d
--- /dev/null
+++ b/xbmc/games/dialogs/DialogGameDefines.h
@@ -0,0 +1,27 @@
+/*
+ *  Copyright (C) 2020-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
+
+// Name of list item property for savestate captions
+constexpr auto SAVESTATE_LABEL = "savestate.label";
+constexpr auto SAVESTATE_CAPTION = "savestate.caption";
+constexpr auto SAVESTATE_GAME_CLIENT = "savestate.gameclient";
+
+// Control IDs for game dialogs
+constexpr unsigned int CONTROL_VIDEO_HEADING = 10810;
+constexpr unsigned int CONTROL_VIDEO_THUMBS = 10811;
+constexpr unsigned int CONTROL_VIDEO_DESCRIPTION = 10812;
+constexpr unsigned int CONTROL_SAVES_HEADING = 10820;
+constexpr unsigned int CONTROL_SAVES_DETAILED_LIST = 3; // Select dialog defaults to this control ID
+constexpr unsigned int CONTROL_SAVES_DESCRIPTION = 10822;
+constexpr unsigned int CONTROL_SAVES_EMULATOR_NAME = 10823;
+constexpr unsigned int CONTROL_SAVES_EMULATOR_ICON = 10824;
+constexpr unsigned int CONTROL_SAVES_NEW_BUTTON = 10825;
+constexpr unsigned int CONTROL_SAVES_CANCEL_BUTTON = 10826;
+constexpr unsigned int CONTROL_NUMBER_OF_ITEMS = 10827;
diff --git a/xbmc/games/dialogs/GUIDialogSelectGameClient.cpp b/xbmc/games/dialogs/GUIDialogSelectGameClient.cpp
new file mode 100644
index 0000000..e17bc27
--- /dev/null
+++ b/xbmc/games/dialogs/GUIDialogSelectGameClient.cpp
@@ -0,0 +1,121 @@
+/*
+ *  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 "GUIDialogSelectGameClient.h"
+
+#include "FileItem.h"
+#include "dialogs/GUIDialogSelect.h"
+#include "filesystem/AddonsDirectory.h"
+#include "games/addons/GameClient.h"
+#include "guilib/GUIComponent.h"
+#include "guilib/GUIWindowManager.h"
+#include "guilib/LocalizeStrings.h"
+#include "guilib/WindowIDs.h"
+#include "utils/StringUtils.h"
+#include "utils/URIUtils.h"
+#include "utils/log.h"
+
+using namespace KODI;
+using namespace KODI::MESSAGING;
+using namespace GAME;
+
+std::string CGUIDialogSelectGameClient::ShowAndGetGameClient(const std::string& gamePath,
+                                                             const GameClientVector& candidates,
+                                                             const GameClientVector& installable)
+{
+  std::string gameClient;
+
+  LogGameClients(candidates, installable);
+
+  std::string extension = URIUtils::GetExtension(gamePath);
+
+  // "Select emulator for {0:s}"
+  CGUIDialogSelect* dialog =
+      GetDialog(StringUtils::Format(g_localizeStrings.Get(35258), extension));
+  if (dialog != nullptr)
+  {
+    // Turn the addons into items
+    CFileItemList items;
+    CFileItemList installableItems;
+    for (const auto& candidate : candidates)
+    {
+      CFileItemPtr item(XFILE::CAddonsDirectory::FileItemFromAddon(candidate, candidate->ID()));
+      item->SetLabel2(g_localizeStrings.Get(35257)); // "Installed"
+      items.Add(std::move(item));
+    }
+    for (const auto& addon : installable)
+    {
+      CFileItemPtr item(XFILE::CAddonsDirectory::FileItemFromAddon(addon, addon->ID()));
+      installableItems.Add(std::move(item));
+    }
+    items.Sort(SortByLabel, SortOrderAscending);
+    installableItems.Sort(SortByLabel, SortOrderAscending);
+
+    items.Append(installableItems);
+
+    dialog->SetItems(items);
+
+    dialog->Open();
+
+    // If the "Get More" button has been pressed, show a list of installable addons
+    if (dialog->IsConfirmed())
+    {
+      int selectedIndex = dialog->GetSelectedItem();
+
+      if (0 <= selectedIndex && selectedIndex < items.Size())
+      {
+        gameClient = items[selectedIndex]->GetPath();
+
+        CLog::Log(LOGDEBUG, "Select game client dialog: User selected emulator {}", gameClient);
+      }
+      else
+      {
+        CLog::Log(LOGDEBUG, "Select game client dialog: User selected invalid emulator {}",
+                  selectedIndex);
+      }
+    }
+    else
+    {
+      CLog::Log(LOGDEBUG, "Select game client dialog: User cancelled game client installation");
+    }
+  }
+
+  return gameClient;
+}
+
+CGUIDialogSelect* CGUIDialogSelectGameClient::GetDialog(const std::string& title)
+{
+  CGUIDialogSelect* dialog =
+      CServiceBroker::GetGUI()->GetWindowManager().GetWindow<CGUIDialogSelect>(
+          WINDOW_DIALOG_SELECT);
+  if (dialog != nullptr)
+  {
+    dialog->Reset();
+    dialog->SetHeading(CVariant{title});
+    dialog->SetUseDetails(true);
+  }
+
+  return dialog;
+}
+
+void CGUIDialogSelectGameClient::LogGameClients(const GameClientVector& candidates,
+                                                const GameClientVector& installable)
+{
+  CLog::Log(LOGDEBUG, "Select game client dialog: Found {} candidates",
+            static_cast<unsigned int>(candidates.size()));
+  for (const auto& gameClient : candidates)
+    CLog::Log(LOGDEBUG, "Adding {} as a candidate", gameClient->ID());
+
+  if (!installable.empty())
+  {
+    CLog::Log(LOGDEBUG, "Select game client dialog: Found {} installable clients",
+              static_cast<unsigned int>(installable.size()));
+    for (const auto& gameClient : installable)
+      CLog::Log(LOGDEBUG, "Adding {} as an installable client", gameClient->ID());
+  }
+}
diff --git a/xbmc/games/dialogs/GUIDialogSelectGameClient.h b/xbmc/games/dialogs/GUIDialogSelectGameClient.h
new file mode 100644
index 0000000..c492481
--- /dev/null
+++ b/xbmc/games/dialogs/GUIDialogSelectGameClient.h
@@ -0,0 +1,61 @@
+/*
+ *  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/GameTypes.h"
+
+#include <string>
+
+class CGUIDialogSelect;
+
+namespace KODI
+{
+namespace GAME
+{
+class CGUIDialogSelectGameClient
+{
+public:
+  /*!
+   * \brief Show a series of dialogs that results in a game client being
+   *        selected
+   *
+   * \param gamePath    The path of the file being played
+   * \param candidates  A list of installed candidates that the user can
+   *                    select from
+   * \param installable A list of installable candidates that the user can
+   *                    select from
+   *
+   * \return The ID of the selected game client, or empty if no game client
+   *         was selected
+   */
+  static std::string ShowAndGetGameClient(const std::string& gamePath,
+                                          const GameClientVector& candidates,
+                                          const GameClientVector& installable);
+
+private:
+  /*!
+   * \brief Get an initialized select dialog
+   *
+   * \param title The title of the select dialog
+   *
+   * \return A select dialog with its properties initialized, or nullptr if
+   *         the dialog isn't found
+   */
+  static CGUIDialogSelect* GetDialog(const std::string& title);
+
+  /*!
+   * \brief Log the candidates and installable game clients
+   *
+   * Other than logging, this has no side effects.
+   */
+  static void LogGameClients(const GameClientVector& candidates,
+                             const GameClientVector& installable);
+};
+} // namespace GAME
+} // namespace KODI
diff --git a/xbmc/games/dialogs/GUIDialogSelectSavestate.cpp b/xbmc/games/dialogs/GUIDialogSelectSavestate.cpp
new file mode 100644
index 0000000..d56b1f4
--- /dev/null
+++ b/xbmc/games/dialogs/GUIDialogSelectSavestate.cpp
@@ -0,0 +1,58 @@
+/*
+ *  Copyright (C) 2020-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 "GUIDialogSelectSavestate.h"
+
+#include "ServiceBroker.h"
+#include "games/dialogs/osd/DialogGameSaves.h"
+#include "guilib/GUIComponent.h"
+#include "guilib/GUIWindowManager.h"
+#include "utils/log.h"
+
+using namespace KODI;
+using namespace GAME;
+
+bool CGUIDialogSelectSavestate::ShowAndGetSavestate(const std::string& gamePath,
+                                                    std::string& savestatePath)
+{
+  savestatePath = "";
+
+  // Can't ask the user if there's no dialog
+  CDialogGameSaves* dialog = GetDialog();
+  if (dialog == nullptr)
+    return true;
+
+  if (!dialog->Open(gamePath))
+    return true;
+
+  if (dialog->IsConfirmed())
+  {
+    savestatePath = dialog->GetSelectedItemPath();
+    return true;
+  }
+  else if (dialog->IsNewPressed())
+  {
+    CLog::Log(LOGDEBUG, "Select savestate dialog: New savestate selected");
+    return true;
+  }
+
+  // User canceled the dialog
+  return false;
+}
+
+CDialogGameSaves* CGUIDialogSelectSavestate::GetDialog()
+{
+  CDialogGameSaves* dialog =
+      CServiceBroker::GetGUI()->GetWindowManager().GetWindow<CDialogGameSaves>(
+          WINDOW_DIALOG_GAME_SAVES);
+
+  if (dialog != nullptr)
+    dialog->Reset();
+
+  return dialog;
+}
diff --git a/xbmc/games/dialogs/GUIDialogSelectSavestate.h b/xbmc/games/dialogs/GUIDialogSelectSavestate.h
new file mode 100644
index 0000000..e554142
--- /dev/null
+++ b/xbmc/games/dialogs/GUIDialogSelectSavestate.h
@@ -0,0 +1,28 @@
+/*
+ *  Copyright (C) 2020-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 <string>
+
+namespace KODI
+{
+namespace GAME
+{
+class CDialogGameSaves;
+
+class CGUIDialogSelectSavestate
+{
+public:
+  static bool ShowAndGetSavestate(const std::string& gamePath, std::string& savestatePath);
+
+private:
+  static CDialogGameSaves* GetDialog();
+};
+} // namespace GAME
+} // namespace KODI
diff --git a/xbmc/games/dialogs/osd/CMakeLists.txt b/xbmc/games/dialogs/osd/CMakeLists.txt
new file mode 100644
index 0000000..3f7f5bd
--- /dev/null
+++ b/xbmc/games/dialogs/osd/CMakeLists.txt
@@ -0,0 +1,25 @@
+set(SOURCES DialogGameAdvancedSettings.cpp
+            DialogGameOSD.cpp
+            DialogGameOSDHelp.cpp
+            DialogGameSaves.cpp
+            DialogGameStretchMode.cpp
+            DialogGameVideoFilter.cpp
+            DialogGameVideoRotation.cpp
+            DialogGameVideoSelect.cpp
+            DialogGameVolume.cpp
+            DialogInGameSaves.cpp
+)
+
+set(HEADERS DialogGameAdvancedSettings.h
+            DialogGameOSD.h
+            DialogGameOSDHelp.h
+            DialogGameSaves.h
+            DialogGameStretchMode.h
+            DialogGameVideoFilter.h
+            DialogGameVideoRotation.h
+            DialogGameVideoSelect.h
+            DialogGameVolume.h
+            DialogInGameSaves.h
+)
+
+core_add_library(gameosddialogs)
diff --git a/xbmc/games/dialogs/osd/DialogGameAdvancedSettings.cpp b/xbmc/games/dialogs/osd/DialogGameAdvancedSettings.cpp
new file mode 100644
index 0000000..83b7a3f
--- /dev/null
+++ b/xbmc/games/dialogs/osd/DialogGameAdvancedSettings.cpp
@@ -0,0 +1,54 @@
+/*
+ *  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 "DialogGameAdvancedSettings.h"
+
+#include "ServiceBroker.h"
+#include "addons/AddonManager.h"
+#include "addons/addoninfo/AddonType.h"
+#include "addons/gui/GUIDialogAddonSettings.h"
+#include "cores/RetroPlayer/guibridge/GUIGameRenderManager.h"
+#include "cores/RetroPlayer/guibridge/GUIGameSettingsHandle.h"
+#include "guilib/GUIMessage.h"
+#include "guilib/WindowIDs.h"
+
+using namespace KODI;
+using namespace GAME;
+
+CDialogGameAdvancedSettings::CDialogGameAdvancedSettings()
+  : CGUIDialog(WINDOW_DIALOG_GAME_ADVANCED_SETTINGS, "")
+{
+}
+
+bool CDialogGameAdvancedSettings::OnMessage(CGUIMessage& message)
+{
+  switch (message.GetMessage())
+  {
+    case GUI_MSG_WINDOW_INIT:
+    {
+      auto gameSettingsHandle = CServiceBroker::GetGameRenderManager().RegisterGameSettingsDialog();
+      if (gameSettingsHandle)
+      {
+        ADDON::AddonPtr addon;
+        if (CServiceBroker::GetAddonMgr().GetAddon(gameSettingsHandle->GameClientID(), addon,
+                                                   ADDON::AddonType::GAMEDLL,
+                                                   ADDON::OnlyEnabled::CHOICE_YES))
+        {
+          gameSettingsHandle.reset();
+          CGUIDialogAddonSettings::ShowForAddon(addon);
+        }
+      }
+
+      return false;
+    }
+    default:
+      break;
+  }
+
+  return CGUIDialog::OnMessage(message);
+}
diff --git a/xbmc/games/dialogs/osd/DialogGameAdvancedSettings.h b/xbmc/games/dialogs/osd/DialogGameAdvancedSettings.h
new file mode 100644
index 0000000..00b669b
--- /dev/null
+++ b/xbmc/games/dialogs/osd/DialogGameAdvancedSettings.h
@@ -0,0 +1,27 @@
+/*
+ *  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 "guilib/GUIDialog.h"
+
+namespace KODI
+{
+namespace GAME
+{
+class CDialogGameAdvancedSettings : public CGUIDialog
+{
+public:
+  CDialogGameAdvancedSettings();
+  ~CDialogGameAdvancedSettings() override = default;
+
+  // implementation of CGUIControl via CGUIDialog
+  bool OnMessage(CGUIMessage& message) override;
+};
+} // namespace GAME
+} // namespace KODI
diff --git a/xbmc/games/dialogs/osd/DialogGameOSD.cpp b/xbmc/games/dialogs/osd/DialogGameOSD.cpp
new file mode 100644
index 0000000..3a0eb52
--- /dev/null
+++ b/xbmc/games/dialogs/osd/DialogGameOSD.cpp
@@ -0,0 +1,81 @@
+/*
+ *  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 "DialogGameOSD.h"
+
+#include "DialogGameOSDHelp.h"
+#include "ServiceBroker.h"
+#include "games/GameServices.h"
+#include "games/GameSettings.h"
+#include "guilib/WindowIDs.h"
+#include "input/actions/Action.h"
+#include "input/actions/ActionIDs.h"
+
+using namespace KODI;
+using namespace GAME;
+
+CDialogGameOSD::CDialogGameOSD()
+  : CGUIDialog(WINDOW_DIALOG_GAME_OSD, "GameOSD.xml"), m_helpDialog(new CDialogGameOSDHelp(*this))
+{
+  // Initialize CGUIWindow
+  m_loadType = KEEP_IN_MEMORY;
+}
+
+bool CDialogGameOSD::OnAction(const CAction& action)
+{
+  switch (action.GetID())
+  {
+    case ACTION_PARENT_DIR:
+    case ACTION_PREVIOUS_MENU:
+    case ACTION_NAV_BACK:
+    case ACTION_SHOW_OSD:
+    case ACTION_PLAYER_PLAY:
+    {
+      // Disable OSD help if visible
+      if (m_helpDialog->IsVisible() && CServiceBroker::IsServiceManagerUp())
+      {
+        GAME::CGameSettings& gameSettings = CServiceBroker::GetGameServices().GameSettings();
+        if (gameSettings.ShowOSDHelp())
+        {
+          gameSettings.SetShowOSDHelp(false);
+          return true;
+        }
+      }
+      break;
+    }
+    default:
+      break;
+  }
+
+  return CGUIDialog::OnAction(action);
+}
+
+void CDialogGameOSD::OnInitWindow()
+{
+  // Init parent class
+  CGUIDialog::OnInitWindow();
+
+  // Init help dialog
+  m_helpDialog->OnInitWindow();
+}
+
+void CDialogGameOSD::OnDeinitWindow(int nextWindowID)
+{
+  CGUIDialog::OnDeinitWindow(nextWindowID);
+
+  if (CServiceBroker::IsServiceManagerUp())
+  {
+    GAME::CGameSettings& gameSettings = CServiceBroker::GetGameServices().GameSettings();
+    gameSettings.SetShowOSDHelp(false);
+  }
+}
+
+bool CDialogGameOSD::PlayInBackground(int dialogId)
+{
+  return dialogId == WINDOW_DIALOG_GAME_VOLUME;
+}
diff --git a/xbmc/games/dialogs/osd/DialogGameOSD.h b/xbmc/games/dialogs/osd/DialogGameOSD.h
new file mode 100644
index 0000000..3a8127b
--- /dev/null
+++ b/xbmc/games/dialogs/osd/DialogGameOSD.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 "guilib/GUIDialog.h"
+
+#include <memory>
+
+namespace KODI
+{
+namespace GAME
+{
+class CDialogGameOSDHelp;
+
+class CDialogGameOSD : public CGUIDialog
+{
+public:
+  CDialogGameOSD();
+
+  ~CDialogGameOSD() override = default;
+
+  // Implementation of CGUIControl via CGUIDialog
+  bool OnAction(const CAction& action) override;
+
+  // Implementation of CGUIWindow via CGUIDialog
+  void OnDeinitWindow(int nextWindowID) override;
+
+  /*!
+   * \brief Decide if the game should play behind the given dialog
+   *
+   * If true, the game should be played at regular speed.
+   *
+   * \param dialog The current dialog
+   *
+   * \return True if the game should be played at regular speed behind the
+   *         dialog, false otherwise
+   */
+  static bool PlayInBackground(int dialogId);
+
+protected:
+  // Implementation of CGUIWindow via CGUIDialog
+  void OnInitWindow() override;
+
+private:
+  std::unique_ptr<CDialogGameOSDHelp> m_helpDialog;
+};
+} // namespace GAME
+} // namespace KODI
diff --git a/xbmc/games/dialogs/osd/DialogGameOSDHelp.cpp b/xbmc/games/dialogs/osd/DialogGameOSDHelp.cpp
new file mode 100644
index 0000000..3152172
--- /dev/null
+++ b/xbmc/games/dialogs/osd/DialogGameOSDHelp.cpp
@@ -0,0 +1,71 @@
+/*
+ *  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 "DialogGameOSDHelp.h"
+
+#include "DialogGameOSD.h"
+#include "ServiceBroker.h"
+#include "games/GameServices.h"
+#include "games/controllers/guicontrols/GUIGameController.h"
+#include "guilib/GUIMessage.h"
+#include "guilib/LocalizeStrings.h"
+#include "guilib/WindowIDs.h"
+#include "utils/StringUtils.h"
+
+using namespace KODI;
+using namespace GAME;
+
+const int CDialogGameOSDHelp::CONTROL_ID_HELP_TEXT = 1101;
+const int CDialogGameOSDHelp::CONTROL_ID_GAME_CONTROLLER = 1102;
+
+CDialogGameOSDHelp::CDialogGameOSDHelp(CDialogGameOSD& dialog) : m_dialog(dialog)
+{
+}
+
+void CDialogGameOSDHelp::OnInitWindow()
+{
+  // Set help text
+  //! @todo Define Select + X combo elsewhere
+  // "Press {0:s} to open the menu."
+  std::string helpText = StringUtils::Format(g_localizeStrings.Get(35235), "Select + X");
+
+  CGUIMessage msg(GUI_MSG_LABEL_SET, WINDOW_DIALOG_GAME_OSD, CONTROL_ID_HELP_TEXT);
+  msg.SetLabel(helpText);
+  m_dialog.OnMessage(msg);
+
+  // Set controller
+  if (CServiceBroker::IsServiceManagerUp())
+  {
+    CGameServices& gameServices = CServiceBroker::GetGameServices();
+
+    //! @todo Define SNES controller elsewhere
+    ControllerPtr controller = gameServices.GetController("game.controller.snes");
+    if (controller)
+    {
+      //! @todo Activate controller for all game controller controls
+      CGUIGameController* guiController =
+          dynamic_cast<CGUIGameController*>(m_dialog.GetControl(CONTROL_ID_GAME_CONTROLLER));
+      if (guiController != nullptr)
+        guiController->ActivateController(controller);
+    }
+  }
+}
+
+bool CDialogGameOSDHelp::IsVisible()
+{
+  return IsVisible(CONTROL_ID_HELP_TEXT) || IsVisible(CONTROL_ID_GAME_CONTROLLER);
+}
+
+bool CDialogGameOSDHelp::IsVisible(int windowId)
+{
+  CGUIControl* control = m_dialog.GetControl(windowId);
+  if (control != nullptr)
+    return control->IsVisible();
+
+  return false;
+}
diff --git a/xbmc/games/dialogs/osd/DialogGameOSDHelp.h b/xbmc/games/dialogs/osd/DialogGameOSDHelp.h
new file mode 100644
index 0000000..6153075
--- /dev/null
+++ b/xbmc/games/dialogs/osd/DialogGameOSDHelp.h
@@ -0,0 +1,40 @@
+/*
+ *  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
+
+namespace KODI
+{
+namespace GAME
+{
+class CDialogGameOSD;
+
+class CDialogGameOSDHelp
+{
+public:
+  CDialogGameOSDHelp(CDialogGameOSD& dialog);
+
+  // Initialize help controls
+  void OnInitWindow();
+
+  // Check if any help controls are visible
+  bool IsVisible();
+
+private:
+  // Utility functions
+  bool IsVisible(int windowId);
+
+  // Construction parameters
+  CDialogGameOSD& m_dialog;
+
+  // Help control IDs
+  static const int CONTROL_ID_HELP_TEXT;
+  static const int CONTROL_ID_GAME_CONTROLLER;
+};
+} // namespace GAME
+} // namespace KODI
diff --git a/xbmc/games/dialogs/osd/DialogGameSaves.cpp b/xbmc/games/dialogs/osd/DialogGameSaves.cpp
new file mode 100644
index 0000000..90e7785
--- /dev/null
+++ b/xbmc/games/dialogs/osd/DialogGameSaves.cpp
@@ -0,0 +1,500 @@
+/*
+ *  Copyright (C) 2020-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 "DialogGameSaves.h"
+
+#include "FileItem.h"
+#include "ServiceBroker.h"
+#include "addons/Addon.h"
+#include "addons/AddonManager.h"
+#include "cores/RetroPlayer/savestates/ISavestate.h"
+#include "cores/RetroPlayer/savestates/SavestateDatabase.h"
+#include "dialogs/GUIDialogContextMenu.h"
+#include "dialogs/GUIDialogOK.h"
+#include "dialogs/GUIDialogYesNo.h"
+#include "games/addons/GameClient.h"
+#include "games/dialogs/DialogGameDefines.h"
+#include "guilib/GUIBaseContainer.h"
+#include "guilib/GUIComponent.h"
+#include "guilib/GUIKeyboardFactory.h"
+#include "guilib/GUIMessage.h"
+#include "guilib/GUIWindowManager.h"
+#include "guilib/LocalizeStrings.h"
+#include "guilib/WindowIDs.h"
+#include "input/Key.h"
+#include "utils/FileUtils.h"
+#include "utils/Variant.h"
+#include "view/GUIViewControl.h"
+#include "view/ViewState.h"
+
+using namespace KODI;
+using namespace GAME;
+
+CDialogGameSaves::CDialogGameSaves()
+  : CGUIDialog(WINDOW_DIALOG_GAME_SAVES, "DialogSelect.xml"),
+    m_viewControl(std::make_unique<CGUIViewControl>()),
+    m_vecList(std::make_unique<CFileItemList>())
+{
+}
+
+bool CDialogGameSaves::OnMessage(CGUIMessage& message)
+{
+  switch (message.GetMessage())
+  {
+    case GUI_MSG_CLICKED:
+    {
+      const int actionId = message.GetParam1();
+
+      switch (actionId)
+      {
+        case ACTION_SELECT_ITEM:
+        case ACTION_MOUSE_LEFT_CLICK:
+        {
+          int selectedId = m_viewControl->GetSelectedItem();
+          if (0 <= selectedId && selectedId < m_vecList->Size())
+          {
+            CFileItemPtr item = m_vecList->Get(selectedId);
+            if (item)
+            {
+              for (int i = 0; i < m_vecList->Size(); i++)
+                m_vecList->Get(i)->Select(false);
+
+              item->Select(true);
+
+              OnSelect(*item);
+
+              return true;
+            }
+          }
+          break;
+        }
+        case ACTION_CONTEXT_MENU:
+        case ACTION_MOUSE_RIGHT_CLICK:
+        {
+          int selectedItem = m_viewControl->GetSelectedItem();
+          if (selectedItem >= 0 && selectedItem < m_vecList->Size())
+          {
+            CFileItemPtr item = m_vecList->Get(selectedItem);
+            if (item)
+            {
+              OnContextMenu(*item);
+              return true;
+            }
+          }
+          break;
+        }
+        case ACTION_RENAME_ITEM:
+        {
+          const int controlId = message.GetSenderId();
+          if (m_viewControl->HasControl(controlId))
+          {
+            int selectedItem = m_viewControl->GetSelectedItem();
+            if (selectedItem >= 0 && selectedItem < m_vecList->Size())
+            {
+              CFileItemPtr item = m_vecList->Get(selectedItem);
+              if (item)
+              {
+                OnRename(*item);
+                return true;
+              }
+            }
+          }
+          break;
+        }
+        case ACTION_DELETE_ITEM:
+        {
+          const int controlId = message.GetSenderId();
+          if (m_viewControl->HasControl(controlId))
+          {
+            int selectedItem = m_viewControl->GetSelectedItem();
+            if (selectedItem >= 0 && selectedItem < m_vecList->Size())
+            {
+              CFileItemPtr item = m_vecList->Get(selectedItem);
+              if (item)
+              {
+                OnDelete(*item);
+                return true;
+              }
+            }
+          }
+          break;
+        }
+        default:
+          break;
+      }
+
+      const int controlId = message.GetSenderId();
+      switch (controlId)
+      {
+        case CONTROL_SAVES_NEW_BUTTON:
+        {
+          m_bNewPressed = true;
+          Close();
+          break;
+        }
+        case CONTROL_SAVES_CANCEL_BUTTON:
+        {
+          m_selectedItem.reset();
+          m_vecList->Clear();
+          m_bConfirmed = false;
+          Close();
+          break;
+        }
+        default:
+          break;
+      }
+
+      break;
+    }
+
+    case GUI_MSG_SETFOCUS:
+    {
+      const int controlId = message.GetControlId();
+      if (m_viewControl->HasControl(controlId))
+      {
+        if (m_vecList->IsEmpty())
+        {
+          SET_CONTROL_FOCUS(CONTROL_SAVES_NEW_BUTTON, 0);
+          return true;
+        }
+
+        if (m_viewControl->GetCurrentControl() != controlId)
+        {
+          m_viewControl->SetFocused();
+          return true;
+        }
+      }
+      break;
+    }
+
+    default:
+      break;
+  }
+
+  return CGUIDialog::OnMessage(message);
+}
+
+void CDialogGameSaves::FrameMove()
+{
+  CGUIControl* itemContainer = GetControl(CONTROL_SAVES_DETAILED_LIST);
+  if (itemContainer != nullptr)
+  {
+    if (itemContainer->HasFocus())
+    {
+      int selectedItem = m_viewControl->GetSelectedItem();
+      if (selectedItem >= 0 && selectedItem < m_vecList->Size())
+      {
+        CFileItemPtr item = m_vecList->Get(selectedItem);
+        if (item)
+          OnFocus(*item);
+      }
+    }
+    else
+    {
+      OnFocusLost();
+    }
+  }
+
+  CGUIDialog::FrameMove();
+}
+
+void CDialogGameSaves::OnInitWindow()
+{
+  m_viewControl->SetItems(*m_vecList);
+  m_viewControl->SetCurrentView(CONTROL_SAVES_DETAILED_LIST);
+
+  CGUIDialog::OnInitWindow();
+
+  // Select the first item
+  m_viewControl->SetSelectedItem(0);
+
+  // There's a race condition where the item's focus sends the update message
+  // before the window is fully initialized, so explicitly set the info now.
+  if (!m_vecList->IsEmpty())
+  {
+    CFileItemPtr item = m_vecList->Get(0);
+    if (item)
+    {
+      const std::string gameClientId = item->GetProperty(SAVESTATE_GAME_CLIENT).asString();
+      if (!gameClientId.empty())
+      {
+        std::string emulatorName;
+        std::string emulatorIcon;
+
+        using namespace ADDON;
+
+        AddonPtr addon;
+        CAddonMgr& addonManager = CServiceBroker::GetAddonMgr();
+        if (addonManager.GetAddon(m_currentGameClient, addon, OnlyEnabled::CHOICE_NO))
+        {
+          std::shared_ptr<CGameClient> gameClient = std::dynamic_pointer_cast<CGameClient>(addon);
+          if (gameClient)
+          {
+            m_currentGameClient = gameClient->ID();
+
+            emulatorName = gameClient->GetEmulatorName();
+            emulatorIcon = gameClient->Icon();
+          }
+        }
+
+        if (!emulatorName.empty())
+        {
+          CGUIMessage message(GUI_MSG_LABEL_SET, GetID(), CONTROL_SAVES_EMULATOR_NAME);
+          message.SetLabel(emulatorName);
+          OnMessage(message);
+        }
+        if (!emulatorIcon.empty())
+        {
+          CGUIMessage message(GUI_MSG_SET_FILENAME, GetID(), CONTROL_SAVES_EMULATOR_ICON);
+          message.SetLabel(emulatorIcon);
+          OnMessage(message);
+        }
+      }
+
+      const std::string caption = item->GetProperty(SAVESTATE_CAPTION).asString();
+      if (!caption.empty())
+      {
+        m_currentCaption = caption;
+
+        CGUIMessage message(GUI_MSG_LABEL_SET, GetID(), CONTROL_SAVES_DESCRIPTION);
+        message.SetLabel(m_currentCaption);
+        OnMessage(message);
+      }
+    }
+  }
+}
+
+void CDialogGameSaves::OnDeinitWindow(int nextWindowID)
+{
+  m_viewControl->Clear();
+
+  CGUIDialog::OnDeinitWindow(nextWindowID);
+
+  // Get selected item
+  for (int i = 0; i < m_vecList->Size(); ++i)
+  {
+    CFileItemPtr item = m_vecList->Get(i);
+    if (item->IsSelected())
+    {
+      m_selectedItem = item;
+      break;
+    }
+  }
+
+  m_vecList->Clear();
+}
+
+void CDialogGameSaves::OnWindowLoaded()
+{
+  CGUIDialog::OnWindowLoaded();
+
+  m_viewControl->Reset();
+  m_viewControl->SetParentWindow(GetID());
+  m_viewControl->AddView(GetControl(CONTROL_SAVES_DETAILED_LIST));
+}
+
+void CDialogGameSaves::OnWindowUnload()
+{
+  CGUIDialog::OnWindowUnload();
+  m_viewControl->Reset();
+}
+
+void CDialogGameSaves::Reset()
+{
+  m_bConfirmed = false;
+  m_bNewPressed = false;
+
+  m_vecList->Clear();
+  m_selectedItem.reset();
+}
+
+bool CDialogGameSaves::Open(const std::string& gamePath)
+{
+  CFileItemList items;
+
+  RETRO::CSavestateDatabase db;
+  if (!db.GetSavestatesNav(items, gamePath))
+    return false;
+
+  if (items.IsEmpty())
+    return false;
+
+  items.Sort(SortByDate, SortOrderDescending);
+
+  SetItems(items);
+
+  CGUIDialog::Open();
+
+  return true;
+}
+
+std::string CDialogGameSaves::GetSelectedItemPath()
+{
+  if (m_selectedItem)
+    return m_selectedItem->GetPath();
+
+  return "";
+}
+
+void CDialogGameSaves::SetItems(const CFileItemList& itemList)
+{
+  m_vecList->Clear();
+
+  // Need to make internal copy of list to be sure dialog is owner of it
+  m_vecList->Copy(itemList);
+
+  m_viewControl->SetItems(*m_vecList);
+}
+
+void CDialogGameSaves::OnSelect(const CFileItem& item)
+{
+  m_bConfirmed = true;
+  Close();
+}
+
+void CDialogGameSaves::OnFocus(const CFileItem& item)
+{
+  const std::string caption = item.GetProperty(SAVESTATE_CAPTION).asString();
+  const std::string gameClientId = item.GetProperty(SAVESTATE_GAME_CLIENT).asString();
+
+  HandleCaption(caption);
+  HandleGameClient(gameClientId);
+}
+
+void CDialogGameSaves::OnFocusLost()
+{
+  HandleCaption("");
+  HandleGameClient("");
+}
+
+void CDialogGameSaves::OnContextMenu(CFileItem& item)
+{
+  CContextButtons buttons;
+
+  buttons.Add(0, 118); // "Rename"
+  buttons.Add(1, 117); // "Delete"
+
+  const int index = CGUIDialogContextMenu::Show(buttons);
+
+  if (index == 0)
+    OnRename(item);
+  else if (index == 1)
+    OnDelete(item);
+}
+
+void CDialogGameSaves::OnRename(CFileItem& item)
+{
+  const std::string& savestatePath = item.GetPath();
+
+  // Get savestate properties
+  RETRO::CSavestateDatabase db;
+  std::unique_ptr<RETRO::ISavestate> savestate = RETRO::CSavestateDatabase::AllocateSavestate();
+  db.GetSavestate(savestatePath, *savestate);
+
+  std::string label(savestate->Label());
+
+  // "Enter new filename"
+  if (CGUIKeyboardFactory::ShowAndGetInput(label, CVariant{g_localizeStrings.Get(16013)}, true) &&
+      label != savestate->Label())
+  {
+    std::unique_ptr<RETRO::ISavestate> newSavestate = db.RenameSavestate(savestatePath, label);
+    if (newSavestate)
+    {
+      RETRO::CSavestateDatabase::GetSavestateItem(*newSavestate, savestatePath, item);
+
+      // Refresh thumbnails
+      m_viewControl->SetItems(*m_vecList);
+    }
+    else
+    {
+      // "Error"
+      // "An unknown error has occurred."
+      CGUIDialogOK::ShowAndGetInput(257, 24071);
+    }
+  }
+}
+
+void CDialogGameSaves::OnDelete(CFileItem& item)
+{
+  // "Confirm delete"
+  // "Would you like to delete the selected file(s)?[CR]Warning - this action can't be undone!"
+  if (CGUIDialogYesNo::ShowAndGetInput(CVariant{122}, CVariant{125}))
+  {
+    const std::string& savestatePath = item.GetPath();
+
+    RETRO::CSavestateDatabase db;
+    if (db.DeleteSavestate(savestatePath))
+    {
+      m_vecList->Remove(&item);
+
+      // Refresh thumbnails
+      m_viewControl->SetItems(*m_vecList);
+    }
+    else
+    {
+      // "Error"
+      // "An unknown error has occurred."
+      CGUIDialogOK::ShowAndGetInput(257, 24071);
+    }
+  }
+}
+
+void CDialogGameSaves::HandleCaption(const std::string& caption)
+{
+  if (caption != m_currentCaption)
+  {
+    m_currentCaption = caption;
+
+    // Update the GUI label
+    CGUIMessage msg(GUI_MSG_LABEL_SET, GetID(), CONTROL_SAVES_DESCRIPTION);
+    msg.SetLabel(m_currentCaption);
+    CServiceBroker::GetGUI()->GetWindowManager().SendThreadMessage(msg, GetID());
+  }
+}
+
+void CDialogGameSaves::HandleGameClient(const std::string& gameClientId)
+{
+  if (gameClientId == m_currentGameClient)
+    return;
+
+  m_currentGameClient = gameClientId;
+  if (m_currentGameClient.empty())
+    return;
+
+  // Get game client properties
+  std::shared_ptr<CGameClient> gameClient;
+  std::string emulatorName;
+  std::string iconPath;
+
+  using namespace ADDON;
+
+  AddonPtr addon;
+  CAddonMgr& addonManager = CServiceBroker::GetAddonMgr();
+  if (addonManager.GetAddon(m_currentGameClient, addon, OnlyEnabled::CHOICE_NO))
+    gameClient = std::dynamic_pointer_cast<CGameClient>(addon);
+
+  if (gameClient)
+  {
+    emulatorName = gameClient->GetEmulatorName();
+    iconPath = gameClient->Icon();
+  }
+
+  // Update the GUI elements
+  if (!emulatorName.empty())
+  {
+    CGUIMessage message(GUI_MSG_LABEL_SET, GetID(), CONTROL_SAVES_EMULATOR_NAME);
+    message.SetLabel(emulatorName);
+    CServiceBroker::GetGUI()->GetWindowManager().SendThreadMessage(message, GetID());
+  }
+  if (!iconPath.empty())
+  {
+    CGUIMessage message(GUI_MSG_SET_FILENAME, GetID(), CONTROL_SAVES_EMULATOR_ICON);
+    message.SetLabel(iconPath);
+    CServiceBroker::GetGUI()->GetWindowManager().SendThreadMessage(message, GetID());
+  }
+}
diff --git a/xbmc/games/dialogs/osd/DialogGameSaves.h b/xbmc/games/dialogs/osd/DialogGameSaves.h
new file mode 100644
index 0000000..3605ee6
--- /dev/null
+++ b/xbmc/games/dialogs/osd/DialogGameSaves.h
@@ -0,0 +1,113 @@
+/*
+ *  Copyright (C) 2020-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 "guilib/GUIDialog.h"
+
+#include <memory>
+#include <string>
+
+class CFileItem;
+class CFileItemList;
+class CGUIMessage;
+class CGUIViewControl;
+
+namespace KODI
+{
+namespace GAME
+{
+class CDialogGameSaves : public CGUIDialog
+{
+public:
+  CDialogGameSaves();
+  ~CDialogGameSaves() override = default;
+
+  // implementation of CGUIControl via CGUIDialog
+  bool OnMessage(CGUIMessage& message) override;
+
+  // implementation of CGUIWindow via CGUIDialog
+  void FrameMove() override;
+
+  // Player interface
+  void Reset();
+  bool Open(const std::string& gamePath);
+  bool IsConfirmed() const { return m_bConfirmed; }
+  bool IsNewPressed() const { return m_bNewPressed; }
+  std::string GetSelectedItemPath();
+
+protected:
+  // implementation of CGUIWIndow via CGUIDialog
+  void OnInitWindow() override;
+  void OnDeinitWindow(int nextWindowID) override;
+  void OnWindowLoaded() override;
+  void OnWindowUnload() override;
+
+private:
+  using CGUIControl::OnFocus;
+
+  /*!
+   * \breif Called when opening to set the item list
+   */
+  void SetItems(const CFileItemList& itemList);
+
+  /*!
+   * \brief Called when an item has been selected
+   */
+  void OnSelect(const CFileItem& item);
+
+  /*!
+   * \brief Called every frame with the item being focused
+   */
+  void OnFocus(const CFileItem& item);
+
+  /*!
+   * \brief Called every frame if no item is focused
+   */
+  void OnFocusLost();
+
+  /*!
+   * \brief Called when a context menu is opened for an item
+   */
+  void OnContextMenu(CFileItem& item);
+
+  /*!
+  * \brief Called when "Rename" is selected from the context menu
+  */
+  void OnRename(CFileItem& item);
+
+  /*!
+  * \brief Called when "Delete" is selected from the context menu
+  */
+  void OnDelete(CFileItem& item);
+
+  /*!
+   * \brief Called every frame with the caption to set
+   */
+  void HandleCaption(const std::string& caption);
+
+  /*!
+  * \brief Called every frame with the game client to set
+  */
+  void HandleGameClient(const std::string& gameClientId);
+
+  // Dialog parameters
+  std::unique_ptr<CGUIViewControl> m_viewControl;
+  std::unique_ptr<CFileItemList> m_vecList;
+  std::shared_ptr<CFileItem> m_selectedItem;
+
+  // Player parameters
+  bool m_bConfirmed{false};
+  bool m_bNewPressed{false};
+
+  // State parameters
+  std::string m_currentCaption;
+  std::string m_currentGameClient;
+};
+} // namespace GAME
+} // namespace KODI
diff --git a/xbmc/games/dialogs/osd/DialogGameStretchMode.cpp b/xbmc/games/dialogs/osd/DialogGameStretchMode.cpp
new file mode 100644
index 0000000..98c1e07
--- /dev/null
+++ b/xbmc/games/dialogs/osd/DialogGameStretchMode.cpp
@@ -0,0 +1,128 @@
+/*
+ *  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 "DialogGameStretchMode.h"
+
+#include "FileItem.h"
+#include "cores/RetroPlayer/RetroPlayerUtils.h"
+#include "cores/RetroPlayer/guibridge/GUIGameVideoHandle.h"
+#include "guilib/LocalizeStrings.h"
+#include "guilib/WindowIDs.h"
+#include "settings/GameSettings.h"
+#include "settings/MediaSettings.h"
+#include "utils/Variant.h"
+
+using namespace KODI;
+using namespace GAME;
+
+const std::vector<CDialogGameStretchMode::StretchModeProperties>
+    CDialogGameStretchMode::m_allStretchModes = {
+        {630, RETRO::STRETCHMODE::Normal},
+        //  { 631,   RETRO::STRETCHMODE::Zoom }, //! @todo RetroArch allows trimming some outer
+        //  pixels
+        {632, RETRO::STRETCHMODE::Stretch4x3},
+        {35232, RETRO::STRETCHMODE::Fullscreen},
+        {635, RETRO::STRETCHMODE::Original},
+};
+
+CDialogGameStretchMode::CDialogGameStretchMode()
+  : CDialogGameVideoSelect(WINDOW_DIALOG_GAME_STRETCH_MODE)
+{
+}
+
+std::string CDialogGameStretchMode::GetHeading()
+{
+  return g_localizeStrings.Get(35233); // "Stretch mode"
+}
+
+void CDialogGameStretchMode::PreInit()
+{
+  m_stretchModes.clear();
+
+  for (const auto& stretchMode : m_allStretchModes)
+  {
+    bool bSupported = false;
+
+    switch (stretchMode.stretchMode)
+    {
+      case RETRO::STRETCHMODE::Normal:
+      case RETRO::STRETCHMODE::Original:
+        bSupported = true;
+        break;
+
+      case RETRO::STRETCHMODE::Stretch4x3:
+      case RETRO::STRETCHMODE::Fullscreen:
+        if (m_gameVideoHandle)
+        {
+          bSupported = m_gameVideoHandle->SupportsRenderFeature(RETRO::RENDERFEATURE::STRETCH) ||
+                       m_gameVideoHandle->SupportsRenderFeature(RETRO::RENDERFEATURE::PIXEL_RATIO);
+        }
+        break;
+
+      default:
+        break;
+    }
+
+    if (bSupported)
+      m_stretchModes.emplace_back(stretchMode);
+  }
+}
+
+void CDialogGameStretchMode::GetItems(CFileItemList& items)
+{
+  for (const auto& stretchMode : m_stretchModes)
+  {
+    CFileItemPtr item = std::make_shared<CFileItem>(g_localizeStrings.Get(stretchMode.stringIndex));
+
+    const std::string stretchModeId =
+        RETRO::CRetroPlayerUtils::StretchModeToIdentifier(stretchMode.stretchMode);
+    if (!stretchModeId.empty())
+      item->SetProperty("game.stretchmode", CVariant{stretchModeId});
+    items.Add(std::move(item));
+  }
+}
+
+void CDialogGameStretchMode::OnItemFocus(unsigned int index)
+{
+  if (index < m_stretchModes.size())
+  {
+    const RETRO::STRETCHMODE stretchMode = m_stretchModes[index].stretchMode;
+
+    CGameSettings& gameSettings = CMediaSettings::GetInstance().GetCurrentGameSettings();
+    if (gameSettings.StretchMode() != stretchMode)
+    {
+      gameSettings.SetStretchMode(stretchMode);
+      gameSettings.NotifyObservers(ObservableMessageSettingsChanged);
+    }
+  }
+}
+
+unsigned int CDialogGameStretchMode::GetFocusedItem() const
+{
+  CGameSettings& gameSettings = CMediaSettings::GetInstance().GetCurrentGameSettings();
+
+  for (unsigned int i = 0; i < m_stretchModes.size(); i++)
+  {
+    const RETRO::STRETCHMODE stretchMode = m_stretchModes[i].stretchMode;
+    if (stretchMode == gameSettings.StretchMode())
+      return i;
+  }
+
+  return 0;
+}
+
+void CDialogGameStretchMode::PostExit()
+{
+  m_stretchModes.clear();
+}
+
+bool CDialogGameStretchMode::OnClickAction()
+{
+  Close();
+  return true;
+}
diff --git a/xbmc/games/dialogs/osd/DialogGameStretchMode.h b/xbmc/games/dialogs/osd/DialogGameStretchMode.h
new file mode 100644
index 0000000..1e05061
--- /dev/null
+++ b/xbmc/games/dialogs/osd/DialogGameStretchMode.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 "DialogGameVideoSelect.h"
+#include "cores/GameSettings.h"
+
+#include <vector>
+
+namespace KODI
+{
+namespace GAME
+{
+class CDialogGameStretchMode : public CDialogGameVideoSelect
+{
+public:
+  CDialogGameStretchMode();
+  ~CDialogGameStretchMode() override = default;
+
+protected:
+  // implementation of CDialogGameVideoSelect
+  std::string GetHeading() override;
+  void PreInit() override;
+  void GetItems(CFileItemList& items) override;
+  void OnItemFocus(unsigned int index) override;
+  unsigned int GetFocusedItem() const override;
+  void PostExit() override;
+  bool OnClickAction() override;
+
+private:
+  struct StretchModeProperties
+  {
+    int stringIndex;
+    RETRO::STRETCHMODE stretchMode;
+  };
+
+  std::vector<StretchModeProperties> m_stretchModes;
+
+  /*!
+   * \brief The list of all the stretch modes along with their properties
+   */
+  static const std::vector<StretchModeProperties> m_allStretchModes;
+};
+} // namespace GAME
+} // namespace KODI
diff --git a/xbmc/games/dialogs/osd/DialogGameVideoFilter.cpp b/xbmc/games/dialogs/osd/DialogGameVideoFilter.cpp
new file mode 100644
index 0000000..a5bba0b
--- /dev/null
+++ b/xbmc/games/dialogs/osd/DialogGameVideoFilter.cpp
@@ -0,0 +1,157 @@
+/*
+ *  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 "DialogGameVideoFilter.h"
+
+#include "cores/RetroPlayer/guibridge/GUIGameVideoHandle.h"
+#include "cores/RetroPlayer/rendering/RenderVideoSettings.h"
+#include "guilib/LocalizeStrings.h"
+#include "guilib/WindowIDs.h"
+#include "settings/GameSettings.h"
+#include "settings/MediaSettings.h"
+#include "utils/StringUtils.h"
+#include "utils/Variant.h"
+
+using namespace KODI;
+using namespace GAME;
+
+namespace
+{
+struct ScalingMethodProperties
+{
+  int nameIndex;
+  int categoryIndex;
+  int descriptionIndex;
+  RETRO::SCALINGMETHOD scalingMethod;
+};
+
+const std::vector<ScalingMethodProperties> scalingMethods = {
+    {16301, 16296, 16298, RETRO::SCALINGMETHOD::NEAREST},
+    {16302, 16297, 16299, RETRO::SCALINGMETHOD::LINEAR},
+};
+} // namespace
+
+CDialogGameVideoFilter::CDialogGameVideoFilter()
+  : CDialogGameVideoSelect(WINDOW_DIALOG_GAME_VIDEO_FILTER)
+{
+}
+
+std::string CDialogGameVideoFilter::GetHeading()
+{
+  return g_localizeStrings.Get(35225); // "Video filter"
+}
+
+void CDialogGameVideoFilter::PreInit()
+{
+  m_items.Clear();
+
+  InitVideoFilters();
+
+  if (m_items.Size() == 0)
+  {
+    CFileItemPtr item = std::make_shared<CFileItem>(g_localizeStrings.Get(231)); // "None"
+    m_items.Add(std::move(item));
+  }
+
+  m_bHasDescription = false;
+}
+
+void CDialogGameVideoFilter::InitVideoFilters()
+{
+  if (m_gameVideoHandle)
+  {
+    for (const auto& scalingMethodProps : scalingMethods)
+    {
+      if (m_gameVideoHandle->SupportsScalingMethod(scalingMethodProps.scalingMethod))
+      {
+        RETRO::CRenderVideoSettings videoSettings;
+        videoSettings.SetScalingMethod(scalingMethodProps.scalingMethod);
+
+        CFileItemPtr item =
+            std::make_shared<CFileItem>(g_localizeStrings.Get(scalingMethodProps.nameIndex));
+        item->SetLabel2(g_localizeStrings.Get(scalingMethodProps.categoryIndex));
+        item->SetProperty("game.videofilter", CVariant{videoSettings.GetVideoFilter()});
+        item->SetProperty("game.videofilterdescription",
+                          CVariant{g_localizeStrings.Get(scalingMethodProps.descriptionIndex)});
+        m_items.Add(std::move(item));
+      }
+    }
+  }
+}
+
+void CDialogGameVideoFilter::GetItems(CFileItemList& items)
+{
+  for (const auto& item : m_items)
+    items.Add(item);
+}
+
+void CDialogGameVideoFilter::OnItemFocus(unsigned int index)
+{
+  if (static_cast<int>(index) < m_items.Size())
+  {
+    CFileItemPtr item = m_items[index];
+
+    std::string videoFilter;
+    std::string description;
+    GetProperties(*item, videoFilter, description);
+
+    CGameSettings& gameSettings = CMediaSettings::GetInstance().GetCurrentGameSettings();
+
+    if (gameSettings.VideoFilter() != videoFilter)
+    {
+      gameSettings.SetVideoFilter(videoFilter);
+      gameSettings.NotifyObservers(ObservableMessageSettingsChanged);
+
+      OnDescriptionChange(description);
+      m_bHasDescription = true;
+    }
+    else if (!m_bHasDescription)
+    {
+      OnDescriptionChange(description);
+      m_bHasDescription = true;
+    }
+  }
+}
+
+unsigned int CDialogGameVideoFilter::GetFocusedItem() const
+{
+  CGameSettings& gameSettings = CMediaSettings::GetInstance().GetCurrentGameSettings();
+
+  for (int i = 0; i < m_items.Size(); i++)
+  {
+    std::string videoFilter;
+    std::string description;
+    GetProperties(*m_items[i], videoFilter, description);
+
+    if (videoFilter == gameSettings.VideoFilter())
+    {
+      return i;
+    }
+  }
+
+  return 0;
+}
+
+void CDialogGameVideoFilter::PostExit()
+{
+  m_items.Clear();
+}
+
+bool CDialogGameVideoFilter::OnClickAction()
+{
+  Close();
+  return true;
+}
+
+void CDialogGameVideoFilter::GetProperties(const CFileItem& item,
+                                           std::string& videoFilter,
+                                           std::string& description)
+{
+  videoFilter = item.GetProperty("game.videofilter").asString();
+  description = item.GetProperty("game.videofilterdescription").asString();
+}
diff --git a/xbmc/games/dialogs/osd/DialogGameVideoFilter.h b/xbmc/games/dialogs/osd/DialogGameVideoFilter.h
new file mode 100644
index 0000000..7ec8c76
--- /dev/null
+++ b/xbmc/games/dialogs/osd/DialogGameVideoFilter.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 "DialogGameVideoSelect.h"
+#include "FileItem.h"
+
+namespace KODI
+{
+namespace GAME
+{
+class CDialogGameVideoFilter : public CDialogGameVideoSelect
+{
+public:
+  CDialogGameVideoFilter();
+  ~CDialogGameVideoFilter() override = default;
+
+protected:
+  // implementation of CDialogGameVideoSelect
+  std::string GetHeading() override;
+  void PreInit() override;
+  void GetItems(CFileItemList& items) override;
+  void OnItemFocus(unsigned int index) override;
+  unsigned int GetFocusedItem() const override;
+  void PostExit() override;
+  bool OnClickAction() override;
+
+private:
+  void InitVideoFilters();
+
+  static void GetProperties(const CFileItem& item,
+                            std::string& videoFilter,
+                            std::string& description);
+
+  CFileItemList m_items;
+
+  //! \brief Set to true when a description has first been set
+  bool m_bHasDescription = false;
+};
+} // namespace GAME
+} // namespace KODI
diff --git a/xbmc/games/dialogs/osd/DialogGameVideoRotation.cpp b/xbmc/games/dialogs/osd/DialogGameVideoRotation.cpp
new file mode 100644
index 0000000..7037a6b
--- /dev/null
+++ b/xbmc/games/dialogs/osd/DialogGameVideoRotation.cpp
@@ -0,0 +1,109 @@
+/*
+ *  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 "DialogGameVideoRotation.h"
+
+#include "FileItem.h"
+#include "guilib/LocalizeStrings.h"
+#include "guilib/WindowIDs.h"
+#include "settings/GameSettings.h"
+#include "settings/MediaSettings.h"
+#include "utils/Variant.h"
+
+using namespace KODI;
+using namespace GAME;
+
+CDialogGameVideoRotation::CDialogGameVideoRotation()
+  : CDialogGameVideoSelect(WINDOW_DIALOG_GAME_VIDEO_ROTATION)
+{
+}
+
+std::string CDialogGameVideoRotation::GetHeading()
+{
+  return g_localizeStrings.Get(35227); // "Rotation"
+}
+
+void CDialogGameVideoRotation::PreInit()
+{
+  m_rotations.clear();
+
+  // Present the user with clockwise rotation
+  m_rotations.push_back(0);
+  m_rotations.push_back(270);
+  m_rotations.push_back(180);
+  m_rotations.push_back(90);
+}
+
+void CDialogGameVideoRotation::GetItems(CFileItemList& items)
+{
+  for (unsigned int rotation : m_rotations)
+  {
+    CFileItemPtr item = std::make_shared<CFileItem>(GetRotationLabel(rotation));
+    item->SetProperty("game.videorotation", CVariant{rotation});
+    items.Add(std::move(item));
+  }
+}
+
+void CDialogGameVideoRotation::OnItemFocus(unsigned int index)
+{
+  if (index < m_rotations.size())
+  {
+    const unsigned int rotationDegCCW = m_rotations[index];
+
+    CGameSettings& gameSettings = CMediaSettings::GetInstance().GetCurrentGameSettings();
+    if (gameSettings.RotationDegCCW() != rotationDegCCW)
+    {
+      gameSettings.SetRotationDegCCW(rotationDegCCW);
+      gameSettings.NotifyObservers(ObservableMessageSettingsChanged);
+    }
+  }
+}
+
+unsigned int CDialogGameVideoRotation::GetFocusedItem() const
+{
+  CGameSettings& gameSettings = CMediaSettings::GetInstance().GetCurrentGameSettings();
+
+  for (unsigned int i = 0; i < m_rotations.size(); i++)
+  {
+    const unsigned int rotationDegCCW = m_rotations[i];
+    if (rotationDegCCW == gameSettings.RotationDegCCW())
+      return i;
+  }
+
+  return 0;
+}
+
+void CDialogGameVideoRotation::PostExit()
+{
+  m_rotations.clear();
+}
+
+bool CDialogGameVideoRotation::OnClickAction()
+{
+  Close();
+  return true;
+}
+
+std::string CDialogGameVideoRotation::GetRotationLabel(unsigned int rotationDegCCW)
+{
+  switch (rotationDegCCW)
+  {
+    case 0:
+      return g_localizeStrings.Get(35228); // 0
+    case 90:
+      return g_localizeStrings.Get(35231); // 270
+    case 180:
+      return g_localizeStrings.Get(35230); // 180
+    case 270:
+      return g_localizeStrings.Get(35229); // 90
+    default:
+      break;
+  }
+
+  return "";
+}
diff --git a/xbmc/games/dialogs/osd/DialogGameVideoRotation.h b/xbmc/games/dialogs/osd/DialogGameVideoRotation.h
new file mode 100644
index 0000000..ef454db
--- /dev/null
+++ b/xbmc/games/dialogs/osd/DialogGameVideoRotation.h
@@ -0,0 +1,44 @@
+/*
+ *  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 "DialogGameVideoSelect.h"
+
+#include <string>
+#include <vector>
+
+namespace KODI
+{
+namespace GAME
+{
+class CDialogGameVideoRotation : public CDialogGameVideoSelect
+{
+public:
+  CDialogGameVideoRotation();
+  ~CDialogGameVideoRotation() override = default;
+
+protected:
+  // implementation of CDialogGameVideoSelect
+  std::string GetHeading() override;
+  void PreInit() override;
+  void GetItems(CFileItemList& items) override;
+  void OnItemFocus(unsigned int index) override;
+  unsigned int GetFocusedItem() const override;
+  void PostExit() override;
+  bool OnClickAction() override;
+
+private:
+  // Helper functions
+  static std::string GetRotationLabel(unsigned int rotationDegCCW);
+
+  // Dialog parameters
+  std::vector<unsigned int> m_rotations; // Degrees counter-clockwise
+};
+} // namespace GAME
+} // namespace KODI
diff --git a/xbmc/games/dialogs/osd/DialogGameVideoSelect.cpp b/xbmc/games/dialogs/osd/DialogGameVideoSelect.cpp
new file mode 100644
index 0000000..a69b26f
--- /dev/null
+++ b/xbmc/games/dialogs/osd/DialogGameVideoSelect.cpp
@@ -0,0 +1,254 @@
+/*
+ *  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 "DialogGameVideoSelect.h"
+
+#include "FileItem.h"
+#include "ServiceBroker.h"
+#include "cores/RetroPlayer/guibridge/GUIGameRenderManager.h"
+#include "cores/RetroPlayer/guibridge/GUIGameVideoHandle.h"
+#include "games/dialogs/DialogGameDefines.h"
+#include "guilib/GUIBaseContainer.h"
+#include "guilib/GUIComponent.h"
+#include "guilib/GUIMessage.h"
+#include "guilib/GUIWindowManager.h"
+#include "input/actions/ActionIDs.h"
+#include "settings/GameSettings.h"
+#include "settings/MediaSettings.h"
+#include "settings/Settings.h"
+#include "settings/SettingsComponent.h"
+#include "view/GUIViewControl.h"
+#include "view/ViewState.h"
+#include "windowing/GraphicContext.h"
+
+using namespace KODI;
+using namespace GAME;
+
+CDialogGameVideoSelect::CDialogGameVideoSelect(int windowId)
+  : CGUIDialog(windowId, "DialogSelect.xml"),
+    m_viewControl(new CGUIViewControl),
+    m_vecItems(new CFileItemList)
+{
+  // Initialize CGUIWindow
+  m_loadType = KEEP_IN_MEMORY;
+}
+
+CDialogGameVideoSelect::~CDialogGameVideoSelect() = default;
+
+bool CDialogGameVideoSelect::OnMessage(CGUIMessage& message)
+{
+  switch (message.GetMessage())
+  {
+    case GUI_MSG_WINDOW_INIT:
+    {
+      RegisterDialog();
+
+      // Don't init this dialog if we aren't playing a game
+      if (!m_gameVideoHandle || !m_gameVideoHandle->IsPlayingGame())
+        return false;
+
+      break;
+    }
+    case GUI_MSG_WINDOW_DEINIT:
+    {
+      UnregisterDialog();
+
+      break;
+    }
+    case GUI_MSG_SETFOCUS:
+    {
+      const int controlId = message.GetControlId();
+      if (m_viewControl->HasControl(controlId) && m_viewControl->GetCurrentControl() != controlId)
+      {
+        m_viewControl->SetFocused();
+        return true;
+      }
+      break;
+    }
+    case GUI_MSG_CLICKED:
+    {
+      const int actionId = message.GetParam1();
+      if (actionId == ACTION_SELECT_ITEM || actionId == ACTION_MOUSE_LEFT_CLICK)
+      {
+        const int controlId = message.GetSenderId();
+        if (m_viewControl->HasControl(controlId))
+        {
+          if (OnClickAction())
+            return true;
+        }
+      }
+      else if (actionId == ACTION_CONTEXT_MENU || actionId == ACTION_MOUSE_RIGHT_CLICK)
+      {
+        const int controlId = message.GetSenderId();
+        if (m_viewControl->HasControl(controlId))
+        {
+          if (OnMenuAction())
+            return true;
+        }
+      }
+      else if (actionId == ACTION_CREATE_BOOKMARK)
+      {
+        const int controlId = message.GetSenderId();
+        if (m_viewControl->HasControl(controlId))
+        {
+          if (OnOverwriteAction())
+            return true;
+        }
+      }
+      else if (actionId == ACTION_RENAME_ITEM)
+      {
+        const int controlId = message.GetSenderId();
+        if (m_viewControl->HasControl(controlId))
+        {
+          if (OnRenameAction())
+            return true;
+        }
+      }
+      else if (actionId == ACTION_DELETE_ITEM)
+      {
+        const int controlId = message.GetSenderId();
+        if (m_viewControl->HasControl(controlId))
+        {
+          if (OnDeleteAction())
+            return true;
+        }
+      }
+
+      break;
+    }
+    case GUI_MSG_REFRESH_LIST:
+    {
+      RefreshList();
+      break;
+    }
+    default:
+      break;
+  }
+
+  return CGUIDialog::OnMessage(message);
+}
+
+void CDialogGameVideoSelect::FrameMove()
+{
+  CGUIBaseContainer* thumbs = dynamic_cast<CGUIBaseContainer*>(GetControl(CONTROL_VIDEO_THUMBS));
+  if (thumbs != nullptr)
+    OnItemFocus(thumbs->GetSelectedItem());
+
+  CGUIDialog::FrameMove();
+}
+
+void CDialogGameVideoSelect::OnWindowLoaded()
+{
+  CGUIDialog::OnWindowLoaded();
+
+  m_viewControl->SetParentWindow(GetID());
+  m_viewControl->AddView(GetControl(CONTROL_VIDEO_THUMBS));
+}
+
+void CDialogGameVideoSelect::OnWindowUnload()
+{
+  m_viewControl->Reset();
+
+  CGUIDialog::OnWindowUnload();
+}
+
+void CDialogGameVideoSelect::OnInitWindow()
+{
+  PreInit();
+
+  CGUIDialog::OnInitWindow();
+
+  Update();
+
+  CGUIMessage msg(GUI_MSG_SETFOCUS, GetID(), CONTROL_VIDEO_THUMBS);
+  OnMessage(msg);
+
+  std::string heading = GetHeading();
+  SET_CONTROL_LABEL(CONTROL_VIDEO_HEADING, heading);
+
+  FrameMove();
+}
+
+void CDialogGameVideoSelect::OnDeinitWindow(int nextWindowID)
+{
+  Clear();
+
+  CGUIDialog::OnDeinitWindow(nextWindowID);
+
+  PostExit();
+
+  SaveSettings();
+}
+
+void CDialogGameVideoSelect::Update()
+{
+  //! @todo
+  // Lock our display, as this window is rendered from the player thread
+  // CServiceBroker::GetWinSystem()->GetGfxContext().Lock();
+
+  m_viewControl->SetCurrentView(DEFAULT_VIEW_ICONS);
+
+  // Empty the list ready for population
+  Clear();
+
+  RefreshList();
+
+  // CServiceBroker::GetWinSystem()->GetGfxContext().Unlock();
+}
+
+void CDialogGameVideoSelect::Clear()
+{
+  m_viewControl->Clear();
+  m_vecItems->Clear();
+}
+
+void CDialogGameVideoSelect::RefreshList()
+{
+  m_vecItems->Clear();
+
+  GetItems(*m_vecItems);
+
+  m_viewControl->SetItems(*m_vecItems);
+
+  auto focusedIndex = GetFocusedItem();
+  m_viewControl->SetSelectedItem(focusedIndex);
+  OnItemFocus(focusedIndex);
+
+  // Refresh the panel container
+  CGUIMessage message(GUI_MSG_REFRESH_THUMBS, GetID(), CONTROL_VIDEO_THUMBS);
+  CServiceBroker::GetGUI()->GetWindowManager().SendThreadMessage(message, GetID());
+}
+
+void CDialogGameVideoSelect::SaveSettings()
+{
+  CGameSettings& defaultSettings = CMediaSettings::GetInstance().GetDefaultGameSettings();
+  CGameSettings& currentSettings = CMediaSettings::GetInstance().GetCurrentGameSettings();
+
+  if (defaultSettings != currentSettings)
+  {
+    defaultSettings = currentSettings;
+    CServiceBroker::GetSettingsComponent()->GetSettings()->Save();
+  }
+}
+
+void CDialogGameVideoSelect::OnDescriptionChange(const std::string& description)
+{
+  CGUIMessage msg(GUI_MSG_LABEL_SET, GetID(), CONTROL_VIDEO_THUMBS);
+  msg.SetLabel(description);
+  CServiceBroker::GetGUI()->GetWindowManager().SendThreadMessage(msg, GetID());
+}
+
+void CDialogGameVideoSelect::RegisterDialog()
+{
+  m_gameVideoHandle = CServiceBroker::GetGameRenderManager().RegisterDialog(*this);
+}
+
+void CDialogGameVideoSelect::UnregisterDialog()
+{
+  m_gameVideoHandle.reset();
+}
diff --git a/xbmc/games/dialogs/osd/DialogGameVideoSelect.h b/xbmc/games/dialogs/osd/DialogGameVideoSelect.h
new file mode 100644
index 0000000..c14c94e
--- /dev/null
+++ b/xbmc/games/dialogs/osd/DialogGameVideoSelect.h
@@ -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.
+ */
+
+#pragma once
+
+#include "guilib/GUIDialog.h"
+
+#include <memory>
+
+class CFileItemList;
+class CGUIViewControl;
+
+namespace KODI
+{
+namespace RETRO
+{
+class CGUIGameVideoHandle;
+}
+
+namespace GAME
+{
+class CDialogGameVideoSelect : public CGUIDialog
+{
+public:
+  ~CDialogGameVideoSelect() override;
+
+  // implementation of CGUIControl via CGUIDialog
+  bool OnMessage(CGUIMessage& message) override;
+
+  // implementation of CGUIWindow via CGUIDialog
+  void FrameMove() override;
+  void OnDeinitWindow(int nextWindowID) override;
+
+protected:
+  CDialogGameVideoSelect(int windowId);
+
+  // implementation of CGUIWindow via CGUIDialog
+  void OnWindowUnload() override;
+  void OnWindowLoaded() override;
+  void OnInitWindow() override;
+
+  // Video select interface
+  virtual std::string GetHeading() = 0;
+  virtual void PreInit() = 0;
+  virtual void GetItems(CFileItemList& items) = 0;
+  virtual void OnItemFocus(unsigned int index) = 0;
+  virtual unsigned int GetFocusedItem() const = 0;
+  virtual void PostExit() = 0;
+  // override this to do something when an item is selected
+  virtual bool OnClickAction() { return false; }
+  // override this to do something when an item's context menu is opened
+  virtual bool OnMenuAction() { return false; }
+  // override this to do something when an item is overwritten with a new savestate
+  virtual bool OnOverwriteAction() { return false; }
+  // override this to do something when an item is renamed
+  virtual bool OnRenameAction() { return false; }
+  // override this to do something when an item is deleted
+  virtual bool OnDeleteAction() { return false; }
+
+  // GUI functions
+  void RefreshList();
+  void OnDescriptionChange(const std::string& description);
+
+  std::shared_ptr<RETRO::CGUIGameVideoHandle> m_gameVideoHandle;
+
+private:
+  void Update();
+  void Clear();
+
+  void SaveSettings();
+
+  void RegisterDialog();
+  void UnregisterDialog();
+
+  std::unique_ptr<CGUIViewControl> m_viewControl;
+  std::unique_ptr<CFileItemList> m_vecItems;
+};
+} // namespace GAME
+} // namespace KODI
diff --git a/xbmc/games/dialogs/osd/DialogGameVolume.cpp b/xbmc/games/dialogs/osd/DialogGameVolume.cpp
new file mode 100644
index 0000000..8467269
--- /dev/null
+++ b/xbmc/games/dialogs/osd/DialogGameVolume.cpp
@@ -0,0 +1,149 @@
+/*
+ *  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 "DialogGameVolume.h"
+
+#include "ServiceBroker.h"
+#include "application/ApplicationComponents.h"
+#include "application/ApplicationVolumeHandling.h"
+#include "dialogs/GUIDialogVolumeBar.h"
+#include "guilib/GUIComponent.h"
+#include "guilib/GUIDialog.h"
+#include "guilib/GUIMessage.h"
+#include "guilib/GUISliderControl.h"
+#include "guilib/GUIWindowManager.h"
+#include "guilib/LocalizeStrings.h"
+#include "guilib/WindowIDs.h"
+#include "interfaces/AnnouncementManager.h"
+#include "utils/Variant.h"
+
+#include <cmath>
+
+using namespace KODI;
+using namespace GAME;
+
+#define CONTROL_LABEL 12 //! @todo Remove me
+
+CDialogGameVolume::CDialogGameVolume()
+{
+  // Initialize CGUIWindow
+  SetID(WINDOW_DIALOG_GAME_VOLUME);
+  m_loadType = KEEP_IN_MEMORY;
+}
+
+bool CDialogGameVolume::OnMessage(CGUIMessage& message)
+{
+  switch (message.GetMessage())
+  {
+    case GUI_MSG_STATE_CHANGED:
+    {
+      int controlId = message.GetControlId();
+      if (controlId == GetID())
+      {
+        OnStateChanged();
+        return true;
+      }
+
+      break;
+    }
+    default:
+      break;
+  }
+
+  return CGUIDialogSlider::OnMessage(message);
+}
+
+void CDialogGameVolume::OnInitWindow()
+{
+  m_volumePercent = m_oldVolumePercent = GetVolumePercent();
+
+  CGUIDialogSlider::OnInitWindow();
+
+  // Set slider parameters
+  SetModalityType(DialogModalityType::MODAL);
+  SetSlider(GetLabel(), GetVolumePercent(), VOLUME_MIN, VOLUME_DELTA, VOLUME_MAX, this, nullptr);
+
+  SET_CONTROL_HIDDEN(CONTROL_LABEL);
+
+  CGUIDialogVolumeBar* dialogVolumeBar = dynamic_cast<CGUIDialogVolumeBar*>(
+      CServiceBroker::GetGUI()->GetWindowManager().GetWindow(WINDOW_DIALOG_VOLUME_BAR));
+  if (dialogVolumeBar != nullptr)
+    dialogVolumeBar->RegisterCallback(this);
+
+  CServiceBroker::GetAnnouncementManager()->AddAnnouncer(this);
+}
+
+void CDialogGameVolume::OnDeinitWindow(int nextWindowID)
+{
+  CServiceBroker::GetAnnouncementManager()->RemoveAnnouncer(this);
+
+  CGUIDialogVolumeBar* dialogVolumeBar = dynamic_cast<CGUIDialogVolumeBar*>(
+      CServiceBroker::GetGUI()->GetWindowManager().GetWindow(WINDOW_DIALOG_VOLUME_BAR));
+  if (dialogVolumeBar != nullptr)
+    dialogVolumeBar->UnregisterCallback(this);
+
+  CGUIDialogSlider::OnDeinitWindow(nextWindowID);
+}
+
+void CDialogGameVolume::OnSliderChange(void* data, CGUISliderControl* slider)
+{
+  const float volumePercent = slider->GetFloatValue();
+
+  if (std::fabs(volumePercent - m_volumePercent) > 0.1f)
+  {
+    m_volumePercent = volumePercent;
+    auto& components = CServiceBroker::GetAppComponents();
+    const auto appVolume = components.GetComponent<CApplicationVolumeHandling>();
+    appVolume->SetVolume(volumePercent, true);
+  }
+}
+
+bool CDialogGameVolume::IsShown() const
+{
+  return m_active;
+}
+
+void CDialogGameVolume::Announce(ANNOUNCEMENT::AnnouncementFlag flag,
+                                 const std::string& sender,
+                                 const std::string& message,
+                                 const CVariant& data)
+{
+  if (flag == ANNOUNCEMENT::Application && message == "OnVolumeChanged")
+  {
+    const float volumePercent = static_cast<float>(data["volume"].asDouble());
+
+    if (std::fabs(volumePercent - m_volumePercent) > 0.1f)
+    {
+      m_volumePercent = volumePercent;
+
+      CGUIMessage msg(GUI_MSG_STATE_CHANGED, GetID(), GetID());
+      CServiceBroker::GetGUI()->GetWindowManager().SendThreadMessage(msg);
+    }
+  }
+}
+
+void CDialogGameVolume::OnStateChanged()
+{
+  if (m_volumePercent != m_oldVolumePercent)
+  {
+    m_oldVolumePercent = m_volumePercent;
+    SetSlider(GetLabel(), m_volumePercent, VOLUME_MIN, VOLUME_DELTA, VOLUME_MAX, this, nullptr);
+  }
+}
+
+float CDialogGameVolume::GetVolumePercent() const
+{
+  const auto& components = CServiceBroker::GetAppComponents();
+  const auto appVolume = components.GetComponent<CApplicationVolumeHandling>();
+  return appVolume->GetVolumePercent();
+}
+
+std::string CDialogGameVolume::GetLabel()
+{
+  return g_localizeStrings.Get(13376); // "Volume"
+}
diff --git a/xbmc/games/dialogs/osd/DialogGameVolume.h b/xbmc/games/dialogs/osd/DialogGameVolume.h
new file mode 100644
index 0000000..a32339d
--- /dev/null
+++ b/xbmc/games/dialogs/osd/DialogGameVolume.h
@@ -0,0 +1,80 @@
+/*
+ *  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 "dialogs/GUIDialogSlider.h"
+#include "dialogs/IGUIVolumeBarCallback.h"
+#include "guilib/ISliderCallback.h"
+#include "interfaces/IAnnouncer.h"
+
+#include <set>
+
+namespace KODI
+{
+
+namespace GAME
+{
+class CDialogGameVolume : public CGUIDialogSlider, // GUI interface
+                          public ISliderCallback, // GUI callback
+                          public IGUIVolumeBarCallback, // Volume bar dialog callback
+                          public ANNOUNCEMENT::IAnnouncer // Application callback
+{
+public:
+  CDialogGameVolume();
+  ~CDialogGameVolume() override = default;
+
+  // implementation of CGUIControl via CGUIDialogSlider
+  bool OnMessage(CGUIMessage& message) override;
+
+  // implementation of CGUIWindow via CGUIDialogSlider
+  void OnDeinitWindow(int nextWindowID) override;
+
+  // implementation of ISliderCallback
+  void OnSliderChange(void* data, CGUISliderControl* slider) override;
+
+  // implementation of IGUIVolumeBarCallback
+  bool IsShown() const override;
+
+  // implementation of IAnnouncer
+  void Announce(ANNOUNCEMENT::AnnouncementFlag flag,
+                const std::string& sender,
+                const std::string& message,
+                const CVariant& data) override;
+
+protected:
+  // implementation of CGUIWindow via CGUIDialogSlider
+  void OnInitWindow() override;
+
+private:
+  /*!
+   * \brief Call when state change message is received
+   */
+  void OnStateChanged();
+
+  /*!
+   * \brief Get the volume of the first callback
+   *
+   * \return The volume, as a fraction of maximum volume
+   */
+  float GetVolumePercent() const;
+
+  /*!
+   * \brief Get the volume bar label
+   */
+  static std::string GetLabel();
+
+  // Volume parameters
+  const float VOLUME_MIN = 0.0f;
+  const float VOLUME_DELTA = 10.0f;
+  const float VOLUME_MAX = 100.0f;
+  float m_volumePercent = 100.0f;
+  float m_oldVolumePercent = 100.0f;
+};
+} // namespace GAME
+} // namespace KODI
diff --git a/xbmc/games/dialogs/osd/DialogInGameSaves.cpp b/xbmc/games/dialogs/osd/DialogInGameSaves.cpp
new file mode 100644
index 0000000..9f66fd5
--- /dev/null
+++ b/xbmc/games/dialogs/osd/DialogInGameSaves.cpp
@@ -0,0 +1,426 @@
+/*
+ *  Copyright (C) 2020-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 "DialogInGameSaves.h"
+
+#include "ServiceBroker.h"
+#include "URL.h"
+#include "XBDateTime.h"
+#include "cores/RetroPlayer/guibridge/GUIGameRenderManager.h"
+#include "cores/RetroPlayer/guibridge/GUIGameSettingsHandle.h"
+#include "cores/RetroPlayer/guicontrols/GUIGameControl.h"
+#include "cores/RetroPlayer/playback/IPlayback.h"
+#include "cores/RetroPlayer/savestates/ISavestate.h"
+#include "cores/RetroPlayer/savestates/SavestateDatabase.h"
+#include "dialogs/GUIDialogContextMenu.h"
+#include "dialogs/GUIDialogOK.h"
+#include "dialogs/GUIDialogYesNo.h"
+#include "games/dialogs/DialogGameDefines.h"
+#include "guilib/GUIKeyboardFactory.h"
+#include "guilib/GUIMessage.h"
+#include "guilib/LocalizeStrings.h"
+#include "guilib/WindowIDs.h"
+#include "settings/GameSettings.h"
+#include "settings/MediaSettings.h"
+#include "utils/log.h"
+
+using namespace KODI;
+using namespace GAME;
+using namespace RETRO;
+
+namespace
+{
+CFileItemPtr CreateNewSaveItem()
+{
+  CFileItemPtr item = std::make_shared<CFileItem>(g_localizeStrings.Get(15314)); // "Save"
+
+  // A nonexistent path ensures a gamewindow control won't render any pixels
+  item->SetPath(NO_PIXEL_DATA);
+  item->SetArt("icon", "DefaultAddSource.png");
+  item->SetProperty(SAVESTATE_CAPTION,
+                    g_localizeStrings.Get(15315)); // "Save progress to a new save file"
+
+  return item;
+}
+} // namespace
+
+CDialogInGameSaves::CDialogInGameSaves()
+  : CDialogGameVideoSelect(WINDOW_DIALOG_IN_GAME_SAVES), m_newSaveItem(CreateNewSaveItem())
+{
+}
+
+bool CDialogInGameSaves::OnMessage(CGUIMessage& message)
+{
+  switch (message.GetMessage())
+  {
+    case GUI_MSG_REFRESH_THUMBS:
+    {
+      if (message.GetControlId() == GetID())
+      {
+        const std::string& itemPath = message.GetStringParam();
+        CGUIListItemPtr itemInfo = message.GetItem();
+
+        if (!itemPath.empty())
+        {
+          OnItemRefresh(itemPath, std::move(itemInfo));
+        }
+        else
+        {
+          InitSavedGames();
+          RefreshList();
+        }
+
+        return true;
+      }
+      break;
+    }
+    default:
+      break;
+  }
+
+  return CDialogGameVideoSelect::OnMessage(message);
+}
+
+std::string CDialogInGameSaves::GetHeading()
+{
+  return g_localizeStrings.Get(35249); // "Save / Load"
+}
+
+void CDialogInGameSaves::PreInit()
+{
+  InitSavedGames();
+}
+
+void CDialogInGameSaves::InitSavedGames()
+{
+  m_savestateItems.Clear();
+
+  auto gameSettings = CServiceBroker::GetGameRenderManager().RegisterGameSettingsDialog();
+
+  CSavestateDatabase db;
+  db.GetSavestatesNav(m_savestateItems, gameSettings->GetPlayingGame(),
+                      gameSettings->GameClientID());
+
+  m_savestateItems.Sort(SortByDate, SortOrderDescending);
+}
+
+void CDialogInGameSaves::GetItems(CFileItemList& items)
+{
+  items.Add(m_newSaveItem);
+  std::for_each(m_savestateItems.cbegin(), m_savestateItems.cend(),
+                [&items](const auto& item) { items.Add(item); });
+}
+
+void CDialogInGameSaves::OnItemFocus(unsigned int index)
+{
+  if (static_cast<int>(index) < 1 + m_savestateItems.Size())
+    m_focusedItemIndex = index;
+}
+
+unsigned int CDialogInGameSaves::GetFocusedItem() const
+{
+  return m_focusedControl;
+}
+
+void CDialogInGameSaves::OnItemRefresh(const std::string& itemPath, CGUIListItemPtr itemInfo)
+{
+  // Turn the message params into a savestate item
+  CFileItemPtr item = TranslateMessageItem(itemPath, std::move(itemInfo));
+  if (item)
+  {
+    // Look up existing savestate by path
+    auto it =
+        std::find_if(m_savestateItems.cbegin(), m_savestateItems.cend(),
+                     [&itemPath](const CFileItemPtr& item) { return item->GetPath() == itemPath; });
+
+    // Update savestate or add a new one
+    if (it != m_savestateItems.cend())
+      **it = std::move(*item);
+    else
+      m_savestateItems.AddFront(std::move(item), 0);
+
+    RefreshList();
+  }
+}
+
+void CDialogInGameSaves::PostExit()
+{
+  m_savestateItems.Clear();
+}
+
+bool CDialogInGameSaves::OnClickAction()
+{
+  if (static_cast<int>(m_focusedItemIndex) < 1 + m_savestateItems.Size())
+  {
+    if (m_focusedItemIndex <= 0)
+    {
+      OnNewSave();
+      return true;
+    }
+    else
+    {
+      CFileItemPtr focusedItem = m_savestateItems[m_focusedItemIndex - 1];
+      if (focusedItem)
+      {
+        OnLoad(*focusedItem);
+        return true;
+      }
+    }
+  }
+
+  return false;
+}
+
+bool CDialogInGameSaves::OnMenuAction()
+{
+  // Start at index 1 to account for leading "Save" item
+  if (1 <= m_focusedItemIndex && static_cast<int>(m_focusedItemIndex) < 1 + m_savestateItems.Size())
+  {
+    CFileItemPtr focusedItem = m_savestateItems[m_focusedItemIndex - 1];
+    if (focusedItem)
+    {
+      CContextButtons buttons;
+
+      buttons.Add(0, 13206); // "Overwrite"
+      buttons.Add(1, 118); // "Rename"
+      buttons.Add(2, 117); // "Delete"
+
+      const int index = CGUIDialogContextMenu::Show(buttons);
+
+      if (index == 0)
+        OnOverwrite(*focusedItem);
+      if (index == 1)
+        OnRename(*focusedItem);
+      else if (index == 2)
+        OnDelete(*focusedItem);
+
+      return true;
+    }
+  }
+
+  return false;
+}
+
+bool CDialogInGameSaves::OnOverwriteAction()
+{
+  // Start at index 1 to account for leading "Save" item
+  if (1 <= m_focusedItemIndex && static_cast<int>(m_focusedItemIndex) < 1 + m_savestateItems.Size())
+  {
+    CFileItemPtr focusedItem = m_savestateItems[m_focusedItemIndex - 1];
+    if (focusedItem)
+    {
+      OnOverwrite(*focusedItem);
+      return true;
+    }
+  }
+
+  return false;
+}
+
+bool CDialogInGameSaves::OnRenameAction()
+{
+  // Start at index 1 to account for leading "Save" item
+  if (1 <= m_focusedItemIndex && static_cast<int>(m_focusedItemIndex) < 1 + m_savestateItems.Size())
+  {
+    CFileItemPtr focusedItem = m_savestateItems[m_focusedItemIndex - 1];
+    if (focusedItem)
+    {
+      OnRename(*focusedItem);
+      return true;
+    }
+  }
+
+  return false;
+}
+
+bool CDialogInGameSaves::OnDeleteAction()
+{
+  // Start at index 1 to account for leading "Save" item
+  if (1 <= m_focusedItemIndex && static_cast<int>(m_focusedItemIndex) < 1 + m_savestateItems.Size())
+  {
+    CFileItemPtr focusedItem = m_savestateItems[m_focusedItemIndex - 1];
+    if (focusedItem)
+    {
+      OnDelete(*focusedItem);
+      return true;
+    }
+  }
+
+  return false;
+}
+
+void CDialogInGameSaves::OnNewSave()
+{
+  auto gameSettings = CServiceBroker::GetGameRenderManager().RegisterGameSettingsDialog();
+
+  const std::string savestatePath = gameSettings->CreateSavestate(false);
+  if (savestatePath.empty())
+  {
+    // "Error"
+    // "An unknown error has occurred."
+    CGUIDialogOK::ShowAndGetInput(257, 24071);
+    return;
+  }
+
+  // Create a simulated savestate to update the GUI faster. We will be notified
+  // of the real savestate info via OnMessage() when the savestate creation
+  // completes.
+  auto savestate = RETRO::CSavestateDatabase::AllocateSavestate();
+
+  savestate->SetType(SAVE_TYPE::MANUAL);
+  savestate->SetCreated(CDateTime::GetUTCDateTime());
+
+  savestate->Finalize();
+
+  CFileItemPtr item = std::make_shared<CFileItem>();
+  CSavestateDatabase::GetSavestateItem(*savestate, savestatePath, *item);
+
+  m_savestateItems.AddFront(std::move(item), 0);
+
+  RefreshList();
+}
+
+void CDialogInGameSaves::OnLoad(CFileItem& focusedItem)
+{
+  auto gameSettings = CServiceBroker::GetGameRenderManager().RegisterGameSettingsDialog();
+
+  // Load savestate
+  if (gameSettings->LoadSavestate(focusedItem.GetPath()))
+  {
+    // Close OSD on successful load
+    gameSettings->CloseOSD();
+  }
+  else
+  {
+    // "Error"
+    // "An unknown error has occurred."
+    CGUIDialogOK::ShowAndGetInput(257, 24071);
+  }
+}
+
+void CDialogInGameSaves::OnOverwrite(CFileItem& focusedItem)
+{
+  std::string savestatePath = focusedItem.GetPath();
+  if (savestatePath.empty())
+    return;
+
+  auto gameSettings = CServiceBroker::GetGameRenderManager().RegisterGameSettingsDialog();
+
+  // Update savestate
+  if (gameSettings->UpdateSavestate(savestatePath))
+  {
+    // Create a simulated savestate to update the GUI faster. We will be
+    // notified of the real savestate info via OnMessage() when the
+    // overwriting completes.
+    auto savestate = RETRO::CSavestateDatabase::AllocateSavestate();
+
+    savestate->SetType(SAVE_TYPE::MANUAL);
+    savestate->SetLabel(focusedItem.GetProperty(SAVESTATE_LABEL).asString());
+    savestate->SetCaption(focusedItem.GetProperty(SAVESTATE_CAPTION).asString());
+    savestate->SetCreated(CDateTime::GetUTCDateTime());
+
+    savestate->Finalize();
+
+    CSavestateDatabase::GetSavestateItem(*savestate, savestatePath, focusedItem);
+
+    RefreshList();
+  }
+  else
+  {
+    // Log an error and notify the user
+    CLog::Log(LOGERROR, "Failed to overwrite savestate at {}", CURL::GetRedacted(savestatePath));
+
+    // "Error"
+    // "An unknown error has occurred."
+    CGUIDialogOK::ShowAndGetInput(257, 24071);
+  }
+}
+
+void CDialogInGameSaves::OnRename(CFileItem& focusedItem)
+{
+  const std::string& savestatePath = focusedItem.GetPath();
+  if (savestatePath.empty())
+    return;
+
+  RETRO::CSavestateDatabase db;
+
+  std::string label;
+
+  std::unique_ptr<RETRO::ISavestate> savestate = RETRO::CSavestateDatabase::AllocateSavestate();
+  if (db.GetSavestate(savestatePath, *savestate))
+    label = savestate->Label();
+
+  // "Enter new filename"
+  if (CGUIKeyboardFactory::ShowAndGetInput(label, CVariant{g_localizeStrings.Get(16013)}, true) &&
+      label != savestate->Label())
+  {
+    std::unique_ptr<RETRO::ISavestate> newSavestate = db.RenameSavestate(savestatePath, label);
+    if (newSavestate)
+    {
+      RETRO::CSavestateDatabase::GetSavestateItem(*newSavestate, savestatePath, focusedItem);
+
+      RefreshList();
+    }
+    else
+    {
+      // "Error"
+      // "An unknown error has occurred."
+      CGUIDialogOK::ShowAndGetInput(257, 24071);
+    }
+  }
+}
+
+void CDialogInGameSaves::OnDelete(CFileItem& focusedItem)
+{
+  // "Confirm delete"
+  // "Would you like to delete the selected file(s)?[CR]Warning - this action can't be undone!"
+  if (CGUIDialogYesNo::ShowAndGetInput(CVariant{122}, CVariant{125}))
+  {
+    RETRO::CSavestateDatabase db;
+    if (db.DeleteSavestate(focusedItem.GetPath()))
+    {
+      m_savestateItems.Remove(&focusedItem);
+
+      RefreshList();
+
+      auto gameSettings = CServiceBroker::GetGameRenderManager().RegisterGameSettingsDialog();
+      gameSettings->FreeSavestateResources(focusedItem.GetPath());
+    }
+    else
+    {
+      // "Error"
+      // "An unknown error has occurred."
+      CGUIDialogOK::ShowAndGetInput(257, 24071);
+    }
+  }
+}
+
+CFileItemPtr CDialogInGameSaves::TranslateMessageItem(const std::string& messagePath,
+                                                      CGUIListItemPtr messageItem)
+{
+  CFileItemPtr item;
+
+  if (messageItem && messageItem->IsFileItem())
+    item = std::static_pointer_cast<CFileItem>(messageItem);
+  else if (messageItem)
+    item = std::make_shared<CFileItem>(*messageItem);
+  else if (!messagePath.empty())
+  {
+    item = std::make_shared<CFileItem>();
+
+    // Load savestate if no item info was given
+    auto savestate = RETRO::CSavestateDatabase::AllocateSavestate();
+    RETRO::CSavestateDatabase db;
+    if (db.GetSavestate(messagePath, *savestate))
+      RETRO::CSavestateDatabase::GetSavestateItem(*savestate, messagePath, *item);
+    else
+      item.reset();
+  }
+
+  return item;
+}
diff --git a/xbmc/games/dialogs/osd/DialogInGameSaves.h b/xbmc/games/dialogs/osd/DialogInGameSaves.h
new file mode 100644
index 0000000..6f98f94
--- /dev/null
+++ b/xbmc/games/dialogs/osd/DialogInGameSaves.h
@@ -0,0 +1,79 @@
+/*
+ *  Copyright (C) 2020-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 "DialogGameVideoSelect.h"
+#include "FileItem.h"
+#include "guilib/GUIListItem.h"
+
+#include <string>
+
+namespace KODI
+{
+namespace GAME
+{
+class CDialogInGameSaves : public CDialogGameVideoSelect
+{
+public:
+  CDialogInGameSaves();
+  ~CDialogInGameSaves() override = default;
+
+  // implementation of CGUIControl via CDialogGameVideoSelect
+  bool OnMessage(CGUIMessage& message) override;
+
+protected:
+  // implementation of CDialogGameVideoSelect
+  std::string GetHeading() override;
+  void PreInit() override;
+  void GetItems(CFileItemList& items) override;
+  void OnItemFocus(unsigned int index) override;
+  unsigned int GetFocusedItem() const override;
+  void PostExit() override;
+  bool OnClickAction() override;
+  bool OnMenuAction() override;
+  bool OnOverwriteAction() override;
+  bool OnRenameAction() override;
+  bool OnDeleteAction() override;
+
+  void OnNewSave();
+  void OnLoad(CFileItem& focusedItem);
+  void OnOverwrite(CFileItem& focusedItem);
+  void OnRename(CFileItem& focusedItem);
+  void OnDelete(CFileItem& focusedItem);
+
+private:
+  void InitSavedGames();
+  void OnItemRefresh(const std::string& itemPath, CGUIListItemPtr itemInfo);
+
+  /*!
+   * \brief Translates the GUI list item received in a GUI message into a
+   *        CFileItem with savestate properties
+   *
+   * When a savestate is overwritten, we optimistically populate the GUI list
+   * with a simulated savestate for immediate user feedback. Later (about a
+   * quarter second) a message arrives with the real savestate info.
+   *
+   * \param messagePath The savestate path, pass as the message's string param
+   * \param messageItem The savestate info, if known, or empty if unknown
+   *
+   * If messageItem is empty, the savestate will be loaded from disk, which
+   * is potentially expensive.
+   *
+   * \return A savestate item for the GUI, or empty if no savestate information
+   *         can be obtained
+   */
+  static CFileItemPtr TranslateMessageItem(const std::string& messagePath,
+                                           CGUIListItemPtr messageItem);
+
+  CFileItemList m_savestateItems;
+  const CFileItemPtr m_newSaveItem;
+  unsigned int m_focusedItemIndex = false;
+};
+} // namespace GAME
+} // namespace KODI
diff --git a/xbmc/games/ports/input/CMakeLists.txt b/xbmc/games/ports/input/CMakeLists.txt
new file mode 100644
index 0000000..5b2b27f
--- /dev/null
+++ b/xbmc/games/ports/input/CMakeLists.txt
@@ -0,0 +1,11 @@
+set(SOURCES PhysicalPort.cpp
+            PortInput.cpp
+            PortManager.cpp
+)
+
+set(HEADERS PhysicalPort.h
+            PortInput.h
+            PortManager.h
+)
+
+core_add_library(games_ports_input)
diff --git a/xbmc/games/ports/input/PhysicalPort.cpp b/xbmc/games/ports/input/PhysicalPort.cpp
new file mode 100644
index 0000000..9c53c76
--- /dev/null
+++ b/xbmc/games/ports/input/PhysicalPort.cpp
@@ -0,0 +1,66 @@
+/*
+ *  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 "PhysicalPort.h"
+
+#include "games/controllers/ControllerDefinitions.h"
+#include "utils/XMLUtils.h"
+#include "utils/log.h"
+
+#include <algorithm>
+#include <utility>
+
+using namespace KODI;
+using namespace GAME;
+
+CPhysicalPort::CPhysicalPort(std::string portId, std::vector<std::string> accepts)
+  : m_portId(std::move(portId)), m_accepts(std::move(accepts))
+{
+}
+
+void CPhysicalPort::Reset()
+{
+  CPhysicalPort defaultPort;
+  *this = std::move(defaultPort);
+}
+
+bool CPhysicalPort::IsCompatible(const std::string& controllerId) const
+{
+  return std::find(m_accepts.begin(), m_accepts.end(), controllerId) != m_accepts.end();
+}
+
+bool CPhysicalPort::Deserialize(const TiXmlElement* pElement)
+{
+  if (pElement == nullptr)
+    return false;
+
+  Reset();
+
+  m_portId = XMLUtils::GetAttribute(pElement, LAYOUT_XML_ATTR_PORT_ID);
+
+  for (const TiXmlElement* pChild = pElement->FirstChildElement(); pChild != nullptr;
+       pChild = pChild->NextSiblingElement())
+  {
+    if (pChild->ValueStr() == LAYOUT_XML_ELM_ACCEPTS)
+    {
+      std::string controller = XMLUtils::GetAttribute(pChild, LAYOUT_XML_ATTR_CONTROLLER);
+
+      if (!controller.empty())
+        m_accepts.emplace_back(std::move(controller));
+      else
+        CLog::Log(LOGWARNING, "<{}> tag is missing \"{}\" attribute", LAYOUT_XML_ELM_ACCEPTS,
+                  LAYOUT_XML_ATTR_CONTROLLER);
+    }
+    else
+    {
+      CLog::Log(LOGDEBUG, "Unknown physical topology port tag: <{}>", pChild->ValueStr());
+    }
+  }
+
+  return true;
+}
diff --git a/xbmc/games/ports/input/PhysicalPort.h b/xbmc/games/ports/input/PhysicalPort.h
new file mode 100644
index 0000000..83fe3a5
--- /dev/null
+++ b/xbmc/games/ports/input/PhysicalPort.h
@@ -0,0 +1,64 @@
+/*
+ *  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 <string>
+#include <vector>
+
+class TiXmlElement;
+
+namespace KODI
+{
+namespace GAME
+{
+
+class CPhysicalPort
+{
+public:
+  CPhysicalPort() = default;
+
+  /*!
+   * \brief Create a controller port
+   *
+   * \param portId The port's ID
+   * \param accepts A list of controller IDs that this port accepts
+   */
+  CPhysicalPort(std::string portId, std::vector<std::string> accepts);
+
+  void Reset();
+
+  /*!
+   * \brief Get the ID of the port
+   *
+   * \return The port's ID, e.g. "1", as a string
+   */
+  const std::string& ID() const { return m_portId; }
+
+  /*!
+   * \brief Get the controllers that can connect to this port
+   *
+   * \return A list of controllers that are physically compatible with this port
+   */
+  const std::vector<std::string>& Accepts() const { return m_accepts; }
+
+  /*!
+   * \brief Check if the controller is compatible with this port
+   *
+   * \return True if the controller is accepted, false otherwise
+   */
+  bool IsCompatible(const std::string& controllerId) const;
+
+  bool Deserialize(const TiXmlElement* pElement);
+
+private:
+  std::string m_portId;
+  std::vector<std::string> m_accepts;
+};
+} // namespace GAME
+} // namespace KODI
diff --git a/xbmc/games/ports/input/PortInput.cpp b/xbmc/games/ports/input/PortInput.cpp
new file mode 100644
index 0000000..af1652b
--- /dev/null
+++ b/xbmc/games/ports/input/PortInput.cpp
@@ -0,0 +1,129 @@
+/*
+ *  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 "PortInput.h"
+
+#include "games/addons/GameClient.h"
+#include "games/controllers/input/InputSink.h"
+#include "guilib/WindowIDs.h"
+#include "input/joysticks/keymaps/KeymapHandling.h"
+#include "peripherals/devices/Peripheral.h"
+
+using namespace KODI;
+using namespace GAME;
+
+CPortInput::CPortInput(JOYSTICK::IInputHandler* gameInput)
+  : m_gameInput(gameInput), m_inputSink(new CInputSink(gameInput))
+{
+}
+
+CPortInput::~CPortInput() = default;
+
+void CPortInput::RegisterInput(JOYSTICK::IInputProvider* provider)
+{
+  // Give input sink the lowest priority by registering it before the other
+  // input handlers
+  provider->RegisterInputHandler(m_inputSink.get(), false);
+
+  // Register input handler
+  provider->RegisterInputHandler(this, false);
+
+  // Register GUI input
+  m_appInput.reset(new JOYSTICK::CKeymapHandling(provider, false, this));
+}
+
+void CPortInput::UnregisterInput(JOYSTICK::IInputProvider* provider)
+{
+  // Unregister in reverse order
+  if (provider == nullptr && m_appInput)
+    m_appInput->UnregisterInputProvider();
+  m_appInput.reset();
+
+  if (provider != nullptr)
+  {
+    provider->UnregisterInputHandler(this);
+    provider->UnregisterInputHandler(m_inputSink.get());
+  }
+}
+
+std::string CPortInput::ControllerID() const
+{
+  return m_gameInput->ControllerID();
+}
+
+bool CPortInput::AcceptsInput(const std::string& feature) const
+{
+  return m_gameInput->AcceptsInput(feature);
+}
+
+bool CPortInput::OnButtonPress(const std::string& feature, bool bPressed)
+{
+  if (bPressed && !m_gameInput->AcceptsInput(feature))
+    return false;
+
+  return m_gameInput->OnButtonPress(feature, bPressed);
+}
+
+void CPortInput::OnButtonHold(const std::string& feature, unsigned int holdTimeMs)
+{
+  m_gameInput->OnButtonHold(feature, holdTimeMs);
+}
+
+bool CPortInput::OnButtonMotion(const std::string& feature,
+                                float magnitude,
+                                unsigned int motionTimeMs)
+{
+  if (magnitude > 0.0f && !m_gameInput->AcceptsInput(feature))
+    return false;
+
+  return m_gameInput->OnButtonMotion(feature, magnitude, motionTimeMs);
+}
+
+bool CPortInput::OnAnalogStickMotion(const std::string& feature,
+                                     float x,
+                                     float y,
+                                     unsigned int motionTimeMs)
+{
+  if ((x != 0.0f || y != 0.0f) && !m_gameInput->AcceptsInput(feature))
+    return false;
+
+  return m_gameInput->OnAnalogStickMotion(feature, x, y, motionTimeMs);
+}
+
+bool CPortInput::OnAccelerometerMotion(const std::string& feature, float x, float y, float z)
+{
+  if (!m_gameInput->AcceptsInput(feature))
+    return false;
+
+  return m_gameInput->OnAccelerometerMotion(feature, x, y, z);
+}
+
+bool CPortInput::OnWheelMotion(const std::string& feature,
+                               float position,
+                               unsigned int motionTimeMs)
+{
+  if ((position != 0.0f) && !m_gameInput->AcceptsInput(feature))
+    return false;
+
+  return m_gameInput->OnWheelMotion(feature, position, motionTimeMs);
+}
+
+bool CPortInput::OnThrottleMotion(const std::string& feature,
+                                  float position,
+                                  unsigned int motionTimeMs)
+{
+  if ((position != 0.0f) && !m_gameInput->AcceptsInput(feature))
+    return false;
+
+  return m_gameInput->OnThrottleMotion(feature, position, motionTimeMs);
+}
+
+int CPortInput::GetWindowID() const
+{
+  return WINDOW_FULLSCREEN_GAME;
+}
diff --git a/xbmc/games/ports/input/PortInput.h b/xbmc/games/ports/input/PortInput.h
new file mode 100644
index 0000000..d3c6524
--- /dev/null
+++ b/xbmc/games/ports/input/PortInput.h
@@ -0,0 +1,77 @@
+/*
+ *  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/KeymapEnvironment.h"
+#include "input/joysticks/interfaces/IInputHandler.h"
+
+#include <memory>
+
+namespace KODI
+{
+namespace JOYSTICK
+{
+class CKeymapHandling;
+class IInputProvider;
+} // namespace JOYSTICK
+
+namespace GAME
+{
+class CPortInput : public JOYSTICK::IInputHandler, public IKeymapEnvironment
+{
+public:
+  CPortInput(JOYSTICK::IInputHandler* gameInput);
+  ~CPortInput() override;
+
+  void RegisterInput(JOYSTICK::IInputProvider* provider);
+  void UnregisterInput(JOYSTICK::IInputProvider* provider);
+
+  JOYSTICK::IInputHandler* InputHandler() { return m_gameInput; }
+
+  // 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 {}
+
+  // Implementation of IKeymapEnvironment
+  int GetWindowID() const override;
+  void SetWindowID(int windowId) override {}
+  int GetFallthrough(int windowId) const override { return -1; }
+  bool UseGlobalFallthrough() const override { return false; }
+  bool UseEasterEgg() const override { return false; }
+
+private:
+  // Construction parameters
+  JOYSTICK::IInputHandler* const m_gameInput;
+
+  // Handles input to Kodi
+  std::unique_ptr<JOYSTICK::CKeymapHandling> m_appInput;
+
+  // Prevents input falling through to Kodi when not handled by the game
+  std::unique_ptr<JOYSTICK::IInputHandler> m_inputSink;
+};
+} // namespace GAME
+} // namespace KODI
diff --git a/xbmc/games/ports/input/PortManager.cpp b/xbmc/games/ports/input/PortManager.cpp
new file mode 100644
index 0000000..a04177a
--- /dev/null
+++ b/xbmc/games/ports/input/PortManager.cpp
@@ -0,0 +1,347 @@
+/*
+ *  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 "PortManager.h"
+
+#include "URL.h"
+#include "games/controllers/Controller.h"
+#include "games/controllers/types/ControllerHub.h"
+#include "games/controllers/types/ControllerNode.h"
+#include "games/ports/types/PortNode.h"
+#include "utils/FileUtils.h"
+#include "utils/URIUtils.h"
+#include "utils/XBMCTinyXML.h"
+#include "utils/XMLUtils.h"
+#include "utils/log.h"
+
+#include <algorithm>
+
+using namespace KODI;
+using namespace GAME;
+
+namespace
+{
+constexpr const char* PORT_XML_FILE = "ports.xml";
+constexpr const char* XML_ROOT_PORTS = "ports";
+constexpr const char* XML_ELM_PORT = "port";
+constexpr const char* XML_ELM_CONTROLLER = "controller";
+constexpr const char* XML_ATTR_PORT_ID = "id";
+constexpr const char* XML_ATTR_PORT_ADDRESS = "address";
+constexpr const char* XML_ATTR_PORT_CONNECTED = "connected";
+constexpr const char* XML_ATTR_PORT_CONTROLLER = "controller";
+constexpr const char* XML_ATTR_CONTROLLER_ID = "id";
+} // namespace
+
+CPortManager::CPortManager() = default;
+
+CPortManager::~CPortManager() = default;
+
+void CPortManager::Initialize(const std::string& profilePath)
+{
+  m_xmlPath = URIUtils::AddFileToFolder(profilePath, PORT_XML_FILE);
+}
+
+void CPortManager::Deinitialize()
+{
+  // Wait for save tasks
+  for (std::future<void>& task : m_saveFutures)
+    task.wait();
+  m_saveFutures.clear();
+
+  m_controllerTree.Clear();
+  m_xmlPath.clear();
+}
+
+void CPortManager::SetControllerTree(const CControllerTree& controllerTree)
+{
+  m_controllerTree = controllerTree;
+}
+
+void CPortManager::LoadXML()
+{
+  if (!CFileUtils::Exists(m_xmlPath))
+  {
+    CLog::Log(LOGDEBUG, "Can't load port config, file doesn't exist: {}", m_xmlPath);
+    return;
+  }
+
+  CLog::Log(LOGINFO, "Loading port layout: {}", CURL::GetRedacted(m_xmlPath));
+
+  CXBMCTinyXML xmlDoc;
+  if (!xmlDoc.LoadFile(m_xmlPath))
+  {
+    CLog::Log(LOGDEBUG, "Unable to load file: {} at line {}", xmlDoc.ErrorDesc(),
+              xmlDoc.ErrorRow());
+    return;
+  }
+
+  const TiXmlElement* pRootElement = xmlDoc.RootElement();
+  if (pRootElement == nullptr || pRootElement->NoChildren() ||
+      pRootElement->ValueStr() != XML_ROOT_PORTS)
+  {
+    CLog::Log(LOGERROR, "Can't find root <{}> tag", XML_ROOT_PORTS);
+    return;
+  }
+
+  DeserializePorts(pRootElement, m_controllerTree.GetPorts());
+}
+
+void CPortManager::SaveXMLAsync()
+{
+  PortVec ports = m_controllerTree.GetPorts();
+
+  // Prune any finished save tasks
+  m_saveFutures.erase(std::remove_if(m_saveFutures.begin(), m_saveFutures.end(),
+                                     [](std::future<void>& task) {
+                                       return task.wait_for(std::chrono::seconds(0)) ==
+                                              std::future_status::ready;
+                                     }),
+                      m_saveFutures.end());
+
+  // Save async
+  std::future<void> task = std::async(std::launch::async, [this, ports = std::move(ports)]() {
+    CXBMCTinyXML doc;
+    TiXmlElement node(XML_ROOT_PORTS);
+
+    SerializePorts(node, ports);
+
+    doc.InsertEndChild(node);
+
+    std::lock_guard<std::mutex> lock(m_saveMutex);
+    doc.SaveFile(m_xmlPath);
+  });
+
+  m_saveFutures.emplace_back(std::move(task));
+}
+
+void CPortManager::Clear()
+{
+  m_xmlPath.clear();
+  m_controllerTree.Clear();
+}
+
+void CPortManager::ConnectController(const std::string& portAddress,
+                                     bool connected,
+                                     const std::string& controllerId /* = "" */)
+{
+  ConnectController(portAddress, connected, controllerId, m_controllerTree.GetPorts());
+}
+
+bool CPortManager::ConnectController(const std::string& portAddress,
+                                     bool connected,
+                                     const std::string& controllerId,
+                                     PortVec& ports)
+{
+  for (CPortNode& port : ports)
+  {
+    if (ConnectController(portAddress, connected, controllerId, port))
+      return true;
+  }
+
+  return false;
+}
+
+bool CPortManager::ConnectController(const std::string& portAddress,
+                                     bool connected,
+                                     const std::string& controllerId,
+                                     CPortNode& port)
+{
+  // Base case
+  if (port.GetAddress() == portAddress)
+  {
+    port.SetConnected(connected);
+    if (!controllerId.empty())
+      port.SetActiveController(controllerId);
+    return true;
+  }
+
+  // Check children
+  return ConnectController(portAddress, connected, controllerId, port.GetCompatibleControllers());
+}
+
+bool CPortManager::ConnectController(const std::string& portAddress,
+                                     bool connected,
+                                     const std::string& controllerId,
+                                     ControllerNodeVec& controllers)
+{
+  for (CControllerNode& controller : controllers)
+  {
+    if (ConnectController(portAddress, connected, controllerId, controller))
+      return true;
+  }
+
+  return false;
+}
+
+bool CPortManager::ConnectController(const std::string& portAddress,
+                                     bool connected,
+                                     const std::string& controllerId,
+                                     CControllerNode& controller)
+{
+  for (CPortNode& childPort : controller.GetHub().GetPorts())
+  {
+    if (ConnectController(portAddress, connected, controllerId, childPort))
+      return true;
+  }
+
+  return false;
+}
+
+void CPortManager::DeserializePorts(const TiXmlElement* pElement, PortVec& ports)
+{
+  for (const TiXmlElement* pPort = pElement->FirstChildElement(); pPort != nullptr;
+       pPort = pPort->NextSiblingElement())
+  {
+    if (pPort->ValueStr() != XML_ELM_PORT)
+    {
+      CLog::Log(LOGDEBUG, "Inside <{}> tag: Ignoring <{}> tag", pElement->ValueStr(),
+                pPort->ValueStr());
+      continue;
+    }
+
+    std::string portId = XMLUtils::GetAttribute(pPort, XML_ATTR_PORT_ID);
+
+    auto it = std::find_if(ports.begin(), ports.end(),
+                           [&portId](const CPortNode& port) { return port.GetPortID() == portId; });
+    if (it != ports.end())
+    {
+      CPortNode& port = *it;
+
+      DeserializePort(pPort, port);
+    }
+  }
+}
+
+void CPortManager::DeserializePort(const TiXmlElement* pPort, CPortNode& port)
+{
+  // Connected
+  bool connected = (XMLUtils::GetAttribute(pPort, XML_ATTR_PORT_CONNECTED) == "true");
+  port.SetConnected(connected);
+
+  // Controller
+  const std::string activeControllerId = XMLUtils::GetAttribute(pPort, XML_ATTR_PORT_CONTROLLER);
+  if (!port.SetActiveController(activeControllerId))
+    port.SetConnected(false);
+
+  DeserializeControllers(pPort, port.GetCompatibleControllers());
+}
+
+void CPortManager::DeserializeControllers(const TiXmlElement* pPort, ControllerNodeVec& controllers)
+{
+  for (const TiXmlElement* pController = pPort->FirstChildElement(); pController != nullptr;
+       pController = pController->NextSiblingElement())
+  {
+    if (pController->ValueStr() != XML_ELM_CONTROLLER)
+    {
+      CLog::Log(LOGDEBUG, "Inside <{}> tag: Ignoring <{}> tag", pPort->ValueStr(),
+                pController->ValueStr());
+      continue;
+    }
+
+    std::string controllerId = XMLUtils::GetAttribute(pController, XML_ATTR_CONTROLLER_ID);
+
+    auto it = std::find_if(controllers.begin(), controllers.end(),
+                           [&controllerId](const CControllerNode& controller) {
+                             return controller.GetController()->ID() == controllerId;
+                           });
+    if (it != controllers.end())
+    {
+      CControllerNode& controller = *it;
+
+      DeserializeController(pController, controller);
+    }
+  }
+}
+
+void CPortManager::DeserializeController(const TiXmlElement* pController,
+                                         CControllerNode& controller)
+{
+  // Child ports
+  DeserializePorts(pController, controller.GetHub().GetPorts());
+}
+
+void CPortManager::SerializePorts(TiXmlElement& node, const PortVec& ports)
+{
+  for (const CPortNode& port : ports)
+  {
+    TiXmlElement portNode(XML_ELM_PORT);
+
+    SerializePort(portNode, port);
+
+    node.InsertEndChild(portNode);
+  }
+}
+
+void CPortManager::SerializePort(TiXmlElement& portNode, const CPortNode& port)
+{
+  // Port ID
+  portNode.SetAttribute(XML_ATTR_PORT_ID, port.GetPortID());
+
+  // Port address
+  portNode.SetAttribute(XML_ATTR_PORT_ADDRESS, port.GetAddress());
+
+  // Connected state
+  portNode.SetAttribute(XML_ATTR_PORT_CONNECTED, port.IsConnected() ? "true" : "false");
+
+  // Active controller
+  if (port.GetActiveController().GetController())
+  {
+    const std::string controllerId = port.GetActiveController().GetController()->ID();
+    portNode.SetAttribute(XML_ATTR_PORT_CONTROLLER, controllerId);
+  }
+
+  // All compatible controllers
+  SerializeControllers(portNode, port.GetCompatibleControllers());
+}
+
+void CPortManager::SerializeControllers(TiXmlElement& portNode,
+                                        const ControllerNodeVec& controllers)
+{
+  for (const CControllerNode& controller : controllers)
+  {
+    // Skip controller if it has no state
+    if (!HasState(controller))
+      continue;
+
+    TiXmlElement controllerNode(XML_ELM_CONTROLLER);
+
+    SerializeController(controllerNode, controller);
+
+    portNode.InsertEndChild(controllerNode);
+  }
+}
+
+void CPortManager::SerializeController(TiXmlElement& controllerNode,
+                                       const CControllerNode& controller)
+{
+  // Controller ID
+  if (controller.GetController())
+    controllerNode.SetAttribute(XML_ATTR_CONTROLLER_ID, controller.GetController()->ID());
+
+  // Ports
+  SerializePorts(controllerNode, controller.GetHub().GetPorts());
+}
+
+bool CPortManager::HasState(const CPortNode& port)
+{
+  // Ports have state (is connected / active controller)
+  return true;
+}
+
+bool CPortManager::HasState(const CControllerNode& controller)
+{
+  // Check controller ports
+  for (const CPortNode& port : controller.GetHub().GetPorts())
+  {
+    if (HasState(port))
+      return true;
+  }
+
+  // Controller itself has no state
+  return false;
+}
diff --git a/xbmc/games/ports/input/PortManager.h b/xbmc/games/ports/input/PortManager.h
new file mode 100644
index 0000000..a02ad35
--- /dev/null
+++ b/xbmc/games/ports/input/PortManager.h
@@ -0,0 +1,81 @@
+/*
+ *  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/types/ControllerTree.h"
+
+#include <future>
+#include <mutex>
+#include <string>
+
+class TiXmlElement;
+
+namespace KODI
+{
+namespace GAME
+{
+class CPortManager
+{
+public:
+  CPortManager();
+  ~CPortManager();
+
+  void Initialize(const std::string& profilePath);
+  void Deinitialize();
+
+  void SetControllerTree(const CControllerTree& controllerTree);
+  void LoadXML();
+  void SaveXMLAsync();
+  void Clear();
+
+  void ConnectController(const std::string& portAddress,
+                         bool connected,
+                         const std::string& controllerId = "");
+
+  const CControllerTree& GetControllerTree() const { return m_controllerTree; }
+
+private:
+  static void DeserializePorts(const TiXmlElement* pElement, PortVec& ports);
+  static void DeserializePort(const TiXmlElement* pElement, CPortNode& port);
+  static void DeserializeControllers(const TiXmlElement* pElement, ControllerNodeVec& controllers);
+  static void DeserializeController(const TiXmlElement* pElement, CControllerNode& controller);
+
+  static void SerializePorts(TiXmlElement& node, const PortVec& ports);
+  static void SerializePort(TiXmlElement& portNode, const CPortNode& port);
+  static void SerializeControllers(TiXmlElement& portNode, const ControllerNodeVec& controllers);
+  static void SerializeController(TiXmlElement& controllerNode, const CControllerNode& controller);
+
+  static bool ConnectController(const std::string& portAddress,
+                                bool connected,
+                                const std::string& controllerId,
+                                PortVec& ports);
+  static bool ConnectController(const std::string& portAddress,
+                                bool connected,
+                                const std::string& controllerId,
+                                CPortNode& port);
+  static bool ConnectController(const std::string& portAddress,
+                                bool connected,
+                                const std::string& controllerId,
+                                ControllerNodeVec& controllers);
+  static bool ConnectController(const std::string& portAddress,
+                                bool connected,
+                                const std::string& controllerId,
+                                CControllerNode& controller);
+
+  static bool HasState(const CPortNode& port);
+  static bool HasState(const CControllerNode& controller);
+
+  CControllerTree m_controllerTree;
+  std::string m_xmlPath;
+
+  std::vector<std::future<void>> m_saveFutures;
+  std::mutex m_saveMutex;
+};
+} // namespace GAME
+} // namespace KODI
diff --git a/xbmc/games/ports/types/CMakeLists.txt b/xbmc/games/ports/types/CMakeLists.txt
new file mode 100644
index 0000000..735df42
--- /dev/null
+++ b/xbmc/games/ports/types/CMakeLists.txt
@@ -0,0 +1,7 @@
+set(SOURCES PortNode.cpp
+)
+
+set(HEADERS PortNode.h
+)
+
+core_add_library(games_ports_types)
diff --git a/xbmc/games/ports/types/PortNode.cpp b/xbmc/games/ports/types/PortNode.cpp
new file mode 100644
index 0000000..7caf6eb
--- /dev/null
+++ b/xbmc/games/ports/types/PortNode.cpp
@@ -0,0 +1,157 @@
+/*
+ *  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 "PortNode.h"
+
+#include "games/controllers/Controller.h"
+#include "games/controllers/types/ControllerHub.h"
+#include "games/ports/input/PhysicalPort.h"
+
+#include <algorithm>
+#include <utility>
+
+using namespace KODI;
+using namespace GAME;
+
+CPortNode::~CPortNode() = default;
+
+CPortNode& CPortNode::operator=(const CPortNode& rhs)
+{
+  if (this != &rhs)
+  {
+    m_bConnected = rhs.m_bConnected;
+    m_active = rhs.m_active;
+    m_portType = rhs.m_portType;
+    m_portId = rhs.m_portId;
+    m_address = rhs.m_address;
+    m_forceConnected = rhs.m_forceConnected;
+    m_controllers = rhs.m_controllers;
+  }
+
+  return *this;
+}
+
+CPortNode& CPortNode::operator=(CPortNode&& rhs) noexcept
+{
+  if (this != &rhs)
+  {
+    m_bConnected = rhs.m_bConnected;
+    m_active = rhs.m_active;
+    m_portType = rhs.m_portType;
+    m_portId = std::move(rhs.m_portId);
+    m_address = std::move(rhs.m_address);
+    m_forceConnected = rhs.m_forceConnected;
+    m_controllers = std::move(rhs.m_controllers);
+  }
+
+  return *this;
+}
+
+const CControllerNode& CPortNode::GetActiveController() const
+{
+  if (m_bConnected && m_active < m_controllers.size())
+    return m_controllers[m_active];
+
+  static const CControllerNode invalid{};
+  return invalid;
+}
+
+CControllerNode& CPortNode::GetActiveController()
+{
+  if (m_bConnected && m_active < m_controllers.size())
+    return m_controllers[m_active];
+
+  static CControllerNode invalid;
+  invalid.Clear();
+  return invalid;
+}
+
+bool CPortNode::SetActiveController(const std::string& controllerId)
+{
+  for (size_t i = 0; i < m_controllers.size(); ++i)
+  {
+    const ControllerPtr& controller = m_controllers.at(i).GetController();
+    if (controller && controller->ID() == controllerId)
+    {
+      m_active = i;
+      return true;
+    }
+  }
+
+  return false;
+}
+
+void CPortNode::SetPortID(std::string portId)
+{
+  m_portId = std::move(portId);
+}
+
+void CPortNode::SetAddress(std::string address)
+{
+  m_address = std::move(address);
+}
+
+void CPortNode::SetCompatibleControllers(ControllerNodeVec controllers)
+{
+  m_controllers = std::move(controllers);
+}
+
+bool CPortNode::IsControllerAccepted(const std::string& controllerId) const
+{
+  // Base case
+  CPhysicalPort port;
+  GetPort(port);
+  if (port.IsCompatible(controllerId))
+    return true;
+
+  // Visit nodes
+  return std::any_of(m_controllers.begin(), m_controllers.end(),
+                     [controllerId](const CControllerNode& node) {
+                       return node.IsControllerAccepted(controllerId);
+                     });
+}
+
+bool CPortNode::IsControllerAccepted(const std::string& portAddress,
+                                     const std::string& controllerId) const
+{
+  bool bAccepted = false;
+
+  if (m_address == portAddress)
+  {
+    // Base case
+    CPhysicalPort port;
+    GetPort(port);
+    if (port.IsCompatible(controllerId))
+      bAccepted = true;
+  }
+  else
+  {
+    // Visit nodes
+    if (std::any_of(m_controllers.begin(), m_controllers.end(),
+                    [portAddress, controllerId](const CControllerNode& node) {
+                      return node.IsControllerAccepted(portAddress, controllerId);
+                    }))
+    {
+      bAccepted = true;
+    }
+  }
+
+  return bAccepted;
+}
+
+void CPortNode::GetPort(CPhysicalPort& port) const
+{
+  std::vector<std::string> accepts;
+  for (const CControllerNode& node : m_controllers)
+  {
+    if (node.GetController())
+      accepts.emplace_back(node.GetController()->ID());
+  }
+
+  port = CPhysicalPort(m_portId, std::move(accepts));
+}
diff --git a/xbmc/games/ports/types/PortNode.h b/xbmc/games/ports/types/PortNode.h
new file mode 100644
index 0000000..660a7bc
--- /dev/null
+++ b/xbmc/games/ports/types/PortNode.h
@@ -0,0 +1,130 @@
+/*
+ *  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/controllers/types/ControllerNode.h"
+
+#include <string>
+#include <vector>
+
+namespace KODI
+{
+namespace GAME
+{
+class CPhysicalPort;
+
+/*!
+ * \brief Collection of nodes that can be connected to this port
+ */
+class CPortNode
+{
+public:
+  CPortNode() = default;
+  CPortNode(const CPortNode& other) { *this = other; }
+  CPortNode(CPortNode&& other) = default;
+  CPortNode& operator=(const CPortNode& rhs);
+  CPortNode& operator=(CPortNode&& rhs) noexcept;
+  ~CPortNode();
+
+  /*!
+   * \brief Connection state of the port
+   *
+   * \return True if a controller is connected, false otherwise
+   */
+  bool IsConnected() const { return m_bConnected; }
+  void SetConnected(bool bConnected) { m_bConnected = bConnected; }
+
+  /*!
+   * \brief The controller that is active on this port
+   *
+   * \return The active controller, or invalid if port is disconnected
+   */
+  const CControllerNode& GetActiveController() const;
+  CControllerNode& GetActiveController();
+  void SetActiveController(unsigned int controllerIndex) { m_active = controllerIndex; }
+  bool SetActiveController(const std::string& controllerId);
+
+  /*!
+   * \brief The port type
+   *
+   * \return The port type, if known
+   */
+  PORT_TYPE GetPortType() const { return m_portType; }
+  void SetPortType(PORT_TYPE type) { m_portType = type; }
+
+  /*!
+   * \brief The hardware or controller port ID
+   *
+   * \return The port ID of the hardware port or controller port, or empty if
+   *         the port is only identified by its type
+   */
+  const std::string& GetPortID() const { return m_portId; }
+  void SetPortID(std::string portId);
+
+  /*!
+   * \brief Address given to the node by the implementation
+   */
+  const std::string& GetAddress() const { return m_address; }
+  void SetAddress(std::string address);
+
+  /*!
+   * \brief If true, prevents a disconnection option from being shown for this
+   * port
+   */
+  bool IsForceConnected() const { return m_forceConnected; }
+  void SetForceConnected(bool forceConnected) { m_forceConnected = forceConnected; }
+
+  /*!
+   * \brief Return the controller profiles that are compatible with this port
+   *
+   * \return The controller profiles, or empty if this port doesn't support
+   *         any controller profiles
+   */
+  const ControllerNodeVec& GetCompatibleControllers() const { return m_controllers; }
+  ControllerNodeVec& GetCompatibleControllers() { return m_controllers; }
+  void SetCompatibleControllers(ControllerNodeVec controllers);
+
+  /*!
+   * \brief Check to see if a controller is compatible with this tree
+   *
+   * \param controllerId The ID of the controller
+   *
+   * \return True if the controller is compatible with the tree, false otherwise
+   */
+  bool IsControllerAccepted(const std::string& controllerId) const;
+
+  /*!
+   * \brief Check to see if a controller is compatible with this tree
+   *
+   * \param portAddress The port address
+   * \param controllerId The ID of the controller
+   *
+   * \return True if the controller is compatible with the tree, false otherwise
+   */
+  bool IsControllerAccepted(const std::string& portAddress, const std::string& controllerId) const;
+
+private:
+  void GetPort(CPhysicalPort& port) const;
+
+  bool m_bConnected = false;
+  unsigned int m_active = 0;
+  PORT_TYPE m_portType = PORT_TYPE::UNKNOWN;
+  std::string m_portId;
+  std::string m_address;
+  bool m_forceConnected{true};
+  ControllerNodeVec m_controllers;
+};
+
+/*!
+ * \brief Collection of port nodes
+ */
+using PortVec = std::vector<CPortNode>;
+} // namespace GAME
+} // namespace KODI
diff --git a/xbmc/games/ports/windows/CMakeLists.txt b/xbmc/games/ports/windows/CMakeLists.txt
new file mode 100644
index 0000000..4cf07ea
--- /dev/null
+++ b/xbmc/games/ports/windows/CMakeLists.txt
@@ -0,0 +1,11 @@
+set(SOURCES GUIPortList.cpp
+            GUIPortWindow.cpp
+)
+
+set(HEADERS GUIPortDefines.h
+            GUIPortList.h
+            GUIPortWindow.h
+            IPortList.h
+)
+
+core_add_library(games_ports_windows)
diff --git a/xbmc/games/ports/windows/GUIPortDefines.h b/xbmc/games/ports/windows/GUIPortDefines.h
new file mode 100644
index 0000000..c9c255b
--- /dev/null
+++ b/xbmc/games/ports/windows/GUIPortDefines.h
@@ -0,0 +1,22 @@
+/*
+ *  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
+
+// Dialog title
+#define CONTROL_PORT_DIALOG_LABEL 2
+
+// GUI control IDs
+#define CONTROL_PORT_LIST 3
+
+// GUI button IDs
+#define CONTROL_CLOSE_BUTTON 18
+#define CONTROL_RESET_BUTTON 19
+
+// Skin XML file
+#define PORT_DIALOG_XML "DialogGameControllers.xml"
diff --git a/xbmc/games/ports/windows/GUIPortList.cpp b/xbmc/games/ports/windows/GUIPortList.cpp
new file mode 100644
index 0000000..a25c94b
--- /dev/null
+++ b/xbmc/games/ports/windows/GUIPortList.cpp
@@ -0,0 +1,344 @@
+/*
+ *  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 "GUIPortList.h"
+
+#include "FileItem.h"
+#include "GUIPortDefines.h"
+#include "GUIPortWindow.h"
+#include "ServiceBroker.h"
+#include "addons/AddonManager.h"
+#include "games/GameServices.h"
+#include "games/addons/GameClient.h"
+#include "games/addons/input/GameClientInput.h"
+#include "games/controllers/Controller.h"
+#include "games/controllers/ControllerLayout.h"
+#include "games/controllers/types/ControllerHub.h"
+#include "games/controllers/types/ControllerTree.h"
+#include "games/ports/types/PortNode.h"
+#include "guilib/GUIMessage.h"
+#include "guilib/GUIWindow.h"
+#include "guilib/LocalizeStrings.h"
+#include "messaging/ApplicationMessenger.h"
+#include "messaging/helpers/DialogOKHelper.h"
+#include "utils/StringUtils.h"
+#include "utils/log.h"
+#include "view/GUIViewControl.h"
+#include "view/ViewState.h"
+
+using namespace KODI;
+using namespace ADDON;
+using namespace GAME;
+
+CGUIPortList::CGUIPortList(CGUIWindow& window)
+  : m_guiWindow(window),
+    m_viewControl(std::make_unique<CGUIViewControl>()),
+    m_vecItems(std::make_unique<CFileItemList>())
+{
+}
+
+CGUIPortList::~CGUIPortList()
+{
+  Deinitialize();
+}
+
+void CGUIPortList::OnWindowLoaded()
+{
+  m_viewControl->Reset();
+  m_viewControl->SetParentWindow(m_guiWindow.GetID());
+  m_viewControl->AddView(m_guiWindow.GetControl(CONTROL_PORT_LIST));
+}
+
+void CGUIPortList::OnWindowUnload()
+{
+  m_viewControl->Reset();
+}
+
+bool CGUIPortList::Initialize(GameClientPtr gameClient)
+{
+  // Validate parameters
+  if (!gameClient)
+    return false;
+
+  // Initialize state
+  m_gameClient = std::move(gameClient);
+  m_viewControl->SetCurrentView(DEFAULT_VIEW_LIST);
+
+  // Initialize GUI
+  Refresh();
+
+  CServiceBroker::GetAddonMgr().Events().Subscribe(this, &CGUIPortList::OnEvent);
+
+  return true;
+}
+
+void CGUIPortList::Deinitialize()
+{
+  CServiceBroker::GetAddonMgr().Events().Unsubscribe(this);
+
+  // Deinitialize GUI
+  CleanupItems();
+
+  // Reset state
+  m_gameClient.reset();
+}
+
+bool CGUIPortList::HasControl(int controlId)
+{
+  return m_viewControl->HasControl(controlId);
+}
+
+int CGUIPortList::GetCurrentControl()
+{
+  return m_viewControl->GetCurrentControl();
+}
+
+void CGUIPortList::Refresh()
+{
+  // Send a synchronous message to clear the view control
+  m_viewControl->Clear();
+
+  CleanupItems();
+
+  if (m_gameClient)
+  {
+    unsigned int itemIndex = 0;
+    for (const CPortNode& port : m_gameClient->Input().GetActiveControllerTree().GetPorts())
+      AddItems(port, itemIndex, GetLabel(port));
+
+    m_viewControl->SetItems(*m_vecItems);
+
+    // Try to restore focus to the previously focused port
+    if (!m_focusedPort.empty() && m_addressToItem.find(m_focusedPort) != m_addressToItem.end())
+    {
+      const unsigned int itemIndex = m_addressToItem[m_focusedPort];
+      m_viewControl->SetSelectedItem(itemIndex);
+      OnItemFocus(itemIndex);
+    }
+  }
+}
+
+void CGUIPortList::FrameMove()
+{
+  const int itemIndex = m_viewControl->GetSelectedItem();
+  if (itemIndex != m_currentItem)
+  {
+    m_currentItem = itemIndex;
+    if (itemIndex >= 0)
+      OnItemFocus(static_cast<unsigned int>(itemIndex));
+  }
+}
+
+void CGUIPortList::SetFocused()
+{
+  m_viewControl->SetFocused();
+}
+
+bool CGUIPortList::OnSelect()
+{
+  const int itemIndex = m_viewControl->GetSelectedItem();
+  if (itemIndex >= 0)
+  {
+    OnItemSelect(static_cast<unsigned int>(itemIndex));
+    return true;
+  }
+
+  return false;
+}
+
+void CGUIPortList::ResetPorts()
+{
+  if (m_gameClient)
+  {
+    // Update the game client
+    m_gameClient->Input().ResetPorts();
+    m_gameClient->Input().SavePorts();
+
+    // Refresh the GUI
+    CGUIMessage msg(GUI_MSG_REFRESH_LIST, m_guiWindow.GetID(), CONTROL_PORT_LIST);
+    CServiceBroker::GetAppMessenger()->SendGUIMessage(msg, m_guiWindow.GetID());
+  }
+}
+
+void CGUIPortList::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_PORT_LIST);
+    msg.SetStringParam(event.addonId);
+    CServiceBroker::GetAppMessenger()->SendGUIMessage(msg, m_guiWindow.GetID());
+  }
+}
+
+bool CGUIPortList::AddItems(const CPortNode& port,
+                            unsigned int& itemId,
+                            const std::string& itemLabel)
+{
+  // Validate parameters
+  if (itemLabel.empty())
+    return false;
+
+  // Record the port address so that we can decode item indexes later
+  m_itemToAddress[itemId] = port.GetAddress();
+  m_addressToItem[port.GetAddress()] = itemId;
+
+  if (port.IsConnected())
+  {
+    const CControllerNode& controllerNode = port.GetActiveController();
+    const ControllerPtr& controller = controllerNode.GetController();
+
+    // Create the list item
+    CFileItemPtr item = std::make_shared<CFileItem>(itemLabel);
+    item->SetLabel2(controller->Layout().Label());
+    item->SetPath(port.GetAddress());
+    item->SetArt("icon", controller->Layout().ImagePath());
+    m_vecItems->Add(std::move(item));
+    ++itemId;
+
+    // Handle items for child ports
+    const PortVec& ports = controllerNode.GetHub().GetPorts();
+    for (const CPortNode& childPort : ports)
+    {
+      std::ostringstream childItemLabel;
+      childItemLabel << " - ";
+      childItemLabel << controller->Layout().Label();
+      childItemLabel << " - ";
+      childItemLabel << GetLabel(childPort);
+
+      if (!AddItems(childPort, itemId, childItemLabel.str()))
+        return false;
+    }
+  }
+  else
+  {
+    // Create the list item
+    CFileItemPtr item = std::make_shared<CFileItem>(itemLabel);
+    item->SetLabel2(g_localizeStrings.Get(13298)); // "Disconnected"
+    item->SetPath(port.GetAddress());
+    item->SetArt("icon", "DefaultAddonNone.png");
+    m_vecItems->Add(std::move(item));
+    ++itemId;
+  }
+
+  return true;
+}
+
+void CGUIPortList::CleanupItems()
+{
+  m_vecItems->Clear();
+  m_itemToAddress.clear();
+  m_addressToItem.clear();
+}
+
+void CGUIPortList::OnItemFocus(unsigned int itemIndex)
+{
+  m_focusedPort = m_itemToAddress[itemIndex];
+}
+
+void CGUIPortList::OnItemSelect(unsigned int itemIndex)
+{
+  if (m_gameClient)
+  {
+    const auto it = m_itemToAddress.find(itemIndex);
+    if (it == m_itemToAddress.end())
+      return;
+
+    const std::string& portAddress = it->second;
+    if (portAddress.empty())
+      return;
+
+    const CPortNode& port = m_gameClient->Input().GetActiveControllerTree().GetPort(portAddress);
+
+    ControllerVector controllers;
+    for (const CControllerNode& controllerNode : port.GetCompatibleControllers())
+      controllers.emplace_back(controllerNode.GetController());
+
+    // Get current controller to give initial focus
+    ControllerPtr controller = port.GetActiveController().GetController();
+
+    auto callback = [this, &port](const ControllerPtr& controller) {
+      OnControllerSelected(port, controller);
+    };
+
+    const bool showDisconnect = !port.IsForceConnected();
+    m_controllerSelectDialog.Initialize(std::move(controllers), std::move(controller),
+                                        showDisconnect, callback);
+  }
+}
+
+void CGUIPortList::OnControllerSelected(const CPortNode& port, const ControllerPtr& controller)
+{
+  if (m_gameClient)
+  {
+    // Translate parameter
+    const bool bConnected = static_cast<bool>(controller);
+
+    // Update the game client
+    const bool bSuccess =
+        bConnected ? m_gameClient->Input().ConnectController(port.GetAddress(), controller)
+                   : m_gameClient->Input().DisconnectController(port.GetAddress());
+
+    if (bSuccess)
+    {
+      m_gameClient->Input().SavePorts();
+    }
+    else
+    {
+      // "Failed to change controller"
+      // "The emulator "%s" had an internal error."
+      MESSAGING::HELPERS::ShowOKDialogText(
+          CVariant{35114},
+          CVariant{StringUtils::Format(g_localizeStrings.Get(35213), m_gameClient->Name())});
+    }
+
+    // Send a GUI message to reload the port list
+    CGUIMessage msg(GUI_MSG_REFRESH_LIST, m_guiWindow.GetID(), CONTROL_PORT_LIST);
+    CServiceBroker::GetAppMessenger()->SendGUIMessage(msg, m_guiWindow.GetID());
+  }
+}
+
+std::string CGUIPortList::GetLabel(const CPortNode& port)
+{
+  const PORT_TYPE portType = port.GetPortType();
+  switch (portType)
+  {
+    case PORT_TYPE::KEYBOARD:
+    {
+      // "Keyboard"
+      return g_localizeStrings.Get(35150);
+    }
+    case PORT_TYPE::MOUSE:
+    {
+      // "Mouse"
+      return g_localizeStrings.Get(35171);
+    }
+    case PORT_TYPE::CONTROLLER:
+    {
+      const std::string& portId = port.GetPortID();
+      if (portId.empty())
+      {
+        CLog::Log(LOGERROR, "Controller port with address \"{}\" doesn't have a port ID",
+                  port.GetAddress());
+      }
+      else
+      {
+        // "Port {0:s}"
+        const std::string& portString = g_localizeStrings.Get(35112);
+        return StringUtils::Format(portString, portId);
+      }
+      break;
+    }
+    default:
+      break;
+  }
+
+  return "";
+}
diff --git a/xbmc/games/ports/windows/GUIPortList.h b/xbmc/games/ports/windows/GUIPortList.h
new file mode 100644
index 0000000..3fed6b7
--- /dev/null
+++ b/xbmc/games/ports/windows/GUIPortList.h
@@ -0,0 +1,79 @@
+/*
+ *  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 "IPortList.h"
+#include "addons/AddonEvents.h"
+#include "games/GameTypes.h"
+#include "games/controllers/ControllerTypes.h"
+#include "games/controllers/dialogs/ControllerSelect.h"
+#include "games/controllers/types/ControllerTree.h"
+
+#include <map>
+#include <memory>
+#include <string>
+
+class CFileItemList;
+class CGUIViewControl;
+class CGUIWindow;
+
+namespace KODI
+{
+namespace GAME
+{
+class CGUIPortList : public IPortList
+{
+public:
+  CGUIPortList(CGUIWindow& window);
+  ~CGUIPortList() override;
+
+  // Implementation of IPortList
+  void OnWindowLoaded() override;
+  void OnWindowUnload() override;
+  bool Initialize(GameClientPtr gameClient) override;
+  void Deinitialize() override;
+  bool HasControl(int controlId) override;
+  int GetCurrentControl() override;
+  void Refresh() override;
+  void FrameMove() override;
+  void SetFocused() override;
+  bool OnSelect() override;
+  void ResetPorts() override;
+
+private:
+  // Add-on API
+  void OnEvent(const ADDON::AddonEvent& event);
+
+  bool AddItems(const CPortNode& port, unsigned int& itemId, const std::string& itemLabel);
+  void CleanupItems();
+  void OnItemFocus(unsigned int itemIndex);
+  void OnItemSelect(unsigned int itemIndex);
+
+  // Controller selection callback
+  void OnControllerSelected(const CPortNode& port, const ControllerPtr& controller);
+
+  static std::string GetLabel(const CPortNode& port);
+
+  // Construction parameters
+  CGUIWindow& m_guiWindow;
+
+  // GUI parameters
+  CControllerSelect m_controllerSelectDialog;
+  std::string m_focusedPort; // Address of focused port
+  int m_currentItem{-1}; // Index of the selected item, or -1 if no item is selected
+  std::unique_ptr<CGUIViewControl> m_viewControl;
+  std::unique_ptr<CFileItemList> m_vecItems;
+
+  // Game parameters
+  GameClientPtr m_gameClient;
+  std::map<unsigned int, std::string> m_itemToAddress; // item index -> port address
+  std::map<std::string, unsigned int> m_addressToItem; // port address -> item index
+};
+} // namespace GAME
+} // namespace KODI
diff --git a/xbmc/games/ports/windows/GUIPortWindow.cpp b/xbmc/games/ports/windows/GUIPortWindow.cpp
new file mode 100644
index 0000000..e95927a
--- /dev/null
+++ b/xbmc/games/ports/windows/GUIPortWindow.cpp
@@ -0,0 +1,183 @@
+/*
+ *  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 "GUIPortWindow.h"
+
+#include "GUIPortDefines.h"
+#include "GUIPortList.h"
+#include "ServiceBroker.h"
+#include "addons/AddonManager.h"
+#include "addons/IAddon.h"
+#include "addons/addoninfo/AddonType.h"
+#include "cores/RetroPlayer/guibridge/GUIGameRenderManager.h"
+#include "cores/RetroPlayer/guibridge/GUIGameSettingsHandle.h"
+#include "games/addons/GameClient.h"
+#include "guilib/GUIButtonControl.h"
+#include "guilib/GUIControl.h"
+#include "guilib/GUIMessage.h"
+#include "guilib/WindowIDs.h"
+#include "input/actions/ActionIDs.h"
+#include "utils/StringUtils.h"
+
+using namespace KODI;
+using namespace GAME;
+
+CGUIPortWindow::CGUIPortWindow()
+  : CGUIDialog(WINDOW_DIALOG_GAME_PORTS, PORT_DIALOG_XML),
+    m_portList(std::make_unique<CGUIPortList>(*this))
+{
+  // Initialize CGUIWindow
+  m_loadType = KEEP_IN_MEMORY;
+}
+
+CGUIPortWindow::~CGUIPortWindow() = default;
+
+bool CGUIPortWindow::OnMessage(CGUIMessage& message)
+{
+  // Set to true to block the call to the super class
+  bool bHandled = false;
+
+  switch (message.GetMessage())
+  {
+    case GUI_MSG_SETFOCUS:
+    {
+      const int controlId = message.GetControlId();
+      if (m_portList->HasControl(controlId) && m_portList->GetCurrentControl() != controlId)
+      {
+        FocusPortList();
+        bHandled = true;
+      }
+      break;
+    }
+    case GUI_MSG_CLICKED:
+    {
+      const int controlId = message.GetSenderId();
+
+      if (controlId == CONTROL_CLOSE_BUTTON)
+      {
+        CloseDialog();
+        bHandled = true;
+      }
+      else if (controlId == CONTROL_RESET_BUTTON)
+      {
+        ResetPorts();
+        bHandled = true;
+      }
+      else if (m_portList->HasControl(controlId))
+      {
+        const int actionId = message.GetParam1();
+        if (actionId == ACTION_SELECT_ITEM || actionId == ACTION_MOUSE_LEFT_CLICK)
+        {
+          OnClickAction();
+          bHandled = true;
+        }
+      }
+      break;
+    }
+    case GUI_MSG_REFRESH_LIST:
+    {
+      UpdatePortList();
+      break;
+    }
+    default:
+      break;
+  }
+
+  if (!bHandled)
+    bHandled = CGUIDialog::OnMessage(message);
+
+  return bHandled;
+}
+
+void CGUIPortWindow::OnWindowLoaded()
+{
+  CGUIDialog::OnWindowLoaded();
+
+  m_portList->OnWindowLoaded();
+}
+
+void CGUIPortWindow::OnWindowUnload()
+{
+  m_portList->OnWindowUnload();
+
+  CGUIDialog::OnWindowUnload();
+}
+
+void CGUIPortWindow::OnInitWindow()
+{
+  CGUIDialog::OnInitWindow();
+
+  // 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);
+
+  // Set the heading
+  // "Port Setup - {game client name}"
+  SET_CONTROL_LABEL(CONTROL_PORT_DIALOG_LABEL,
+                    StringUtils::Format("$LOCALIZE[35111] - {}", m_gameClient->Name()));
+
+  m_portList->Initialize(m_gameClient);
+
+  UpdatePortList();
+
+  // Focus the port list
+  CGUIMessage msgFocus(GUI_MSG_SETFOCUS, GetID(), CONTROL_PORT_LIST);
+  OnMessage(msgFocus);
+}
+
+void CGUIPortWindow::OnDeinitWindow(int nextWindowID)
+{
+  m_portList->Deinitialize();
+
+  m_gameClient.reset();
+
+  CGUIDialog::OnDeinitWindow(nextWindowID);
+}
+
+void CGUIPortWindow::FrameMove()
+{
+  CGUIDialog::FrameMove();
+
+  m_portList->FrameMove();
+}
+
+void CGUIPortWindow::UpdatePortList()
+{
+  m_portList->Refresh();
+}
+
+void CGUIPortWindow::FocusPortList()
+{
+  m_portList->SetFocused();
+}
+
+bool CGUIPortWindow::OnClickAction()
+{
+  return m_portList->OnSelect();
+}
+
+void CGUIPortWindow::ResetPorts()
+{
+  m_portList->ResetPorts();
+}
+
+void CGUIPortWindow::CloseDialog()
+{
+  Close();
+}
diff --git a/xbmc/games/ports/windows/GUIPortWindow.h b/xbmc/games/ports/windows/GUIPortWindow.h
new file mode 100644
index 0000000..3b98708
--- /dev/null
+++ b/xbmc/games/ports/windows/GUIPortWindow.h
@@ -0,0 +1,56 @@
+/*
+ *  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/GameTypes.h"
+#include "guilib/GUIDialog.h"
+
+#include <memory>
+
+namespace KODI
+{
+namespace GAME
+{
+class IPortList;
+
+class CGUIPortWindow : public CGUIDialog
+{
+public:
+  CGUIPortWindow();
+  ~CGUIPortWindow() override;
+
+  // Implementation of CGUIControl via CGUIDialog
+  bool OnMessage(CGUIMessage& message) override;
+
+protected:
+  // Implementation of CGUIWindow via CGUIDialog
+  void OnWindowLoaded() override;
+  void OnWindowUnload() override;
+  void OnInitWindow() override;
+  void OnDeinitWindow(int nextWindowID) override;
+  void FrameMove() override;
+
+private:
+  // Actions for port list
+  void UpdatePortList();
+  void FocusPortList();
+  bool OnClickAction();
+
+  // Actions for the available buttons
+  void ResetPorts();
+  void CloseDialog();
+
+  // GUI parameters
+  std::unique_ptr<IPortList> m_portList;
+
+  // Game parameters
+  GameClientPtr m_gameClient;
+};
+} // namespace GAME
+} // namespace KODI
diff --git a/xbmc/games/ports/windows/IPortList.h b/xbmc/games/ports/windows/IPortList.h
new file mode 100644
index 0000000..e330c6e
--- /dev/null
+++ b/xbmc/games/ports/windows/IPortList.h
@@ -0,0 +1,104 @@
+/*
+ *  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/GameTypes.h"
+
+/*!
+ * \brief Controller port setup window
+ *
+ * The port setup window presents a list of ports and their attached
+ * controllers.
+ *
+ * The label2 of each port is the currently-connected controller. The user
+ * selects from all controllers that the port accepts (as given by the
+ * game-addon's topology.xml file).
+ *
+ * The controller topology is stored as a generic tree. Here we apply game logic
+ * to simplify controller selection.
+ */
+
+namespace KODI
+{
+namespace GAME
+{
+/*!
+ * \brief A list populated by controller ports
+ */
+class IPortList
+{
+public:
+  virtual ~IPortList() = default;
+
+  /*!
+   * \brief Callback when the GUI window is loaded
+   */
+  virtual void OnWindowLoaded() = 0;
+
+  /*!
+   * \brief Callback when the GUI window is unloaded
+   */
+  virtual void OnWindowUnload() = 0;
+
+  /*!
+   * \brief Initialize resources
+   *
+   * \param gameClient The game client providing the ports
+   *
+   * \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(GameClientPtr gameClient) = 0;
+
+  /*!
+   * \brief Deinitialize resources
+   */
+  virtual void Deinitialize() = 0;
+
+  /*!
+   * \brief Query if a control with the given ID belongs to this list
+   */
+  virtual bool HasControl(int controlId) = 0;
+
+  /*!
+   * \brief Query the ID of the current control in this list
+   *
+   * \return The control ID, or -1 if no control is currently active
+   */
+  virtual int GetCurrentControl() = 0;
+
+  /*!
+   * \brief Refresh the contents of the list
+   */
+  virtual void Refresh() = 0;
+
+  /*!
+   * \brief Callback when a frame is rendered by the GUI
+   */
+  virtual void FrameMove() = 0;
+
+  /*!
+   * \brief The port list has been focused in the GUI
+   */
+  virtual void SetFocused() = 0;
+
+  /*!
+   * \brief The port list has been selected
+   *
+   * \brief True if a control was active, false of all controls were inactive
+   */
+  virtual bool OnSelect() = 0;
+
+  /*!
+   * \brief Reset the ports to their game add-on's default configuration
+   */
+  virtual void ResetPorts() = 0;
+};
+} // namespace GAME
+} // namespace KODI
diff --git a/xbmc/games/tags/CMakeLists.txt b/xbmc/games/tags/CMakeLists.txt
new file mode 100644
index 0000000..d43cdbb
--- /dev/null
+++ b/xbmc/games/tags/CMakeLists.txt
@@ -0,0 +1,5 @@
+set(SOURCES GameInfoTag.cpp)
+
+set(HEADERS GameInfoTag.h)
+
+core_add_library(gametags)
diff --git a/xbmc/games/tags/GameInfoTag.cpp b/xbmc/games/tags/GameInfoTag.cpp
new file mode 100644
index 0000000..8a02c2c
--- /dev/null
+++ b/xbmc/games/tags/GameInfoTag.cpp
@@ -0,0 +1,158 @@
+/*
+ *  Copyright (C) 2012-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 "GameInfoTag.h"
+
+#include "utils/Archive.h"
+#include "utils/Variant.h"
+
+#include <string>
+
+using namespace KODI;
+using namespace GAME;
+
+void CGameInfoTag::Reset()
+{
+  m_bLoaded = false;
+  m_strURL.clear();
+  m_strTitle.clear();
+  m_strPlatform.clear();
+  m_genres.clear();
+  m_strDeveloper.clear();
+  m_strOverview.clear();
+  m_year = 0;
+  m_strID.clear();
+  m_strRegion.clear();
+  m_strPublisher.clear();
+  m_strFormat.clear();
+  m_strCartridgeType.clear();
+  m_strGameClient.clear();
+}
+
+CGameInfoTag& CGameInfoTag::operator=(const CGameInfoTag& tag)
+{
+  if (this != &tag)
+  {
+    m_bLoaded = tag.m_bLoaded;
+    m_strURL = tag.m_strURL;
+    m_strTitle = tag.m_strTitle;
+    m_strPlatform = tag.m_strPlatform;
+    m_genres = tag.m_genres;
+    m_strDeveloper = tag.m_strDeveloper;
+    m_strOverview = tag.m_strOverview;
+    m_year = tag.m_year;
+    m_strID = tag.m_strID;
+    m_strRegion = tag.m_strRegion;
+    m_strPublisher = tag.m_strPublisher;
+    m_strFormat = tag.m_strFormat;
+    m_strCartridgeType = tag.m_strCartridgeType;
+    m_strGameClient = tag.m_strGameClient;
+  }
+  return *this;
+}
+
+bool CGameInfoTag::operator==(const CGameInfoTag& tag) const
+{
+  if (this != &tag)
+  {
+    if (m_bLoaded != tag.m_bLoaded)
+      return false;
+
+    if (m_bLoaded)
+    {
+      if (m_strURL != tag.m_strURL)
+        return false;
+      if (m_strTitle != tag.m_strTitle)
+        return false;
+      if (m_strPlatform != tag.m_strPlatform)
+        return false;
+      if (m_genres != tag.m_genres)
+        return false;
+      if (m_strDeveloper != tag.m_strDeveloper)
+        return false;
+      if (m_strOverview != tag.m_strOverview)
+        return false;
+      if (m_year != tag.m_year)
+        return false;
+      if (m_strID != tag.m_strID)
+        return false;
+      if (m_strRegion != tag.m_strRegion)
+        return false;
+      if (m_strPublisher != tag.m_strPublisher)
+        return false;
+      if (m_strFormat != tag.m_strFormat)
+        return false;
+      if (m_strCartridgeType != tag.m_strCartridgeType)
+        return false;
+      if (m_strGameClient != tag.m_strGameClient)
+        return false;
+    }
+  }
+  return true;
+}
+
+void CGameInfoTag::Archive(CArchive& ar)
+{
+  if (ar.IsStoring())
+  {
+    ar << m_bLoaded;
+    ar << m_strURL;
+    ar << m_strTitle;
+    ar << m_strPlatform;
+    ar << m_genres;
+    ar << m_strDeveloper;
+    ar << m_strOverview;
+    ar << m_year;
+    ar << m_strID;
+    ar << m_strRegion;
+    ar << m_strPublisher;
+    ar << m_strFormat;
+    ar << m_strCartridgeType;
+    ar << m_strGameClient;
+  }
+  else
+  {
+    ar >> m_bLoaded;
+    ar >> m_strURL;
+    ar >> m_strTitle;
+    ar >> m_strPlatform;
+    ar >> m_genres;
+    ar >> m_strDeveloper;
+    ar >> m_strOverview;
+    ar >> m_year;
+    ar >> m_strID;
+    ar >> m_strRegion;
+    ar >> m_strPublisher;
+    ar >> m_strFormat;
+    ar >> m_strCartridgeType;
+    ar >> m_strGameClient;
+  }
+}
+
+void CGameInfoTag::Serialize(CVariant& value) const
+{
+  value["loaded"] = m_bLoaded;
+  value["url"] = m_strURL;
+  value["name"] = m_strTitle;
+  value["platform"] = m_strPlatform;
+  value["genres"] = m_genres;
+  value["developer"] = m_strDeveloper;
+  value["overview"] = m_strOverview;
+  value["year"] = m_year;
+  value["id"] = m_strID;
+  value["region"] = m_strRegion;
+  value["publisher"] = m_strPublisher;
+  value["format"] = m_strFormat;
+  value["cartridgetype"] = m_strCartridgeType;
+  value["gameclient"] = m_strGameClient;
+}
+
+void CGameInfoTag::ToSortable(SortItem& sortable, Field field) const
+{
+  // No database entries for games (...yet)
+}
diff --git a/xbmc/games/tags/GameInfoTag.h b/xbmc/games/tags/GameInfoTag.h
new file mode 100644
index 0000000..00287ad
--- /dev/null
+++ b/xbmc/games/tags/GameInfoTag.h
@@ -0,0 +1,112 @@
+/*
+ *  Copyright (C) 2012-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 "utils/IArchivable.h"
+#include "utils/ISerializable.h"
+#include "utils/ISortable.h"
+
+#include <string>
+
+namespace KODI
+{
+namespace GAME
+{
+class CGameInfoTag : public IArchivable, public ISerializable, public ISortable
+{
+public:
+  CGameInfoTag() { Reset(); }
+  CGameInfoTag(const CGameInfoTag& tag) { *this = tag; }
+  CGameInfoTag& operator=(const CGameInfoTag& tag);
+  virtual ~CGameInfoTag() = default;
+  void Reset();
+
+  bool operator==(const CGameInfoTag& tag) const;
+  bool operator!=(const CGameInfoTag& tag) const { return !(*this == tag); }
+
+  bool IsLoaded() const { return m_bLoaded; }
+  void SetLoaded(bool bOnOff = true) { m_bLoaded = bOnOff; }
+
+  // File path
+  const std::string& GetURL() const { return m_strURL; }
+  void SetURL(const std::string& strURL) { m_strURL = strURL; }
+
+  // Title
+  const std::string& GetTitle() const { return m_strTitle; }
+  void SetTitle(const std::string& strTitle) { m_strTitle = strTitle; }
+
+  // Platform
+  const std::string& GetPlatform() const { return m_strPlatform; }
+  void SetPlatform(const std::string& strPlatform) { m_strPlatform = strPlatform; }
+
+  // Genres
+  const std::vector<std::string>& GetGenres() const { return m_genres; }
+  void SetGenres(const std::vector<std::string>& genres) { m_genres = genres; }
+
+  // Developer
+  const std::string& GetDeveloper() const { return m_strDeveloper; }
+  void SetDeveloper(const std::string& strDeveloper) { m_strDeveloper = strDeveloper; }
+
+  // Overview
+  const std::string& GetOverview() const { return m_strOverview; }
+  void SetOverview(const std::string& strOverview) { m_strOverview = strOverview; }
+
+  // Year
+  unsigned int GetYear() const { return m_year; }
+  void SetYear(unsigned int year) { m_year = year; }
+
+  // Game Code (ID)
+  const std::string& GetID() const { return m_strID; }
+  void SetID(const std::string& strID) { m_strID = strID; }
+
+  // Region
+  const std::string& GetRegion() const { return m_strRegion; }
+  void SetRegion(const std::string& strRegion) { m_strRegion = strRegion; }
+
+  // Publisher / Licensee
+  const std::string& GetPublisher() const { return m_strPublisher; }
+  void SetPublisher(const std::string& strPublisher) { m_strPublisher = strPublisher; }
+
+  // Format (PAL/NTSC)
+  const std::string& GetFormat() const { return m_strFormat; }
+  void SetFormat(const std::string& strFormat) { m_strFormat = strFormat; }
+
+  // Cartridge Type, e.g. "ROM+MBC5+RAM+BATT" or "CD"
+  const std::string& GetCartridgeType() const { return m_strCartridgeType; }
+  void SetCartridgeType(const std::string& strCartridgeType)
+  {
+    m_strCartridgeType = strCartridgeType;
+  }
+
+  // Game client add-on ID
+  const std::string& GetGameClient() const { return m_strGameClient; }
+  void SetGameClient(const std::string& strGameClient) { m_strGameClient = strGameClient; }
+
+  void Archive(CArchive& ar) override;
+  void Serialize(CVariant& value) const override;
+  void ToSortable(SortItem& sortable, Field field) const override;
+
+private:
+  bool m_bLoaded;
+  std::string m_strURL;
+  std::string m_strTitle;
+  std::string m_strPlatform;
+  std::vector<std::string> m_genres;
+  std::string m_strDeveloper;
+  std::string m_strOverview;
+  unsigned int m_year;
+  std::string m_strID;
+  std::string m_strRegion;
+  std::string m_strPublisher;
+  std::string m_strFormat;
+  std::string m_strCartridgeType;
+  std::string m_strGameClient;
+};
+} // namespace GAME
+} // namespace KODI
diff --git a/xbmc/games/windows/CMakeLists.txt b/xbmc/games/windows/CMakeLists.txt
new file mode 100644
index 0000000..314608c
--- /dev/null
+++ b/xbmc/games/windows/CMakeLists.txt
@@ -0,0 +1,7 @@
+set(SOURCES GUIViewStateWindowGames.cpp
+            GUIWindowGames.cpp)
+
+set(HEADERS GUIViewStateWindowGames.h
+            GUIWindowGames.h)
+
+core_add_library(gameswindows)
diff --git a/xbmc/games/windows/GUIViewStateWindowGames.cpp b/xbmc/games/windows/GUIViewStateWindowGames.cpp
new file mode 100644
index 0000000..ffb9bf0
--- /dev/null
+++ b/xbmc/games/windows/GUIViewStateWindowGames.cpp
@@ -0,0 +1,91 @@
+/*
+ *  Copyright (C) 2012-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 "GUIViewStateWindowGames.h"
+
+#include "FileItem.h"
+#include "games/GameUtils.h"
+#include "guilib/LocalizeStrings.h"
+#include "guilib/WindowIDs.h"
+#include "settings/MediaSourceSettings.h"
+#include "utils/StringUtils.h"
+#include "view/ViewState.h"
+#include "view/ViewStateSettings.h"
+#include "windowing/GraphicContext.h" // include before ViewState.h
+
+#include <assert.h>
+#include <set>
+
+using namespace KODI;
+using namespace GAME;
+
+CGUIViewStateWindowGames::CGUIViewStateWindowGames(const CFileItemList& items)
+  : CGUIViewState(items)
+{
+  if (items.IsVirtualDirectoryRoot())
+  {
+    AddSortMethod(SortByLabel, 551, LABEL_MASKS());
+    AddSortMethod(SortByDriveType, 564, LABEL_MASKS());
+    SetSortMethod(SortByLabel);
+    SetSortOrder(SortOrderAscending);
+    SetViewAsControl(DEFAULT_VIEW_LIST);
+  }
+  else
+  {
+    AddSortMethod(SortByFile, 561,
+                  LABEL_MASKS("%F", "%I", "%L", "")); // Filename, Size | Label, empty
+    AddSortMethod(SortBySize, 553,
+                  LABEL_MASKS("%L", "%I", "%L", "%I")); // Filename, Size | Label, Size
+
+    const CViewState* viewState = CViewStateSettings::GetInstance().Get("games");
+    if (viewState)
+    {
+      SetSortMethod(viewState->m_sortDescription);
+      SetViewAsControl(viewState->m_viewMode);
+      SetSortOrder(viewState->m_sortDescription.sortOrder);
+    }
+  }
+
+  LoadViewState(items.GetPath(), WINDOW_GAMES);
+}
+
+std::string CGUIViewStateWindowGames::GetLockType()
+{
+  return "games";
+}
+
+std::string CGUIViewStateWindowGames::GetExtensions()
+{
+  using namespace ADDON;
+
+  std::set<std::string> exts = CGameUtils::GetGameExtensions();
+
+  // Ensure .zip appears
+  exts.insert(".zip");
+
+  return StringUtils::Join(exts, "|");
+}
+
+VECSOURCES& CGUIViewStateWindowGames::GetSources()
+{
+  VECSOURCES* pGameSources = CMediaSourceSettings::GetInstance().GetSources("games");
+
+  // Guard against source type not existing
+  if (pGameSources == nullptr)
+  {
+    static VECSOURCES empty;
+    return empty;
+  }
+
+  return *pGameSources;
+}
+
+void CGUIViewStateWindowGames::SaveViewState()
+{
+  SaveViewToDb(m_items.GetPath(), WINDOW_GAMES, CViewStateSettings::GetInstance().Get("games"));
+}
diff --git a/xbmc/games/windows/GUIViewStateWindowGames.h b/xbmc/games/windows/GUIViewStateWindowGames.h
new file mode 100644
index 0000000..90ad821
--- /dev/null
+++ b/xbmc/games/windows/GUIViewStateWindowGames.h
@@ -0,0 +1,34 @@
+/*
+ *  Copyright (C) 2012-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 "view/GUIViewState.h"
+
+namespace KODI
+{
+namespace GAME
+{
+class CGUIViewStateWindowGames : public CGUIViewState
+{
+public:
+  explicit CGUIViewStateWindowGames(const CFileItemList& items);
+
+  ~CGUIViewStateWindowGames() override = default;
+
+  // implementation of CGUIViewState
+  std::string GetLockType() override;
+  std::string GetExtensions() override;
+  VECSOURCES& GetSources() override;
+
+protected:
+  // implementation of CGUIViewState
+  void SaveViewState() override;
+};
+} // namespace GAME
+} // namespace KODI
diff --git a/xbmc/games/windows/GUIWindowGames.cpp b/xbmc/games/windows/GUIWindowGames.cpp
new file mode 100644
index 0000000..a74186d
--- /dev/null
+++ b/xbmc/games/windows/GUIWindowGames.cpp
@@ -0,0 +1,340 @@
+/*
+ *  Copyright (C) 2012-2020 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 "GUIWindowGames.h"
+
+#include "FileItem.h"
+#include "GUIPassword.h"
+#include "ServiceBroker.h"
+#include "URL.h"
+#include "Util.h"
+#include "addons/gui/GUIDialogAddonInfo.h"
+#include "application/Application.h"
+#include "dialogs/GUIDialogContextMenu.h"
+#include "dialogs/GUIDialogMediaSource.h"
+#include "dialogs/GUIDialogProgress.h"
+#include "guilib/GUIComponent.h"
+#include "guilib/GUIWindowManager.h"
+#include "guilib/WindowIDs.h"
+#include "input/actions/ActionIDs.h"
+#include "media/MediaLockState.h"
+#include "playlists/PlayListTypes.h"
+#include "settings/MediaSourceSettings.h"
+#include "settings/Settings.h"
+#include "settings/SettingsComponent.h"
+#include "utils/StringUtils.h"
+#include "utils/URIUtils.h"
+
+#include <algorithm>
+
+using namespace KODI;
+using namespace GAME;
+
+#define CONTROL_BTNVIEWASICONS 2
+#define CONTROL_BTNSORTBY 3
+#define CONTROL_BTNSORTASC 4
+
+CGUIWindowGames::CGUIWindowGames() : CGUIMediaWindow(WINDOW_GAMES, "MyGames.xml")
+{
+}
+
+bool CGUIWindowGames::OnMessage(CGUIMessage& message)
+{
+  switch (message.GetMessage())
+  {
+    case GUI_MSG_WINDOW_INIT:
+    {
+      m_rootDir.AllowNonLocalSources(true); //! @todo
+
+      // Is this the first time the window is opened?
+      if (m_vecItems->GetPath() == "?" && message.GetStringParam().empty())
+        message.SetStringParam(CMediaSourceSettings::GetInstance().GetDefaultSource("games"));
+
+      //! @todo
+      m_dlgProgress = CServiceBroker::GetGUI()->GetWindowManager().GetWindow<CGUIDialogProgress>(
+          WINDOW_DIALOG_PROGRESS);
+
+      break;
+    }
+    case GUI_MSG_CLICKED:
+    {
+      if (OnClickMsg(message.GetSenderId(), message.GetParam1()))
+        return true;
+      break;
+    }
+    default:
+      break;
+  }
+  return CGUIMediaWindow::OnMessage(message);
+}
+
+bool CGUIWindowGames::OnClickMsg(int controlId, int actionId)
+{
+  if (!m_viewControl.HasControl(controlId)) // list/thumb control
+    return false;
+
+  const int iItem = m_viewControl.GetSelectedItem();
+
+  CFileItemPtr pItem = m_vecItems->Get(iItem);
+  if (!pItem)
+    return false;
+
+  switch (actionId)
+  {
+    case ACTION_DELETE_ITEM:
+    {
+      // Is delete allowed?
+      if (CServiceBroker::GetSettingsComponent()->GetSettings()->GetBool(
+              CSettings::SETTING_FILELISTS_ALLOWFILEDELETION))
+      {
+        OnDeleteItem(iItem);
+        return true;
+      }
+      break;
+    }
+    case ACTION_PLAYER_PLAY:
+    {
+      if (OnClick(iItem))
+        return true;
+      break;
+    }
+    case ACTION_SHOW_INFO:
+    {
+      if (!m_vecItems->IsPlugin())
+      {
+        if (pItem->HasAddonInfo())
+        {
+          CGUIDialogAddonInfo::ShowForItem(pItem);
+          return true;
+        }
+      }
+      break;
+    }
+    default:
+      break;
+  }
+
+  return false;
+}
+
+void CGUIWindowGames::SetupShares()
+{
+  CGUIMediaWindow::SetupShares();
+
+  // Don't convert zip files to directories. Otherwise, the files will be
+  // opened and scanned for games with a valid extension. If none are found,
+  // the .zip won't be shown.
+  //
+  // This is a problem for MAME roms, because the files inside the .zip don't
+  // have standard extensions.
+  //
+  m_rootDir.SetFlags(XFILE::DIR_FLAG_NO_FILE_DIRS);
+}
+
+bool CGUIWindowGames::OnClick(int iItem, const std::string& player /* = "" */)
+{
+  CFileItemPtr item = m_vecItems->Get(iItem);
+  if (item)
+  {
+    // Compensate for DIR_FLAG_NO_FILE_DIRS flag
+    if (URIUtils::IsArchive(item->GetPath()))
+    {
+      bool bIsGame = false;
+
+      // If zip file contains no games, assume it is a game
+      CFileItemList items;
+      if (m_rootDir.GetDirectory(CURL(item->GetPath()), items))
+      {
+        if (items.Size() == 0)
+          bIsGame = true;
+      }
+
+      if (!bIsGame)
+        item->m_bIsFolder = true;
+    }
+
+    if (!item->m_bIsFolder)
+    {
+      PlayGame(*item);
+      return true;
+    }
+  }
+
+  return CGUIMediaWindow::OnClick(iItem, player);
+}
+
+void CGUIWindowGames::GetContextButtons(int itemNumber, CContextButtons& buttons)
+{
+  CFileItemPtr item = m_vecItems->Get(itemNumber);
+
+  if (item && !item->GetProperty("pluginreplacecontextitems").asBoolean())
+  {
+    if (m_vecItems->IsVirtualDirectoryRoot() || m_vecItems->IsSourcesPath())
+    {
+      // Context buttons for a sources path, like "Add Source", "Remove Source", etc.
+      CGUIDialogContextMenu::GetContextButtons("games", item, buttons);
+    }
+    else
+    {
+      if (item->IsGame())
+      {
+        buttons.Add(CONTEXT_BUTTON_PLAY_ITEM, 208); // Play
+      }
+
+      if (CServiceBroker::GetSettingsComponent()->GetSettings()->GetBool(
+              CSettings::SETTING_FILELISTS_ALLOWFILEDELETION) &&
+          !item->IsReadOnly())
+      {
+        buttons.Add(CONTEXT_BUTTON_DELETE, 117);
+        buttons.Add(CONTEXT_BUTTON_RENAME, 118);
+      }
+    }
+  }
+
+  CGUIMediaWindow::GetContextButtons(itemNumber, buttons);
+}
+
+bool CGUIWindowGames::OnContextButton(int itemNumber, CONTEXT_BUTTON button)
+{
+  CFileItemPtr item = m_vecItems->Get(itemNumber);
+  if (item)
+  {
+    if (m_vecItems->IsVirtualDirectoryRoot() || m_vecItems->IsSourcesPath())
+    {
+      if (CGUIDialogContextMenu::OnContextButton("games", item, button))
+      {
+        Update(m_vecItems->GetPath());
+        return true;
+      }
+    }
+    switch (button)
+    {
+      case CONTEXT_BUTTON_PLAY_ITEM:
+        PlayGame(*item);
+        return true;
+      case CONTEXT_BUTTON_INFO:
+        CGUIDialogAddonInfo::ShowForItem(item);
+        return true;
+      case CONTEXT_BUTTON_DELETE:
+        OnDeleteItem(itemNumber);
+        return true;
+      case CONTEXT_BUTTON_RENAME:
+        OnRenameItem(itemNumber);
+        return true;
+      default:
+        break;
+    }
+  }
+  return CGUIMediaWindow::OnContextButton(itemNumber, button);
+}
+
+bool CGUIWindowGames::OnAddMediaSource()
+{
+  return CGUIDialogMediaSource::ShowAndAddMediaSource("games");
+}
+
+bool CGUIWindowGames::GetDirectory(const std::string& strDirectory, CFileItemList& items)
+{
+  if (!CGUIMediaWindow::GetDirectory(strDirectory, items))
+    return false;
+
+  // Set label
+  std::string label;
+  if (items.GetLabel().empty())
+  {
+    std::string source;
+    if (m_rootDir.IsSource(items.GetPath(), CMediaSourceSettings::GetInstance().GetSources("games"),
+                           &source))
+      label = std::move(source);
+  }
+
+  if (!label.empty())
+    items.SetLabel(label);
+
+  // Set content
+  std::string content;
+  if (items.GetContent().empty())
+  {
+    if (!items.IsVirtualDirectoryRoot() && // Don't set content for root directory
+        !items.IsPlugin()) // Don't set content for plugins
+    {
+      content = "games";
+    }
+  }
+
+  if (!content.empty())
+    items.SetContent(content);
+
+  // Ensure a game info tag is created so that files are recognized as games
+  for (const CFileItemPtr& item : items)
+  {
+    if (!item->m_bIsFolder)
+      item->GetGameInfoTag();
+  }
+
+  return true;
+}
+
+std::string CGUIWindowGames::GetStartFolder(const std::string& dir)
+{
+  // From CGUIWindowPictures::GetStartFolder()
+
+  if (StringUtils::EqualsNoCase(dir, "plugins") || StringUtils::EqualsNoCase(dir, "addons"))
+  {
+    return "addons://sources/game/";
+  }
+
+  SetupShares();
+  VECSOURCES shares;
+  m_rootDir.GetSources(shares);
+  bool bIsSourceName = false;
+  int iIndex = CUtil::GetMatchingSource(dir, shares, bIsSourceName);
+  if (iIndex >= 0)
+  {
+    if (iIndex < static_cast<int>(shares.size()) && shares[iIndex].m_iHasLock == LOCK_STATE_LOCKED)
+    {
+      CFileItem item(shares[iIndex]);
+      if (!g_passwordManager.IsItemUnlocked(&item, "games"))
+        return "";
+    }
+    if (bIsSourceName)
+      return shares[iIndex].strPath;
+    return dir;
+  }
+  return CGUIMediaWindow::GetStartFolder(dir);
+}
+
+void CGUIWindowGames::OnItemInfo(int itemNumber)
+{
+  CFileItemPtr item = m_vecItems->Get(itemNumber);
+  if (!item)
+    return;
+
+  if (!m_vecItems->IsPlugin())
+  {
+    if (item->IsPlugin() || item->IsScript())
+      CGUIDialogAddonInfo::ShowForItem(item);
+  }
+
+  //! @todo
+  /*
+  CGUIDialogGameInfo* gameInfo =
+  CServiceBroker::GetGUI()->GetWindowManager().GetWindow<CGUIDialogGameInfo>(WINDOW_DIALOG_PICTURE_INFO);
+  if (gameInfo)
+  {
+    gameInfo->SetGame(item);
+    gameInfo->Open();
+  }
+  */
+}
+
+bool CGUIWindowGames::PlayGame(const CFileItem& item)
+{
+  CFileItem itemCopy(item);
+  return g_application.PlayMedia(itemCopy, "", PLAYLIST::TYPE_NONE);
+}
diff --git a/xbmc/games/windows/GUIWindowGames.h b/xbmc/games/windows/GUIWindowGames.h
new file mode 100644
index 0000000..2fbabfa
--- /dev/null
+++ b/xbmc/games/windows/GUIWindowGames.h
@@ -0,0 +1,45 @@
+/*
+ *  Copyright (C) 2012-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 "windows/GUIMediaWindow.h"
+
+class CGUIDialogProgress;
+
+namespace KODI
+{
+namespace GAME
+{
+class CGUIWindowGames : public CGUIMediaWindow
+{
+public:
+  CGUIWindowGames();
+  ~CGUIWindowGames() override = default;
+
+  // implementation of CGUIControl via CGUIMediaWindow
+  bool OnMessage(CGUIMessage& message) override;
+
+protected:
+  // implementation of CGUIMediaWindow
+  void SetupShares() override;
+  bool OnClick(int iItem, const std::string& player = "") override;
+  void GetContextButtons(int itemNumber, CContextButtons& buttons) override;
+  bool OnContextButton(int itemNumber, CONTEXT_BUTTON button) override;
+  bool OnAddMediaSource() override;
+  bool GetDirectory(const std::string& strDirectory, CFileItemList& items) override;
+  std::string GetStartFolder(const std::string& dir) override;
+
+  bool OnClickMsg(int controlId, int actionId);
+  void OnItemInfo(int itemNumber);
+  bool PlayGame(const CFileItem& item);
+
+  CGUIDialogProgress* m_dlgProgress = nullptr;
+};
+} // namespace GAME
+} // namespace KODI