From c04dcc2e7d834218ef2d4194331e383402495ae1 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Wed, 10 Apr 2024 20:07:22 +0200 Subject: Adding upstream version 2:20.4+dfsg. Signed-off-by: Daniel Baumann --- xbmc/games/ports/input/CMakeLists.txt | 11 + xbmc/games/ports/input/PhysicalPort.cpp | 66 ++++++ xbmc/games/ports/input/PhysicalPort.h | 64 ++++++ xbmc/games/ports/input/PortInput.cpp | 129 ++++++++++++ xbmc/games/ports/input/PortInput.h | 77 +++++++ xbmc/games/ports/input/PortManager.cpp | 347 ++++++++++++++++++++++++++++++++ xbmc/games/ports/input/PortManager.h | 81 ++++++++ 7 files changed, 775 insertions(+) create mode 100644 xbmc/games/ports/input/CMakeLists.txt create mode 100644 xbmc/games/ports/input/PhysicalPort.cpp create mode 100644 xbmc/games/ports/input/PhysicalPort.h create mode 100644 xbmc/games/ports/input/PortInput.cpp create mode 100644 xbmc/games/ports/input/PortInput.h create mode 100644 xbmc/games/ports/input/PortManager.cpp create mode 100644 xbmc/games/ports/input/PortManager.h (limited to 'xbmc/games/ports/input') 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 +#include + +using namespace KODI; +using namespace GAME; + +CPhysicalPort::CPhysicalPort(std::string portId, std::vector 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 +#include + +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 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& 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 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 + +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 m_appInput; + + // Prevents input falling through to Kodi when not handled by the game + std::unique_ptr 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 + +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& 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& task) { + return task.wait_for(std::chrono::seconds(0)) == + std::future_status::ready; + }), + m_saveFutures.end()); + + // Save async + std::future 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 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 +#include +#include + +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> m_saveFutures; + std::mutex m_saveMutex; +}; +} // namespace GAME +} // namespace KODI -- cgit v1.2.3