Merge pull request #13340 from garbear/game-globals

Games: Register setting handlers inside CGameSettings

15 files changed, 133 insertions, 61 deletions

diff --git a/xbmc/ServiceManager.cpp b/xbmc/ServiceManager.cpp
index 69aeb327fc..7ab9254234 100644
--- a/xbmc/ServiceManager.cpp
+++ b/xbmc/ServiceManager.cpp
@@ -139,7 +139,9 @@ bool CServiceManager::InitStageTwo(const CAppParamParser &params)
   m_inputManager.reset(new CInputManager(params));
   m_inputManager->InitializeInputs();
 
-  m_peripherals.reset(new PERIPHERALS::CPeripherals(*m_announcementManager));
+  m_peripherals.reset(new PERIPHERALS::CPeripherals(*m_announcementManager,
+                                                    *m_inputManager,
+                                                    *m_gameControllerManager));
 
   m_gameRenderManager.reset(new RETRO::CGUIGameRenderManager);
 
@@ -192,6 +194,7 @@ bool CServiceManager::InitStageThree()
 
   m_gameServices.reset(new GAME::CGameServices(*m_gameControllerManager,
     *m_gameRenderManager,
+    *m_settings,
     *m_peripherals));
 
   m_contextMenuManager->Init();
diff --git a/xbmc/games/GameServices.cpp b/xbmc/games/GameServices.cpp
index 7da8e2b04a..3d67c64246 100644
--- a/xbmc/games/GameServices.cpp
+++ b/xbmc/games/GameServices.cpp
@@ -22,16 +22,18 @@
 #include "controllers/Controller.h"
 #include "controllers/ControllerManager.h"
 #include "games/ports/PortManager.h"
-#include "ServiceBroker.h"
+#include "games/GameSettings.h"
 
 using namespace KODI;
 using namespace GAME;
 
 CGameServices::CGameServices(CControllerManager &controllerManager,
                              RETRO:: CGUIGameRenderManager &renderManager,
+                             CSettings &settings,
                              PERIPHERALS::CPeripherals &peripheralManager) :
   m_controllerManager(controllerManager),
   m_gameRenderManager(renderManager),
+  m_gameSettings(new CGameSettings(settings)),
   m_portManager(new CPortManager(peripheralManager))
 {
 }
diff --git a/xbmc/games/GameServices.h b/xbmc/games/GameServices.h
index ae7485f63b..5ef9c3e0f5 100644
--- a/xbmc/games/GameServices.h
+++ b/xbmc/games/GameServices.h
@@ -24,6 +24,8 @@
 #include <memory>
 #include <string>
 
+class CSettings;
+
 namespace PERIPHERALS
 {
   class CPeripherals;
@@ -39,6 +41,7 @@ namespace RETRO
 namespace GAME
 {
   class CControllerManager;
+  class CGameSettings;
   class CPortManager;
 
   class CGameServices
@@ -46,6 +49,7 @@ namespace GAME
   public:
     CGameServices(CControllerManager &controllerManager,
                   RETRO::CGUIGameRenderManager &renderManager,
+                  CSettings &settings,
                   PERIPHERALS::CPeripherals &peripheralManager);
     ~CGameServices();
 
@@ -53,6 +57,7 @@ namespace GAME
     ControllerPtr GetDefaultController();
     ControllerVector GetControllers();
 
+    CGameSettings& GameSettings() { return *m_gameSettings; }
     CPortManager& PortManager();
 
     RETRO::CGUIGameRenderManager &GameRenderManager() { return m_gameRenderManager; }
@@ -63,6 +68,7 @@ namespace GAME
     RETRO::CGUIGameRenderManager &m_gameRenderManager;
 
     // Game services
+    std::unique_ptr<CGameSettings> m_gameSettings;
     std::unique_ptr<CPortManager> m_portManager;
   };
 }
diff --git a/xbmc/games/GameSettings.cpp b/xbmc/games/GameSettings.cpp
index 43fb48c965..52f9be0276 100644
--- a/xbmc/games/GameSettings.cpp
+++ b/xbmc/games/GameSettings.cpp
@@ -34,10 +34,27 @@ using namespace GAME;
 
 #define SETTING_GAMES_KEYBOARD_PLAYERCONFIG_PREFIX  "gameskeyboard.keyboardplayerconfig" //! @todo
 
-CGameSettings& CGameSettings::GetInstance()
+CGameSettings::CGameSettings(CSettings &settings) :
+  m_settings(settings)
 {
-  static CGameSettings gameSettingsInstance;
-  return gameSettingsInstance;
+  m_settings.RegisterCallback(this, {
+    CSettings::SETTING_GAMES_KEYBOARD_PLAYERS,
+    CSettings::SETTING_GAMES_KEYBOARD_PLAYERCONFIG_1,
+    CSettings::SETTING_GAMES_KEYBOARD_PLAYERCONFIG_2,
+    CSettings::SETTING_GAMES_KEYBOARD_PLAYERCONFIG_3,
+    CSettings::SETTING_GAMES_KEYBOARD_PLAYERCONFIG_4,
+    CSettings::SETTING_GAMES_KEYBOARD_PLAYERCONFIG_5,
+    CSettings::SETTING_GAMES_KEYBOARD_PLAYERCONFIG_6,
+    CSettings::SETTING_GAMES_KEYBOARD_PLAYERCONFIG_7,
+    CSettings::SETTING_GAMES_KEYBOARD_PLAYERCONFIG_8,
+    CSettings::SETTING_GAMES_ENABLEREWIND,
+    CSettings::SETTING_GAMES_REWINDTIME,
+  });
+}
+
+CGameSettings::~CGameSettings()
+{
+  m_settings.UnregisterCallback(this);
 }
 
 void CGameSettings::OnSettingChanged(std::shared_ptr<const CSetting> setting)
diff --git a/xbmc/games/GameSettings.h b/xbmc/games/GameSettings.h
index c4102b3125..0706d58b51 100644
--- a/xbmc/games/GameSettings.h
+++ b/xbmc/games/GameSettings.h
@@ -23,6 +23,7 @@
 #include "utils/Observer.h"
 
 class CSetting;
+class CSettings;
 
 namespace KODI
 {
@@ -33,15 +34,16 @@ class CGameSettings : public ISettingCallback,
                       public Observable
 {
 public:
-  static CGameSettings& GetInstance();
-  virtual ~CGameSettings() = default;
+  CGameSettings(CSettings &settings);
+  ~CGameSettings() override;
 
   // Inherited from ISettingCallback
   virtual void OnSettingChanged(std::shared_ptr<const CSetting> setting) override;
   virtual void OnSettingAction(std::shared_ptr<const CSetting> setting) override;
 
 private:
-  CGameSettings() = default;
+  // Construction parameters
+  CSettings &m_settings;
 };
 
 } // namespace GAME
diff --git a/xbmc/games/addons/playback/GameClientReversiblePlayback.cpp b/xbmc/games/addons/playback/GameClientReversiblePlayback.cpp
index b0302e066d..a7b6d536e8 100644
--- a/xbmc/games/addons/playback/GameClientReversiblePlayback.cpp
+++ b/xbmc/games/addons/playback/GameClientReversiblePlayback.cpp
@@ -26,10 +26,12 @@
 #include "games/addons/savestates/Savestate.h"
 #include "games/addons/savestates/SavestateReader.h"
 #include "games/addons/savestates/SavestateWriter.h"
+#include "games/GameServices.h"
 #include "games/GameSettings.h"
 #include "settings/Settings.h"
 #include "threads/SingleLock.h"
 #include "utils/MathUtils.h"
+#include "ServiceBroker.h"
 
 #include <algorithm>
 
@@ -52,14 +54,14 @@ CGameClientReversiblePlayback::CGameClientReversiblePlayback(CGameClient* gameCl
 {
   UpdateMemoryStream();
 
-  CGameSettings::GetInstance().RegisterObserver(this);
+  CServiceBroker::GetGameServices().GameSettings().RegisterObserver(this);
 
   m_gameLoop.Start();
 }
 
 CGameClientReversiblePlayback::~CGameClientReversiblePlayback()
 {
-  CGameSettings::GetInstance().UnregisterObserver(this);
+  CServiceBroker::GetGameServices().GameSettings().UnregisterObserver(this);
 
   m_gameLoop.Stop();
 }
diff --git a/xbmc/peripherals/Peripherals.cpp b/xbmc/peripherals/Peripherals.cpp
index 9ec71c1942..8e6b3c194d 100644
--- a/xbmc/peripherals/Peripherals.cpp
+++ b/xbmc/peripherals/Peripherals.cpp
@@ -77,8 +77,12 @@ using namespace PERIPHERALS;
 using namespace XFILE;
 using namespace KODI::MESSAGING;
 
-CPeripherals::CPeripherals(ANNOUNCEMENT::CAnnouncementManager &announcements) :
+CPeripherals::CPeripherals(ANNOUNCEMENT::CAnnouncementManager &announcements,
+                           CInputManager &inputManager,
+                           GAME::CControllerManager &controllerProfiles) :
   m_announcements(announcements),
+  m_inputManager(inputManager),
+  m_controllerProfiles(controllerProfiles),
   m_eventScanner(this)
 {
   // Register settings
diff --git a/xbmc/peripherals/Peripherals.h b/xbmc/peripherals/Peripherals.h
index a34cf33f82..b298e90ea2 100644
--- a/xbmc/peripherals/Peripherals.h
+++ b/xbmc/peripherals/Peripherals.h
@@ -33,6 +33,7 @@
 #include "utils/Observer.h"
 
 class CFileItemList;
+class CInputManager;
 class CSetting;
 class CSettingsCategory;
 class TiXmlElement;
@@ -41,6 +42,11 @@ class CKey;
 
 namespace KODI
 {
+namespace GAME
+{
+  class CControllerManager;
+}
+
 namespace JOYSTICK
 {
   class IButtonMapper;
@@ -61,7 +67,9 @@ namespace PERIPHERALS
                         public ANNOUNCEMENT::IAnnouncer
   {
   public:
-    explicit CPeripherals(ANNOUNCEMENT::CAnnouncementManager &announcements);
+    explicit CPeripherals(ANNOUNCEMENT::CAnnouncementManager &announcements,
+                          CInputManager &inputManager,
+                          KODI::GAME::CControllerManager &controllerProfiles);
 
     ~CPeripherals() override;
 
@@ -313,6 +321,16 @@ namespace PERIPHERALS
     // implementation of IAnnouncer
     void Announce(ANNOUNCEMENT::AnnouncementFlag flag, const char *sender, const char *message, const CVariant &data) override;
 
+    /*!
+     * \brief Access the input manager passed to the constructor
+     */
+    CInputManager &GetInputManager() { return m_inputManager; }
+
+    /*!
+     * \brief Access controller profiles through the construction parameter
+     */
+    KODI::GAME::CControllerManager &GetControllerProfiles() { return m_controllerProfiles; }
+
   private:
     bool LoadMappings();
     bool GetMappingForDevice(const CPeripheralBus &bus, PeripheralScanResult& result) const;
@@ -322,6 +340,8 @@ namespace PERIPHERALS
 
     // Construction parameters
     ANNOUNCEMENT::CAnnouncementManager &m_announcements;
+    CInputManager &m_inputManager;
+    KODI::GAME::CControllerManager &m_controllerProfiles;
 
 #if !defined(HAVE_LIBCEC)
     bool                                 m_bMissingLibCecWarningDisplayed = false;
diff --git a/xbmc/peripherals/addons/PeripheralAddon.cpp b/xbmc/peripherals/addons/PeripheralAddon.cpp
index b35a9c3746..5808581a64 100644
--- a/xbmc/peripherals/addons/PeripheralAddon.cpp
+++ b/xbmc/peripherals/addons/PeripheralAddon.cpp
@@ -20,7 +20,6 @@
 
 #include "PeripheralAddon.h"
 #include "PeripheralAddonTranslator.h"
-#include "ServiceBroker.h"
 #include "AddonButtonMap.h"
 #include "PeripheralAddonTranslator.h"
 #include "addons/AddonManager.h"
@@ -58,8 +57,9 @@ using namespace XFILE;
   #define SAFE_DELETE(p)  do { delete (p); (p) = NULL; } while (0)
 #endif
 
-CPeripheralAddon::CPeripheralAddon(const ADDON::BinaryAddonBasePtr& addonInfo)
+CPeripheralAddon::CPeripheralAddon(const ADDON::BinaryAddonBasePtr& addonInfo, CPeripherals &manager)
   : IAddonInstanceHandler(ADDON_INSTANCE_PERIPHERAL, addonInfo),
+    m_manager(manager),
     m_bSupportsJoystickRumble(false),
     m_bSupportsJoystickPowerOff(false)
 {
@@ -774,6 +774,39 @@ void CPeripheralAddon::RefreshButtonMaps(const std::string& strDeviceName /* = "
   }
 }
 
+void CPeripheralAddon::TriggerDeviceScan()
+{
+  m_manager.TriggerDeviceScan(PERIPHERAL_BUS_ADDON);
+}
+
+unsigned int CPeripheralAddon::FeatureCount(const std::string &controllerId, JOYSTICK_FEATURE_TYPE type) const
+{
+  using namespace GAME;
+
+  unsigned int count = 0;
+
+  CControllerManager& controllerProfiles = m_manager.GetControllerProfiles();
+  ControllerPtr controller = controllerProfiles.GetController(controllerId);
+  if (controller)
+    count = controller->FeatureCount(CPeripheralAddonTranslator::TranslateFeatureType(type));
+
+  return count;
+}
+
+JOYSTICK_FEATURE_TYPE CPeripheralAddon::FeatureType(const std::string &controllerId, const std::string &featureName) const
+{
+  using namespace GAME;
+
+  JOYSTICK_FEATURE_TYPE type = JOYSTICK_FEATURE_TYPE_UNKNOWN;
+
+  CControllerManager& controllerProfiles = m_manager.GetControllerProfiles();
+  ControllerPtr controller = controllerProfiles.GetController(controllerId);
+  if (controller)
+    type = CPeripheralAddonTranslator::TranslateFeatureType(controller->FeatureType(featureName));
+
+  return type;
+}
+
 void CPeripheralAddon::GetPeripheralInfo(const CPeripheral* device, kodi::addon::Peripheral& peripheralInfo)
 {
   peripheralInfo.SetType(CPeripheralAddonTranslator::TranslateType(device->Type()));
@@ -855,7 +888,10 @@ std::string CPeripheralAddon::GetProvider(PeripheralType type)
 
 void CPeripheralAddon::cb_trigger_scan(void* kodiInstance)
 {
-  CServiceBroker::GetPeripherals().TriggerDeviceScan(PERIPHERAL_BUS_ADDON);
+  if (kodiInstance == nullptr)
+    return;
+
+  static_cast<CPeripheralAddon*>(kodiInstance)->TriggerDeviceScan();
 }
 
 void CPeripheralAddon::cb_refresh_button_maps(void* kodiInstance, const char* deviceName, const char* controllerId)
@@ -868,28 +904,16 @@ void CPeripheralAddon::cb_refresh_button_maps(void* kodiInstance, const char* de
 
 unsigned int CPeripheralAddon::cb_feature_count(void* kodiInstance, const char* controllerId, JOYSTICK_FEATURE_TYPE type)
 {
-  using namespace GAME;
+  if (kodiInstance == nullptr || controllerId == nullptr)
+    return 0;
 
-  unsigned int count = 0;
-
-  CControllerManager& controllerManager = CServiceBroker::GetGameControllerManager();
-  ControllerPtr controller = controllerManager.GetController(controllerId);
-  if (controller)
-    count = controller->FeatureCount(CPeripheralAddonTranslator::TranslateFeatureType(type));
-
-  return count;
+  return static_cast<CPeripheralAddon*>(kodiInstance)->FeatureCount(controllerId, type);
 }
 
 JOYSTICK_FEATURE_TYPE CPeripheralAddon::cb_feature_type(void* kodiInstance, const char* controllerId, const char* featureName)
 {
-  using namespace GAME;
-
-  JOYSTICK_FEATURE_TYPE type = JOYSTICK_FEATURE_TYPE::JOYSTICK_FEATURE_TYPE_UNKNOWN;
+  if (kodiInstance == nullptr || controllerId == nullptr || featureName == nullptr)
+    return JOYSTICK_FEATURE_TYPE_UNKNOWN;
 
-  CControllerManager& controllerManager = CServiceBroker::GetGameControllerManager();
-  ControllerPtr controller = controllerManager.GetController(controllerId);
-  if (controller)
-    type = CPeripheralAddonTranslator::TranslateFeatureType(controller->FeatureType(featureName));
-
-  return type;
+  return static_cast<CPeripheralAddon*>(kodiInstance)->FeatureType(controllerId, featureName);
 }
diff --git a/xbmc/peripherals/addons/PeripheralAddon.h b/xbmc/peripherals/addons/PeripheralAddon.h
index 8b825d8a2c..476d07b65e 100644
--- a/xbmc/peripherals/addons/PeripheralAddon.h
+++ b/xbmc/peripherals/addons/PeripheralAddon.h
@@ -45,6 +45,7 @@ namespace PERIPHERALS
 {
   class CPeripheral;
   class CPeripheralJoystick;
+  class CPeripherals;
 
   typedef std::vector<kodi::addon::DriverPrimitive> PrimitiveVector;
   typedef std::map<KODI::JOYSTICK::FeatureName, kodi::addon::JoystickFeature> FeatureMap;
@@ -52,7 +53,7 @@ namespace PERIPHERALS
   class CPeripheralAddon : public ADDON::IAddonInstanceHandler
   {
   public:
-    explicit CPeripheralAddon(const ADDON::BinaryAddonBasePtr& addonInfo);
+    explicit CPeripheralAddon(const ADDON::BinaryAddonBasePtr& addonInfo, CPeripherals &manager);
     ~CPeripheralAddon(void) override;
 
     /*!
@@ -100,7 +101,6 @@ namespace PERIPHERALS
 
     void RegisterButtonMap(CPeripheral* device, KODI::JOYSTICK::IButtonMap* buttonMap);
     void UnregisterButtonMap(KODI::JOYSTICK::IButtonMap* buttonMap);
-    void RefreshButtonMaps(const std::string& strDeviceName = "");
 
     static inline bool ProvidesJoysticks(const ADDON::BinaryAddonBasePtr& addonInfo)
     {
@@ -115,6 +115,12 @@ namespace PERIPHERALS
   private:
     void UnregisterButtonMap(CPeripheral* device);
 
+    // Binary add-on callbacks
+    void TriggerDeviceScan();
+    void RefreshButtonMaps(const std::string& strDeviceName = "");
+    unsigned int FeatureCount(const std::string &controllerId, JOYSTICK_FEATURE_TYPE type) const;
+    JOYSTICK_FEATURE_TYPE FeatureType(const std::string &controllerId, const std::string &featureName) const;
+
     /*!
      * @brief Helper functions
      */
@@ -138,6 +144,9 @@ namespace PERIPHERALS
     static std::string GetDeviceName(PeripheralType type);
     static std::string GetProvider(PeripheralType type);
 
+    // Construction parameters
+    CPeripherals &m_manager;
+
     /* @brief Cache for const char* members in PERIPHERAL_PROPERTIES */
     std::string         m_strUserPath;    /*!< @brief translated path to the user profile */
     std::string         m_strClientPath;  /*!< @brief translated path to this add-on */
diff --git a/xbmc/peripherals/bus/virtual/PeripheralBusAddon.cpp b/xbmc/peripherals/bus/virtual/PeripheralBusAddon.cpp
index f980fe290b..d81062d641 100644
--- a/xbmc/peripherals/bus/virtual/PeripheralBusAddon.cpp
+++ b/xbmc/peripherals/bus/virtual/PeripheralBusAddon.cpp
@@ -417,7 +417,7 @@ void CPeripheralBusAddon::UpdateAddons(void)
     BinaryAddonBaseList::iterator it = std::find_if(newAddons.begin(), newAddons.end(), GetAddon);
     if (it != newAddons.end())
     {
-      PeripheralAddonPtr newAddon = std::make_shared<CPeripheralAddon>(*it);
+      PeripheralAddonPtr newAddon = std::make_shared<CPeripheralAddon>(*it, m_manager);
       if (newAddon)
       {
         bool bCreated;
diff --git a/xbmc/peripherals/devices/PeripheralHID.cpp b/xbmc/peripherals/devices/PeripheralHID.cpp
index 7636978a56..e86b0ff0b7 100644
--- a/xbmc/peripherals/devices/PeripheralHID.cpp
+++ b/xbmc/peripherals/devices/PeripheralHID.cpp
@@ -22,7 +22,7 @@
 #include "utils/log.h"
 #include "guilib/LocalizeStrings.h"
 #include "input/InputManager.h"
-#include "ServiceBroker.h"
+#include "peripherals/Peripherals.h"
 
 using namespace PERIPHERALS;
 
@@ -38,7 +38,7 @@ CPeripheralHID::~CPeripheralHID(void)
   if (!m_strKeymap.empty() && !GetSettingBool("do_not_use_custom_keymap"))
   {
     CLog::Log(LOGDEBUG, "%s - switching active keymapping to: default", __FUNCTION__);
-    CServiceBroker::GetInputManager().RemoveKeymap(m_strKeymap);
+    m_manager.GetInputManager().RemoveKeymap(m_strKeymap);
   }
 }
 
@@ -66,12 +66,12 @@ bool CPeripheralHID::InitialiseFeature(const PeripheralFeature feature)
       if (bKeymapEnabled)
       {
         CLog::Log(LOGDEBUG, "%s - adding keymapping for: %s", __FUNCTION__, m_strKeymap.c_str());
-        CServiceBroker::GetInputManager().AddKeymap(m_strKeymap);
+        m_manager.GetInputManager().AddKeymap(m_strKeymap);
       }
       else if (!bKeymapEnabled)
       {
         CLog::Log(LOGDEBUG, "%s - removing keymapping for: %s", __FUNCTION__, m_strKeymap.c_str());
-        CServiceBroker::GetInputManager().RemoveKeymap(m_strKeymap);
+        m_manager.GetInputManager().RemoveKeymap(m_strKeymap);
       }
     }
 
diff --git a/xbmc/peripherals/devices/PeripheralJoystick.cpp b/xbmc/peripherals/devices/PeripheralJoystick.cpp
index ff97956163..c8db2a6019 100644
--- a/xbmc/peripherals/devices/PeripheralJoystick.cpp
+++ b/xbmc/peripherals/devices/PeripheralJoystick.cpp
@@ -34,7 +34,6 @@
 #include "threads/SingleLock.h"
 #include "utils/log.h"
 #include "Application.h"
-#include "ServiceBroker.h"
 
 #include <algorithm>
 
@@ -93,7 +92,7 @@ bool CPeripheralJoystick::InitialiseFeature(const PeripheralFeature feature)
         InitializeDeadzoneFiltering();
 
         // Give joystick monitor priority over default controller
-        m_appInput.reset(new CKeymapHandling(this, false, CServiceBroker::GetInputManager().KeymapEnvironment()));
+        m_appInput.reset(new CKeymapHandling(this, false, m_manager.GetInputManager().KeymapEnvironment()));
         m_joystickMonitor.reset(new CJoystickMonitor);
         RegisterInputHandler(m_joystickMonitor.get(), false);
       }
diff --git a/xbmc/peripherals/devices/PeripheralJoystickEmulation.cpp b/xbmc/peripherals/devices/PeripheralJoystickEmulation.cpp
index dbed666b6c..fa9080809d 100644
--- a/xbmc/peripherals/devices/PeripheralJoystickEmulation.cpp
+++ b/xbmc/peripherals/devices/PeripheralJoystickEmulation.cpp
@@ -21,8 +21,8 @@
 #include "PeripheralJoystickEmulation.h"
 #include "input/keyboard/generic/JoystickEmulation.h"
 #include "input/InputManager.h"
+#include "peripherals/Peripherals.h"
 #include "threads/SingleLock.h"
-#include "ServiceBroker.h"
 
 #include <algorithm>
 #include <sstream>
@@ -38,7 +38,7 @@ CPeripheralJoystickEmulation::CPeripheralJoystickEmulation(CPeripherals& manager
 
 CPeripheralJoystickEmulation::~CPeripheralJoystickEmulation(void)
 {
-  CServiceBroker::GetInputManager().UnregisterKeyboardHandler(this);
+  m_manager.GetInputManager().UnregisterKeyboardHandler(this);
 }
 
 bool CPeripheralJoystickEmulation::InitialiseFeature(const PeripheralFeature feature)
@@ -49,7 +49,7 @@ bool CPeripheralJoystickEmulation::InitialiseFeature(const PeripheralFeature fea
   {
     if (feature == FEATURE_JOYSTICK)
     {
-      CServiceBroker::GetInputManager().RegisterKeyboardHandler(this);
+      m_manager.GetInputManager().RegisterKeyboardHandler(this);
     }
     bSuccess = true;
   }
diff --git a/xbmc/settings/Settings.cpp b/xbmc/settings/Settings.cpp
index 65c4bc29cb..3ed90eb3aa 100644
--- a/xbmc/settings/Settings.cpp
+++ b/xbmc/settings/Settings.cpp
@@ -31,7 +31,6 @@
 #include "cores/playercorefactory/PlayerCoreFactory.h"
 #include "cores/VideoPlayer/VideoRenderers/BaseRenderer.h"
 #include "filesystem/File.h"
-#include "games/GameSettings.h"
 #include "guilib/GUIAudioManager.h"
 #include "guilib/GUIFontManager.h"
 #include "guilib/StereoscopicsManager.h"
@@ -1003,20 +1002,6 @@ void CSettings::InitializeISettingCallbacks()
   settingSet.insert(CSettings::SETTING_POWERMANAGEMENT_WAKEONACCESS);
   GetSettingsManager()->RegisterCallback(&CWakeOnAccess::GetInstance(), settingSet);
 
-  settingSet.clear();
-  settingSet.insert(CSettings::SETTING_GAMES_KEYBOARD_PLAYERS);
-  settingSet.insert(CSettings::SETTING_GAMES_KEYBOARD_PLAYERCONFIG_1);
-  settingSet.insert(CSettings::SETTING_GAMES_KEYBOARD_PLAYERCONFIG_2);
-  settingSet.insert(CSettings::SETTING_GAMES_KEYBOARD_PLAYERCONFIG_3);
-  settingSet.insert(CSettings::SETTING_GAMES_KEYBOARD_PLAYERCONFIG_4);
-  settingSet.insert(CSettings::SETTING_GAMES_KEYBOARD_PLAYERCONFIG_5);
-  settingSet.insert(CSettings::SETTING_GAMES_KEYBOARD_PLAYERCONFIG_6);
-  settingSet.insert(CSettings::SETTING_GAMES_KEYBOARD_PLAYERCONFIG_7);
-  settingSet.insert(CSettings::SETTING_GAMES_KEYBOARD_PLAYERCONFIG_8);
-  settingSet.insert(CSettings::SETTING_GAMES_ENABLEREWIND);
-  settingSet.insert(CSettings::SETTING_GAMES_REWINDTIME);
-  GetSettingsManager()->RegisterCallback(&GAME::CGameSettings::GetInstance(), settingSet);
-
 #ifdef HAVE_LIBBLURAY
   settingSet.clear();
   settingSet.insert(CSettings::SETTING_DISC_PLAYBACK);
@@ -1039,7 +1024,6 @@ void CSettings::UninitializeISettingCallbacks()
   GetSettingsManager()->UnregisterCallback(&CNetworkServices::GetInstance());
   GetSettingsManager()->UnregisterCallback(&g_passwordManager);
   GetSettingsManager()->UnregisterCallback(&CRssManager::GetInstance());
-  GetSettingsManager()->UnregisterCallback(&GAME::CGameSettings::GetInstance());
 #if defined(TARGET_LINUX)
   GetSettingsManager()->UnregisterCallback(&g_timezone);
 #endif // defined(TARGET_LINUX)