Merge pull request #13340 from garbear/game-globals

Games: Register setting handlers inside CGameSettings

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();

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))
 {
 }

xbmc/games/GameServices.h

@@ -24,6 +24,8 @@
 #include <memory>
 #include <string>
 
+class CSettings;
+
 namespace PERIPHERALS
 {
   class CPeripherals;
@@ -39,20 +41,23 @@ namespace RETRO
 namespace GAME
 {
   class CControllerManager;
+  class CGameSettings;
   class CPortManager;
 
   class CGameServices
   {
   public:
     CGameServices(CControllerManager &controllerManager,
                   RETRO::CGUIGameRenderManager &renderManager,
+                  CSettings &settings,
                   PERIPHERALS::CPeripherals &peripheralManager);
     ~CGameServices();
 
     ControllerPtr GetController(const std::string& controllerId);
     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;
   };
 }

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)

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

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();
 }

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

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;

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);
 }

xbmc/peripherals/addons/PeripheralAddon.h

@@ -45,14 +45,15 @@ 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;
 
   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 */