summaryrefslogtreecommitdiffstats
path: root/xbmc/peripherals/addons
diff options
context:
space:
mode:
Diffstat (limited to 'xbmc/peripherals/addons')
-rw-r--r--xbmc/peripherals/addons/AddonButtonMap.cpp734
-rw-r--r--xbmc/peripherals/addons/AddonButtonMap.h146
-rw-r--r--xbmc/peripherals/addons/AddonButtonMapping.cpp139
-rw-r--r--xbmc/peripherals/addons/AddonButtonMapping.h72
-rw-r--r--xbmc/peripherals/addons/AddonInputHandling.cpp192
-rw-r--r--xbmc/peripherals/addons/AddonInputHandling.h108
-rw-r--r--xbmc/peripherals/addons/CMakeLists.txt13
-rw-r--r--xbmc/peripherals/addons/PeripheralAddon.cpp990
-rw-r--r--xbmc/peripherals/addons/PeripheralAddon.h178
-rw-r--r--xbmc/peripherals/addons/PeripheralAddonTranslator.cpp449
-rw-r--r--xbmc/peripherals/addons/PeripheralAddonTranslator.h62
11 files changed, 3083 insertions, 0 deletions
diff --git a/xbmc/peripherals/addons/AddonButtonMap.cpp b/xbmc/peripherals/addons/AddonButtonMap.cpp
new file mode 100644
index 0000000..0d76ec9
--- /dev/null
+++ b/xbmc/peripherals/addons/AddonButtonMap.cpp
@@ -0,0 +1,734 @@
+/*
+ * 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 "AddonButtonMap.h"
+
+#include "PeripheralAddonTranslator.h"
+#include "input/joysticks/JoystickUtils.h"
+#include "peripherals/Peripherals.h"
+#include "peripherals/devices/Peripheral.h"
+#include "utils/log.h"
+
+#include <algorithm>
+#include <assert.h>
+#include <mutex>
+#include <vector>
+
+using namespace KODI;
+using namespace JOYSTICK;
+using namespace PERIPHERALS;
+
+CAddonButtonMap::CAddonButtonMap(CPeripheral* device,
+ const std::weak_ptr<CPeripheralAddon>& addon,
+ const std::string& strControllerId,
+ CPeripherals& manager)
+ : m_device(device), m_addon(addon), m_strControllerId(strControllerId), m_manager(manager)
+{
+ auto peripheralAddon = m_addon.lock();
+ assert(peripheralAddon != nullptr);
+
+ peripheralAddon->RegisterButtonMap(device, this);
+}
+
+CAddonButtonMap::~CAddonButtonMap(void)
+{
+ if (auto addon = m_addon.lock())
+ addon->UnregisterButtonMap(this);
+}
+
+std::string CAddonButtonMap::Location(void) const
+{
+ return m_device->Location();
+}
+
+bool CAddonButtonMap::Load(void)
+{
+ std::string controllerAppearance;
+ FeatureMap features;
+ DriverMap driverMap;
+ PrimitiveVector ignoredPrimitives;
+
+ bool bSuccess = false;
+ if (auto addon = m_addon.lock())
+ {
+ bSuccess |= addon->GetFeatures(m_device, m_strControllerId, features);
+ bSuccess |= addon->GetIgnoredPrimitives(m_device, ignoredPrimitives);
+ }
+
+ if (features.empty())
+ {
+ // Check if we can initialize a buttonmap from the peripheral bus
+ PeripheralBusPtr peripheralBus = m_manager.GetBusByType(m_device->GetBusType());
+ if (peripheralBus)
+ {
+ CLog::Log(LOGDEBUG,
+ "Buttonmap not found for {}, attempting to initialize from peripheral bus",
+ m_device->Location());
+ if (peripheralBus->InitializeButtonMap(*m_device, *this))
+ {
+ bSuccess = true;
+
+ if (auto addon = m_addon.lock())
+ {
+ addon->GetFeatures(m_device, m_strControllerId, features);
+ addon->GetIgnoredPrimitives(m_device, ignoredPrimitives);
+ }
+ }
+ }
+ }
+
+ // GetFeatures() was changed to always return false if no features were
+ // retrieved. Check here, just in case its contract is changed or violated in
+ // the future.
+ if (bSuccess && features.empty())
+ bSuccess = false;
+
+ if (bSuccess)
+ driverMap = CreateLookupTable(features);
+ else
+ CLog::Log(LOGDEBUG, "Failed to load button map for \"{}\"", m_device->Location());
+
+ {
+ std::unique_lock<CCriticalSection> lock(m_mutex);
+ m_controllerAppearance = std::move(controllerAppearance);
+ m_features = std::move(features);
+ m_driverMap = std::move(driverMap);
+ m_ignoredPrimitives = CPeripheralAddonTranslator::TranslatePrimitives(ignoredPrimitives);
+ }
+
+ return true;
+}
+
+void CAddonButtonMap::Reset(void)
+{
+ if (auto addon = m_addon.lock())
+ addon->ResetButtonMap(m_device, m_strControllerId);
+}
+
+bool CAddonButtonMap::IsEmpty(void) const
+{
+ std::unique_lock<CCriticalSection> lock(m_mutex);
+
+ return m_driverMap.empty();
+}
+
+std::string CAddonButtonMap::GetAppearance() const
+{
+ std::unique_lock<CCriticalSection> lock(m_mutex);
+
+ return m_controllerAppearance;
+}
+
+bool CAddonButtonMap::SetAppearance(const std::string& controllerId) const
+{
+ return false;
+}
+
+bool CAddonButtonMap::GetFeature(const CDriverPrimitive& primitive, FeatureName& feature)
+{
+ std::unique_lock<CCriticalSection> lock(m_mutex);
+
+ DriverMap::const_iterator it = m_driverMap.find(primitive);
+ if (it != m_driverMap.end())
+ {
+ feature = it->second;
+ return true;
+ }
+
+ return false;
+}
+
+FEATURE_TYPE CAddonButtonMap::GetFeatureType(const FeatureName& feature)
+{
+ FEATURE_TYPE type = FEATURE_TYPE::UNKNOWN;
+
+ std::unique_lock<CCriticalSection> lock(m_mutex);
+
+ FeatureMap::const_iterator it = m_features.find(feature);
+ if (it != m_features.end())
+ type = CPeripheralAddonTranslator::TranslateFeatureType(it->second.Type());
+
+ return type;
+}
+
+bool CAddonButtonMap::GetScalar(const FeatureName& feature, CDriverPrimitive& primitive)
+{
+ bool retVal(false);
+
+ std::unique_lock<CCriticalSection> lock(m_mutex);
+
+ FeatureMap::const_iterator it = m_features.find(feature);
+ if (it != m_features.end())
+ {
+ const kodi::addon::JoystickFeature& addonFeature = it->second;
+
+ if (addonFeature.Type() == JOYSTICK_FEATURE_TYPE_SCALAR ||
+ addonFeature.Type() == JOYSTICK_FEATURE_TYPE_MOTOR)
+ {
+ primitive = CPeripheralAddonTranslator::TranslatePrimitive(
+ addonFeature.Primitive(JOYSTICK_SCALAR_PRIMITIVE));
+ retVal = true;
+ }
+ }
+
+ return retVal;
+}
+
+void CAddonButtonMap::AddScalar(const FeatureName& feature, const CDriverPrimitive& primitive)
+{
+ const bool bMotor = (primitive.Type() == PRIMITIVE_TYPE::MOTOR);
+
+ kodi::addon::JoystickFeature scalar(feature, bMotor ? JOYSTICK_FEATURE_TYPE_MOTOR
+ : JOYSTICK_FEATURE_TYPE_SCALAR);
+ scalar.SetPrimitive(JOYSTICK_SCALAR_PRIMITIVE,
+ CPeripheralAddonTranslator::TranslatePrimitive(primitive));
+
+ if (auto addon = m_addon.lock())
+ addon->MapFeature(m_device, m_strControllerId, scalar);
+}
+
+bool CAddonButtonMap::GetAnalogStick(const FeatureName& feature,
+ JOYSTICK::ANALOG_STICK_DIRECTION direction,
+ JOYSTICK::CDriverPrimitive& primitive)
+{
+ bool retVal(false);
+
+ std::unique_lock<CCriticalSection> lock(m_mutex);
+
+ FeatureMap::const_iterator it = m_features.find(feature);
+ if (it != m_features.end())
+ {
+ const kodi::addon::JoystickFeature& addonFeature = it->second;
+
+ if (addonFeature.Type() == JOYSTICK_FEATURE_TYPE_ANALOG_STICK)
+ {
+ primitive = CPeripheralAddonTranslator::TranslatePrimitive(
+ addonFeature.Primitive(GetAnalogStickIndex(direction)));
+ retVal = primitive.IsValid();
+ }
+ }
+
+ return retVal;
+}
+
+void CAddonButtonMap::AddAnalogStick(const FeatureName& feature,
+ JOYSTICK::ANALOG_STICK_DIRECTION direction,
+ const JOYSTICK::CDriverPrimitive& primitive)
+{
+ using namespace JOYSTICK;
+
+ JOYSTICK_FEATURE_PRIMITIVE primitiveIndex = GetAnalogStickIndex(direction);
+ kodi::addon::DriverPrimitive addonPrimitive =
+ CPeripheralAddonTranslator::TranslatePrimitive(primitive);
+
+ kodi::addon::JoystickFeature analogStick(feature, JOYSTICK_FEATURE_TYPE_ANALOG_STICK);
+
+ {
+ std::unique_lock<CCriticalSection> lock(m_mutex);
+ auto it = m_features.find(feature);
+ if (it != m_features.end())
+ analogStick = it->second;
+ }
+
+ const bool bModified = (primitive != CPeripheralAddonTranslator::TranslatePrimitive(
+ analogStick.Primitive(primitiveIndex)));
+ if (bModified)
+ analogStick.SetPrimitive(primitiveIndex, addonPrimitive);
+
+ if (auto addon = m_addon.lock())
+ addon->MapFeature(m_device, m_strControllerId, analogStick);
+
+ // Because each direction is mapped individually, we need to refresh the
+ // feature each time a new direction is mapped.
+ if (bModified)
+ Load();
+}
+
+bool CAddonButtonMap::GetRelativePointer(const FeatureName& feature,
+ JOYSTICK::RELATIVE_POINTER_DIRECTION direction,
+ JOYSTICK::CDriverPrimitive& primitive)
+{
+ bool retVal(false);
+
+ std::unique_lock<CCriticalSection> lock(m_mutex);
+
+ FeatureMap::const_iterator it = m_features.find(feature);
+ if (it != m_features.end())
+ {
+ const kodi::addon::JoystickFeature& addonFeature = it->second;
+
+ if (addonFeature.Type() == JOYSTICK_FEATURE_TYPE_RELPOINTER)
+ {
+ primitive = CPeripheralAddonTranslator::TranslatePrimitive(
+ addonFeature.Primitive(GetRelativePointerIndex(direction)));
+ retVal = primitive.IsValid();
+ }
+ }
+
+ return retVal;
+}
+
+void CAddonButtonMap::AddRelativePointer(const FeatureName& feature,
+ JOYSTICK::RELATIVE_POINTER_DIRECTION direction,
+ const JOYSTICK::CDriverPrimitive& primitive)
+{
+ using namespace JOYSTICK;
+
+ JOYSTICK_FEATURE_PRIMITIVE primitiveIndex = GetRelativePointerIndex(direction);
+ kodi::addon::DriverPrimitive addonPrimitive =
+ CPeripheralAddonTranslator::TranslatePrimitive(primitive);
+
+ kodi::addon::JoystickFeature relPointer(feature, JOYSTICK_FEATURE_TYPE_RELPOINTER);
+
+ {
+ std::unique_lock<CCriticalSection> lock(m_mutex);
+ auto it = m_features.find(feature);
+ if (it != m_features.end())
+ relPointer = it->second;
+ }
+
+ const bool bModified = (primitive != CPeripheralAddonTranslator::TranslatePrimitive(
+ relPointer.Primitive(primitiveIndex)));
+ if (bModified)
+ relPointer.SetPrimitive(primitiveIndex, addonPrimitive);
+
+ if (auto addon = m_addon.lock())
+ addon->MapFeature(m_device, m_strControllerId, relPointer);
+
+ // Because each direction is mapped individually, we need to refresh the
+ // feature each time a new direction is mapped.
+ if (bModified)
+ Load();
+}
+
+bool CAddonButtonMap::GetAccelerometer(const FeatureName& feature,
+ CDriverPrimitive& positiveX,
+ CDriverPrimitive& positiveY,
+ CDriverPrimitive& positiveZ)
+{
+ bool retVal(false);
+
+ std::unique_lock<CCriticalSection> lock(m_mutex);
+
+ FeatureMap::const_iterator it = m_features.find(feature);
+ if (it != m_features.end())
+ {
+ const kodi::addon::JoystickFeature& addonFeature = it->second;
+
+ if (addonFeature.Type() == JOYSTICK_FEATURE_TYPE_ACCELEROMETER)
+ {
+ positiveX = CPeripheralAddonTranslator::TranslatePrimitive(
+ addonFeature.Primitive(JOYSTICK_ACCELEROMETER_POSITIVE_X));
+ positiveY = CPeripheralAddonTranslator::TranslatePrimitive(
+ addonFeature.Primitive(JOYSTICK_ACCELEROMETER_POSITIVE_Y));
+ positiveZ = CPeripheralAddonTranslator::TranslatePrimitive(
+ addonFeature.Primitive(JOYSTICK_ACCELEROMETER_POSITIVE_Z));
+ retVal = true;
+ }
+ }
+
+ return retVal;
+}
+
+void CAddonButtonMap::AddAccelerometer(const FeatureName& feature,
+ const CDriverPrimitive& positiveX,
+ const CDriverPrimitive& positiveY,
+ const CDriverPrimitive& positiveZ)
+{
+ using namespace JOYSTICK;
+
+ kodi::addon::JoystickFeature accelerometer(feature, JOYSTICK_FEATURE_TYPE_ACCELEROMETER);
+
+ accelerometer.SetPrimitive(JOYSTICK_ACCELEROMETER_POSITIVE_X,
+ CPeripheralAddonTranslator::TranslatePrimitive(positiveX));
+ accelerometer.SetPrimitive(JOYSTICK_ACCELEROMETER_POSITIVE_Y,
+ CPeripheralAddonTranslator::TranslatePrimitive(positiveY));
+ accelerometer.SetPrimitive(JOYSTICK_ACCELEROMETER_POSITIVE_Z,
+ CPeripheralAddonTranslator::TranslatePrimitive(positiveZ));
+
+ if (auto addon = m_addon.lock())
+ addon->MapFeature(m_device, m_strControllerId, accelerometer);
+}
+
+bool CAddonButtonMap::GetWheel(const KODI::JOYSTICK::FeatureName& feature,
+ KODI::JOYSTICK::WHEEL_DIRECTION direction,
+ KODI::JOYSTICK::CDriverPrimitive& primitive)
+{
+ bool retVal(false);
+
+ std::unique_lock<CCriticalSection> lock(m_mutex);
+
+ FeatureMap::const_iterator it = m_features.find(feature);
+ if (it != m_features.end())
+ {
+ const kodi::addon::JoystickFeature& addonFeature = it->second;
+
+ if (addonFeature.Type() == JOYSTICK_FEATURE_TYPE_WHEEL)
+ {
+ primitive = CPeripheralAddonTranslator::TranslatePrimitive(
+ addonFeature.Primitive(GetPrimitiveIndex(direction)));
+ retVal = primitive.IsValid();
+ }
+ }
+
+ return retVal;
+}
+
+void CAddonButtonMap::AddWheel(const KODI::JOYSTICK::FeatureName& feature,
+ KODI::JOYSTICK::WHEEL_DIRECTION direction,
+ const KODI::JOYSTICK::CDriverPrimitive& primitive)
+{
+ using namespace JOYSTICK;
+
+ JOYSTICK_FEATURE_PRIMITIVE primitiveIndex = GetPrimitiveIndex(direction);
+ kodi::addon::DriverPrimitive addonPrimitive =
+ CPeripheralAddonTranslator::TranslatePrimitive(primitive);
+
+ kodi::addon::JoystickFeature joystickFeature(feature, JOYSTICK_FEATURE_TYPE_WHEEL);
+
+ {
+ std::unique_lock<CCriticalSection> lock(m_mutex);
+ auto it = m_features.find(feature);
+ if (it != m_features.end())
+ joystickFeature = it->second;
+ }
+
+ const bool bModified = (primitive != CPeripheralAddonTranslator::TranslatePrimitive(
+ joystickFeature.Primitive(primitiveIndex)));
+ if (bModified)
+ joystickFeature.SetPrimitive(primitiveIndex, addonPrimitive);
+
+ if (auto addon = m_addon.lock())
+ addon->MapFeature(m_device, m_strControllerId, joystickFeature);
+
+ // Because each direction is mapped individually, we need to refresh the
+ // feature each time a new direction is mapped.
+ if (bModified)
+ Load();
+}
+
+bool CAddonButtonMap::GetThrottle(const KODI::JOYSTICK::FeatureName& feature,
+ KODI::JOYSTICK::THROTTLE_DIRECTION direction,
+ KODI::JOYSTICK::CDriverPrimitive& primitive)
+{
+ bool retVal(false);
+
+ std::unique_lock<CCriticalSection> lock(m_mutex);
+
+ FeatureMap::const_iterator it = m_features.find(feature);
+ if (it != m_features.end())
+ {
+ const kodi::addon::JoystickFeature& addonFeature = it->second;
+
+ if (addonFeature.Type() == JOYSTICK_FEATURE_TYPE_THROTTLE)
+ {
+ primitive = CPeripheralAddonTranslator::TranslatePrimitive(
+ addonFeature.Primitive(GetPrimitiveIndex(direction)));
+ retVal = primitive.IsValid();
+ }
+ }
+
+ return retVal;
+}
+
+void CAddonButtonMap::AddThrottle(const KODI::JOYSTICK::FeatureName& feature,
+ KODI::JOYSTICK::THROTTLE_DIRECTION direction,
+ const KODI::JOYSTICK::CDriverPrimitive& primitive)
+{
+ using namespace JOYSTICK;
+
+ JOYSTICK_FEATURE_PRIMITIVE primitiveIndex = GetPrimitiveIndex(direction);
+ kodi::addon::DriverPrimitive addonPrimitive =
+ CPeripheralAddonTranslator::TranslatePrimitive(primitive);
+
+ kodi::addon::JoystickFeature joystickFeature(feature, JOYSTICK_FEATURE_TYPE_THROTTLE);
+
+ {
+ std::unique_lock<CCriticalSection> lock(m_mutex);
+ auto it = m_features.find(feature);
+ if (it != m_features.end())
+ joystickFeature = it->second;
+ }
+
+ const bool bModified = (primitive != CPeripheralAddonTranslator::TranslatePrimitive(
+ joystickFeature.Primitive(primitiveIndex)));
+ if (bModified)
+ joystickFeature.SetPrimitive(primitiveIndex, addonPrimitive);
+
+ if (auto addon = m_addon.lock())
+ addon->MapFeature(m_device, m_strControllerId, joystickFeature);
+
+ // Because each direction is mapped individually, we need to refresh the
+ // feature each time a new direction is mapped.
+ if (bModified)
+ Load();
+}
+
+bool CAddonButtonMap::GetKey(const FeatureName& feature, CDriverPrimitive& primitive)
+{
+ bool retVal(false);
+
+ std::unique_lock<CCriticalSection> lock(m_mutex);
+
+ FeatureMap::const_iterator it = m_features.find(feature);
+ if (it != m_features.end())
+ {
+ const kodi::addon::JoystickFeature& addonFeature = it->second;
+
+ if (addonFeature.Type() == JOYSTICK_FEATURE_TYPE_KEY)
+ {
+ primitive = CPeripheralAddonTranslator::TranslatePrimitive(
+ addonFeature.Primitive(JOYSTICK_SCALAR_PRIMITIVE));
+ retVal = true;
+ }
+ }
+
+ return retVal;
+}
+
+void CAddonButtonMap::AddKey(const FeatureName& feature, const CDriverPrimitive& primitive)
+{
+ kodi::addon::JoystickFeature scalar(feature, JOYSTICK_FEATURE_TYPE_KEY);
+ scalar.SetPrimitive(JOYSTICK_SCALAR_PRIMITIVE,
+ CPeripheralAddonTranslator::TranslatePrimitive(primitive));
+
+ if (auto addon = m_addon.lock())
+ addon->MapFeature(m_device, m_strControllerId, scalar);
+}
+
+void CAddonButtonMap::SetIgnoredPrimitives(
+ const std::vector<JOYSTICK::CDriverPrimitive>& primitives)
+{
+ if (auto addon = m_addon.lock())
+ addon->SetIgnoredPrimitives(m_device,
+ CPeripheralAddonTranslator::TranslatePrimitives(primitives));
+}
+
+bool CAddonButtonMap::IsIgnored(const JOYSTICK::CDriverPrimitive& primitive)
+{
+ return std::find(m_ignoredPrimitives.begin(), m_ignoredPrimitives.end(), primitive) !=
+ m_ignoredPrimitives.end();
+}
+
+bool CAddonButtonMap::GetAxisProperties(unsigned int axisIndex, int& center, unsigned int& range)
+{
+ std::unique_lock<CCriticalSection> lock(m_mutex);
+
+ for (const auto& it : m_driverMap)
+ {
+ const CDriverPrimitive& primitive = it.first;
+
+ if (primitive.Type() != PRIMITIVE_TYPE::SEMIAXIS)
+ continue;
+
+ if (primitive.Index() != axisIndex)
+ continue;
+
+ center = primitive.Center();
+ range = primitive.Range();
+ return true;
+ }
+
+ return false;
+}
+
+void CAddonButtonMap::SaveButtonMap()
+{
+ if (auto addon = m_addon.lock())
+ addon->SaveButtonMap(m_device);
+}
+
+void CAddonButtonMap::RevertButtonMap()
+{
+ if (auto addon = m_addon.lock())
+ addon->RevertButtonMap(m_device);
+}
+
+CAddonButtonMap::DriverMap CAddonButtonMap::CreateLookupTable(const FeatureMap& features)
+{
+ using namespace JOYSTICK;
+
+ DriverMap driverMap;
+
+ for (const auto& it : features)
+ {
+ const kodi::addon::JoystickFeature& feature = it.second;
+
+ switch (feature.Type())
+ {
+ case JOYSTICK_FEATURE_TYPE_SCALAR:
+ case JOYSTICK_FEATURE_TYPE_KEY:
+ {
+ driverMap[CPeripheralAddonTranslator::TranslatePrimitive(
+ feature.Primitive(JOYSTICK_SCALAR_PRIMITIVE))] = it.first;
+ break;
+ }
+
+ case JOYSTICK_FEATURE_TYPE_ANALOG_STICK:
+ {
+ std::vector<JOYSTICK_FEATURE_PRIMITIVE> primitives = {
+ JOYSTICK_ANALOG_STICK_UP,
+ JOYSTICK_ANALOG_STICK_DOWN,
+ JOYSTICK_ANALOG_STICK_RIGHT,
+ JOYSTICK_ANALOG_STICK_LEFT,
+ };
+
+ for (auto primitive : primitives)
+ driverMap[CPeripheralAddonTranslator::TranslatePrimitive(feature.Primitive(primitive))] =
+ it.first;
+ break;
+ }
+
+ case JOYSTICK_FEATURE_TYPE_ACCELEROMETER:
+ {
+ std::vector<JOYSTICK_FEATURE_PRIMITIVE> primitives = {
+ JOYSTICK_ACCELEROMETER_POSITIVE_X,
+ JOYSTICK_ACCELEROMETER_POSITIVE_Y,
+ JOYSTICK_ACCELEROMETER_POSITIVE_Z,
+ };
+
+ for (auto primitive : primitives)
+ {
+ CDriverPrimitive translatedPrimitive =
+ CPeripheralAddonTranslator::TranslatePrimitive(feature.Primitive(primitive));
+ driverMap[translatedPrimitive] = it.first;
+
+ // Map opposite semiaxis
+ CDriverPrimitive oppositePrimitive = CDriverPrimitive(
+ translatedPrimitive.Index(), 0, translatedPrimitive.SemiAxisDirection() * -1, 1);
+ driverMap[oppositePrimitive] = it.first;
+ }
+ break;
+ }
+
+ case JOYSTICK_FEATURE_TYPE_WHEEL:
+ {
+ std::vector<JOYSTICK_FEATURE_PRIMITIVE> primitives = {
+ JOYSTICK_WHEEL_LEFT,
+ JOYSTICK_WHEEL_RIGHT,
+ };
+
+ for (auto primitive : primitives)
+ driverMap[CPeripheralAddonTranslator::TranslatePrimitive(feature.Primitive(primitive))] =
+ it.first;
+ break;
+ }
+
+ case JOYSTICK_FEATURE_TYPE_THROTTLE:
+ {
+ std::vector<JOYSTICK_FEATURE_PRIMITIVE> primitives = {
+ JOYSTICK_THROTTLE_UP,
+ JOYSTICK_THROTTLE_DOWN,
+ };
+
+ for (auto primitive : primitives)
+ driverMap[CPeripheralAddonTranslator::TranslatePrimitive(feature.Primitive(primitive))] =
+ it.first;
+ break;
+ }
+
+ case JOYSTICK_FEATURE_TYPE_RELPOINTER:
+ {
+ std::vector<JOYSTICK_FEATURE_PRIMITIVE> primitives = {
+ JOYSTICK_RELPOINTER_UP,
+ JOYSTICK_RELPOINTER_DOWN,
+ JOYSTICK_RELPOINTER_RIGHT,
+ JOYSTICK_RELPOINTER_LEFT,
+ };
+
+ for (auto primitive : primitives)
+ driverMap[CPeripheralAddonTranslator::TranslatePrimitive(feature.Primitive(primitive))] =
+ it.first;
+ break;
+ }
+
+ default:
+ break;
+ }
+ }
+
+ return driverMap;
+}
+
+JOYSTICK_FEATURE_PRIMITIVE CAddonButtonMap::GetAnalogStickIndex(
+ JOYSTICK::ANALOG_STICK_DIRECTION dir)
+{
+ using namespace JOYSTICK;
+
+ switch (dir)
+ {
+ case ANALOG_STICK_DIRECTION::UP:
+ return JOYSTICK_ANALOG_STICK_UP;
+ case ANALOG_STICK_DIRECTION::DOWN:
+ return JOYSTICK_ANALOG_STICK_DOWN;
+ case ANALOG_STICK_DIRECTION::RIGHT:
+ return JOYSTICK_ANALOG_STICK_RIGHT;
+ case ANALOG_STICK_DIRECTION::LEFT:
+ return JOYSTICK_ANALOG_STICK_LEFT;
+ default:
+ break;
+ }
+
+ return static_cast<JOYSTICK_FEATURE_PRIMITIVE>(0);
+}
+
+JOYSTICK_FEATURE_PRIMITIVE CAddonButtonMap::GetRelativePointerIndex(
+ JOYSTICK::RELATIVE_POINTER_DIRECTION dir)
+{
+ using namespace JOYSTICK;
+
+ switch (dir)
+ {
+ case RELATIVE_POINTER_DIRECTION::UP:
+ return JOYSTICK_RELPOINTER_UP;
+ case RELATIVE_POINTER_DIRECTION::DOWN:
+ return JOYSTICK_RELPOINTER_DOWN;
+ case RELATIVE_POINTER_DIRECTION::RIGHT:
+ return JOYSTICK_RELPOINTER_RIGHT;
+ case RELATIVE_POINTER_DIRECTION::LEFT:
+ return JOYSTICK_RELPOINTER_LEFT;
+ default:
+ break;
+ }
+
+ return static_cast<JOYSTICK_FEATURE_PRIMITIVE>(0);
+}
+
+JOYSTICK_FEATURE_PRIMITIVE CAddonButtonMap::GetPrimitiveIndex(JOYSTICK::WHEEL_DIRECTION dir)
+{
+ using namespace JOYSTICK;
+
+ switch (dir)
+ {
+ case WHEEL_DIRECTION::RIGHT:
+ return JOYSTICK_WHEEL_RIGHT;
+ case WHEEL_DIRECTION::LEFT:
+ return JOYSTICK_WHEEL_LEFT;
+ default:
+ break;
+ }
+
+ return static_cast<JOYSTICK_FEATURE_PRIMITIVE>(0);
+}
+
+JOYSTICK_FEATURE_PRIMITIVE CAddonButtonMap::GetPrimitiveIndex(JOYSTICK::THROTTLE_DIRECTION dir)
+{
+ using namespace JOYSTICK;
+
+ switch (dir)
+ {
+ case THROTTLE_DIRECTION::UP:
+ return JOYSTICK_THROTTLE_UP;
+ case THROTTLE_DIRECTION::DOWN:
+ return JOYSTICK_THROTTLE_DOWN;
+ default:
+ break;
+ }
+
+ return static_cast<JOYSTICK_FEATURE_PRIMITIVE>(0);
+}
diff --git a/xbmc/peripherals/addons/AddonButtonMap.h b/xbmc/peripherals/addons/AddonButtonMap.h
new file mode 100644
index 0000000..cade54b
--- /dev/null
+++ b/xbmc/peripherals/addons/AddonButtonMap.h
@@ -0,0 +1,146 @@
+/*
+ * 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 "PeripheralAddon.h" // for FeatureMap
+#include "input/joysticks/DriverPrimitive.h"
+#include "input/joysticks/JoystickTypes.h"
+#include "input/joysticks/interfaces/IButtonMap.h"
+#include "peripherals/PeripheralTypes.h"
+#include "threads/CriticalSection.h"
+
+namespace PERIPHERALS
+{
+class CPeripheral;
+class CPeripherals;
+
+class CAddonButtonMap : public KODI::JOYSTICK::IButtonMap
+{
+public:
+ CAddonButtonMap(CPeripheral* device,
+ const std::weak_ptr<CPeripheralAddon>& addon,
+ const std::string& strControllerId,
+ CPeripherals& manager);
+
+ ~CAddonButtonMap(void) override;
+
+ // Implementation of IButtonMap
+ std::string ControllerID(void) const override { return m_strControllerId; }
+
+ std::string Location(void) const override;
+
+ bool Load(void) override;
+
+ void Reset(void) override;
+
+ bool IsEmpty(void) const override;
+
+ std::string GetAppearance() const override;
+
+ bool SetAppearance(const std::string& controllerId) const override;
+
+ bool GetFeature(const KODI::JOYSTICK::CDriverPrimitive& primitive,
+ KODI::JOYSTICK::FeatureName& feature) override;
+
+ KODI::JOYSTICK::FEATURE_TYPE GetFeatureType(const KODI::JOYSTICK::FeatureName& feature) override;
+
+ bool GetScalar(const KODI::JOYSTICK::FeatureName& feature,
+ KODI::JOYSTICK::CDriverPrimitive& primitive) override;
+
+ void AddScalar(const KODI::JOYSTICK::FeatureName& feature,
+ const KODI::JOYSTICK::CDriverPrimitive& primitive) override;
+
+ bool GetAnalogStick(const KODI::JOYSTICK::FeatureName& feature,
+ KODI::JOYSTICK::ANALOG_STICK_DIRECTION direction,
+ KODI::JOYSTICK::CDriverPrimitive& primitive) override;
+
+ void AddAnalogStick(const KODI::JOYSTICK::FeatureName& feature,
+ KODI::JOYSTICK::ANALOG_STICK_DIRECTION direction,
+ const KODI::JOYSTICK::CDriverPrimitive& primitive) override;
+
+ bool GetRelativePointer(const KODI::JOYSTICK::FeatureName& feature,
+ KODI::JOYSTICK::RELATIVE_POINTER_DIRECTION direction,
+ KODI::JOYSTICK::CDriverPrimitive& primitive) override;
+
+ void AddRelativePointer(const KODI::JOYSTICK::FeatureName& feature,
+ KODI::JOYSTICK::RELATIVE_POINTER_DIRECTION direction,
+ const KODI::JOYSTICK::CDriverPrimitive& primitive) override;
+
+ bool GetAccelerometer(const KODI::JOYSTICK::FeatureName& feature,
+ KODI::JOYSTICK::CDriverPrimitive& positiveX,
+ KODI::JOYSTICK::CDriverPrimitive& positiveY,
+ KODI::JOYSTICK::CDriverPrimitive& positiveZ) override;
+
+ void AddAccelerometer(const KODI::JOYSTICK::FeatureName& feature,
+ const KODI::JOYSTICK::CDriverPrimitive& positiveX,
+ const KODI::JOYSTICK::CDriverPrimitive& positiveY,
+ const KODI::JOYSTICK::CDriverPrimitive& positiveZ) override;
+
+ bool GetWheel(const KODI::JOYSTICK::FeatureName& feature,
+ KODI::JOYSTICK::WHEEL_DIRECTION direction,
+ KODI::JOYSTICK::CDriverPrimitive& primitive) override;
+
+ void AddWheel(const KODI::JOYSTICK::FeatureName& feature,
+ KODI::JOYSTICK::WHEEL_DIRECTION direction,
+ const KODI::JOYSTICK::CDriverPrimitive& primitive) override;
+
+ bool GetThrottle(const KODI::JOYSTICK::FeatureName& feature,
+ KODI::JOYSTICK::THROTTLE_DIRECTION direction,
+ KODI::JOYSTICK::CDriverPrimitive& primitive) override;
+
+ void AddThrottle(const KODI::JOYSTICK::FeatureName& feature,
+ KODI::JOYSTICK::THROTTLE_DIRECTION direction,
+ const KODI::JOYSTICK::CDriverPrimitive& primitive) override;
+
+ bool GetKey(const KODI::JOYSTICK::FeatureName& feature,
+ KODI::JOYSTICK::CDriverPrimitive& primitive) override;
+
+ void AddKey(const KODI::JOYSTICK::FeatureName& feature,
+ const KODI::JOYSTICK::CDriverPrimitive& primitive) override;
+
+ void SetIgnoredPrimitives(
+ const std::vector<KODI::JOYSTICK::CDriverPrimitive>& primitives) override;
+
+ bool IsIgnored(const KODI::JOYSTICK::CDriverPrimitive& primitive) override;
+
+ bool GetAxisProperties(unsigned int axisIndex, int& center, unsigned int& range) override;
+
+ void SaveButtonMap() override;
+
+ void RevertButtonMap() override;
+
+private:
+ typedef std::map<KODI::JOYSTICK::CDriverPrimitive, KODI::JOYSTICK::FeatureName> DriverMap;
+ typedef std::vector<KODI::JOYSTICK::CDriverPrimitive> JoystickPrimitiveVector;
+
+ // Utility functions
+ static DriverMap CreateLookupTable(const FeatureMap& features);
+
+ static JOYSTICK_FEATURE_PRIMITIVE GetAnalogStickIndex(KODI::JOYSTICK::ANALOG_STICK_DIRECTION dir);
+ static JOYSTICK_FEATURE_PRIMITIVE GetRelativePointerIndex(
+ KODI::JOYSTICK::RELATIVE_POINTER_DIRECTION dir);
+ static JOYSTICK_FEATURE_PRIMITIVE GetPrimitiveIndex(KODI::JOYSTICK::WHEEL_DIRECTION dir);
+ static JOYSTICK_FEATURE_PRIMITIVE GetPrimitiveIndex(KODI::JOYSTICK::THROTTLE_DIRECTION dir);
+
+ // Construction parameters
+ CPeripheral* const m_device;
+ const std::weak_ptr<CPeripheralAddon> m_addon;
+ const std::string m_strControllerId;
+ CPeripherals& m_manager;
+
+ // Button map state
+ std::string m_controllerAppearance;
+ FeatureMap m_features;
+ DriverMap m_driverMap;
+ JoystickPrimitiveVector m_ignoredPrimitives;
+
+ // Synchronization parameters
+ mutable CCriticalSection m_mutex;
+};
+} // namespace PERIPHERALS
diff --git a/xbmc/peripherals/addons/AddonButtonMapping.cpp b/xbmc/peripherals/addons/AddonButtonMapping.cpp
new file mode 100644
index 0000000..abf981f
--- /dev/null
+++ b/xbmc/peripherals/addons/AddonButtonMapping.cpp
@@ -0,0 +1,139 @@
+/*
+ * 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 "AddonButtonMapping.h"
+
+#include "input/joysticks/generic/ButtonMapping.h"
+#include "input/joysticks/interfaces/IButtonMapper.h"
+#include "peripherals/Peripherals.h"
+#include "peripherals/addons/AddonButtonMap.h"
+#include "utils/log.h"
+
+using namespace KODI;
+using namespace JOYSTICK;
+using namespace PERIPHERALS;
+
+CAddonButtonMapping::CAddonButtonMapping(CPeripherals& manager,
+ CPeripheral* peripheral,
+ IButtonMapper* mapper)
+{
+ PeripheralAddonPtr addon = manager.GetAddonWithButtonMap(peripheral);
+
+ if (!addon)
+ {
+ CLog::Log(LOGDEBUG, "Failed to locate add-on for \"{}\"", peripheral->DeviceName());
+ }
+ else
+ {
+ const std::string controllerId = mapper->ControllerID();
+ m_buttonMap = std::make_unique<CAddonButtonMap>(peripheral, addon, controllerId, manager);
+ if (m_buttonMap->Load())
+ {
+ IKeymap* keymap = peripheral->GetKeymap(controllerId);
+ m_buttonMapping.reset(new CButtonMapping(mapper, m_buttonMap.get(), keymap));
+
+ // Allow the mapper to save our button map
+ mapper->SetButtonMapCallback(peripheral->Location(), this);
+ }
+ else
+ m_buttonMap.reset();
+ }
+}
+
+CAddonButtonMapping::~CAddonButtonMapping(void)
+{
+ m_buttonMapping.reset();
+ m_buttonMap.reset();
+}
+
+bool CAddonButtonMapping::OnButtonMotion(unsigned int buttonIndex, bool bPressed)
+{
+ if (m_buttonMapping)
+ return m_buttonMapping->OnButtonMotion(buttonIndex, bPressed);
+
+ return false;
+}
+
+bool CAddonButtonMapping::OnHatMotion(unsigned int hatIndex, HAT_STATE state)
+{
+ if (m_buttonMapping)
+ return m_buttonMapping->OnHatMotion(hatIndex, state);
+
+ return false;
+}
+
+bool CAddonButtonMapping::OnAxisMotion(unsigned int axisIndex,
+ float position,
+ int center,
+ unsigned int range)
+{
+ if (m_buttonMapping)
+ return m_buttonMapping->OnAxisMotion(axisIndex, position, center, range);
+
+ return false;
+}
+
+void CAddonButtonMapping::OnInputFrame(void)
+{
+ if (m_buttonMapping)
+ m_buttonMapping->OnInputFrame();
+}
+
+bool CAddonButtonMapping::OnKeyPress(const CKey& key)
+{
+ if (m_buttonMapping)
+ return m_buttonMapping->OnKeyPress(key);
+
+ return false;
+}
+
+void CAddonButtonMapping::OnKeyRelease(const CKey& key)
+{
+ if (m_buttonMapping)
+ m_buttonMapping->OnKeyRelease(key);
+}
+
+bool CAddonButtonMapping::OnPosition(int x, int y)
+{
+ if (m_buttonMapping)
+ return m_buttonMapping->OnPosition(x, y);
+
+ return false;
+}
+
+bool CAddonButtonMapping::OnButtonPress(MOUSE::BUTTON_ID button)
+{
+ if (m_buttonMapping)
+ return m_buttonMapping->OnButtonPress(button);
+
+ return false;
+}
+
+void CAddonButtonMapping::OnButtonRelease(MOUSE::BUTTON_ID button)
+{
+ if (m_buttonMapping)
+ m_buttonMapping->OnButtonRelease(button);
+}
+
+void CAddonButtonMapping::SaveButtonMap()
+{
+ if (m_buttonMapping)
+ m_buttonMapping->SaveButtonMap();
+}
+
+void CAddonButtonMapping::ResetIgnoredPrimitives()
+{
+ if (m_buttonMapping)
+ m_buttonMapping->ResetIgnoredPrimitives();
+}
+
+void CAddonButtonMapping::RevertButtonMap()
+{
+ if (m_buttonMapping)
+ m_buttonMapping->RevertButtonMap();
+}
diff --git a/xbmc/peripherals/addons/AddonButtonMapping.h b/xbmc/peripherals/addons/AddonButtonMapping.h
new file mode 100644
index 0000000..245a588
--- /dev/null
+++ b/xbmc/peripherals/addons/AddonButtonMapping.h
@@ -0,0 +1,72 @@
+/*
+ * 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 "input/joysticks/interfaces/IButtonMapCallback.h"
+#include "input/joysticks/interfaces/IDriverHandler.h"
+#include "input/keyboard/interfaces/IKeyboardDriverHandler.h"
+#include "input/mouse/interfaces/IMouseDriverHandler.h"
+
+#include <memory>
+
+namespace KODI
+{
+namespace JOYSTICK
+{
+class CButtonMapping;
+class IButtonMap;
+class IButtonMapper;
+} // namespace JOYSTICK
+} // namespace KODI
+
+namespace PERIPHERALS
+{
+class CPeripheral;
+class CPeripherals;
+
+class CAddonButtonMapping : public KODI::JOYSTICK::IDriverHandler,
+ public KODI::KEYBOARD::IKeyboardDriverHandler,
+ public KODI::MOUSE::IMouseDriverHandler,
+ public KODI::JOYSTICK::IButtonMapCallback
+{
+public:
+ CAddonButtonMapping(CPeripherals& manager,
+ CPeripheral* peripheral,
+ KODI::JOYSTICK::IButtonMapper* mapper);
+
+ ~CAddonButtonMapping(void) override;
+
+ // implementation of IDriverHandler
+ bool OnButtonMotion(unsigned int buttonIndex, bool bPressed) override;
+ bool OnHatMotion(unsigned int hatIndex, KODI::JOYSTICK::HAT_STATE state) override;
+ bool OnAxisMotion(unsigned int axisIndex,
+ float position,
+ int center,
+ unsigned int range) override;
+ void OnInputFrame(void) 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(KODI::MOUSE::BUTTON_ID button) override;
+ void OnButtonRelease(KODI::MOUSE::BUTTON_ID button) override;
+
+ // implementation of IButtonMapCallback
+ void SaveButtonMap() override;
+ void ResetIgnoredPrimitives() override;
+ void RevertButtonMap() override;
+
+private:
+ std::unique_ptr<KODI::JOYSTICK::CButtonMapping> m_buttonMapping;
+ std::unique_ptr<KODI::JOYSTICK::IButtonMap> m_buttonMap;
+};
+} // namespace PERIPHERALS
diff --git a/xbmc/peripherals/addons/AddonInputHandling.cpp b/xbmc/peripherals/addons/AddonInputHandling.cpp
new file mode 100644
index 0000000..7490b96
--- /dev/null
+++ b/xbmc/peripherals/addons/AddonInputHandling.cpp
@@ -0,0 +1,192 @@
+/*
+ * 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 "AddonInputHandling.h"
+
+#include "input/joysticks/generic/DriverReceiving.h"
+#include "input/joysticks/generic/InputHandling.h"
+#include "input/joysticks/interfaces/IDriverReceiver.h"
+#include "input/joysticks/interfaces/IInputHandler.h"
+#include "input/keyboard/generic/KeyboardInputHandling.h"
+#include "input/keyboard/interfaces/IKeyboardInputHandler.h"
+#include "input/mouse/generic/MouseInputHandling.h"
+#include "input/mouse/interfaces/IMouseInputHandler.h"
+#include "peripherals/addons/AddonButtonMap.h"
+#include "peripherals/devices/Peripheral.h"
+#include "utils/log.h"
+
+using namespace KODI;
+using namespace JOYSTICK;
+using namespace PERIPHERALS;
+
+CAddonInputHandling::CAddonInputHandling(CPeripherals& manager,
+ CPeripheral* peripheral,
+ std::shared_ptr<CPeripheralAddon> addon,
+ IInputHandler* handler,
+ IDriverReceiver* receiver)
+ : m_manager(manager),
+ m_peripheral(peripheral),
+ m_addon(std::move(addon)),
+ m_joystickInputHandler(handler),
+ m_joystickDriverReceiver(receiver)
+{
+}
+
+CAddonInputHandling::CAddonInputHandling(CPeripherals& manager,
+ CPeripheral* peripheral,
+ std::shared_ptr<CPeripheralAddon> addon,
+ KEYBOARD::IKeyboardInputHandler* handler)
+ : m_manager(manager),
+ m_peripheral(peripheral),
+ m_addon(std::move(addon)),
+ m_keyboardInputHandler(handler)
+{
+}
+
+CAddonInputHandling::CAddonInputHandling(CPeripherals& manager,
+ CPeripheral* peripheral,
+ std::shared_ptr<CPeripheralAddon> addon,
+ MOUSE::IMouseInputHandler* handler)
+ : m_manager(manager),
+ m_peripheral(peripheral),
+ m_addon(std::move(addon)),
+ m_mouseInputHandler(handler)
+{
+}
+
+CAddonInputHandling::~CAddonInputHandling(void)
+{
+ m_joystickDriverHandler.reset();
+ m_joystickInputReceiver.reset();
+ m_keyboardDriverHandler.reset();
+ m_mouseDriverHandler.reset();
+ m_buttonMap.reset();
+}
+
+bool CAddonInputHandling::Load()
+{
+ std::string controllerId;
+ if (m_joystickInputHandler != nullptr)
+ controllerId = m_joystickInputHandler->ControllerID();
+ else if (m_keyboardInputHandler != nullptr)
+ controllerId = m_keyboardInputHandler->ControllerID();
+ else if (m_mouseInputHandler != nullptr)
+ controllerId = m_mouseInputHandler->ControllerID();
+
+ if (!controllerId.empty())
+ m_buttonMap = std::make_unique<CAddonButtonMap>(m_peripheral, m_addon, controllerId, m_manager);
+
+ if (m_buttonMap && m_buttonMap->Load())
+ {
+ if (m_joystickInputHandler != nullptr)
+ {
+ m_joystickDriverHandler =
+ std::make_unique<CInputHandling>(m_joystickInputHandler, m_buttonMap.get());
+ if (m_joystickDriverReceiver != nullptr)
+ {
+ m_joystickInputReceiver =
+ std::make_unique<CDriverReceiving>(m_joystickDriverReceiver, m_buttonMap.get());
+
+ // Interfaces are connected here because they share button map as a common resource
+ m_joystickInputHandler->SetInputReceiver(m_joystickInputReceiver.get());
+ }
+ return true;
+ }
+ else if (m_keyboardInputHandler != nullptr)
+ {
+ m_keyboardDriverHandler = std::make_unique<KEYBOARD::CKeyboardInputHandling>(
+ m_keyboardInputHandler, m_buttonMap.get());
+ return true;
+ }
+ else if (m_mouseInputHandler != nullptr)
+ {
+ m_mouseDriverHandler =
+ std::make_unique<MOUSE::CMouseInputHandling>(m_mouseInputHandler, m_buttonMap.get());
+ return true;
+ }
+ }
+
+ return false;
+}
+
+bool CAddonInputHandling::OnButtonMotion(unsigned int buttonIndex, bool bPressed)
+{
+ if (m_joystickDriverHandler)
+ return m_joystickDriverHandler->OnButtonMotion(buttonIndex, bPressed);
+
+ return false;
+}
+
+bool CAddonInputHandling::OnHatMotion(unsigned int hatIndex, HAT_STATE state)
+{
+ if (m_joystickDriverHandler)
+ return m_joystickDriverHandler->OnHatMotion(hatIndex, state);
+
+ return false;
+}
+
+bool CAddonInputHandling::OnAxisMotion(unsigned int axisIndex,
+ float position,
+ int center,
+ unsigned int range)
+{
+ if (m_joystickDriverHandler)
+ return m_joystickDriverHandler->OnAxisMotion(axisIndex, position, center, range);
+
+ return false;
+}
+
+void CAddonInputHandling::OnInputFrame(void)
+{
+ if (m_joystickDriverHandler)
+ m_joystickDriverHandler->OnInputFrame();
+}
+
+bool CAddonInputHandling::OnKeyPress(const CKey& key)
+{
+ if (m_keyboardDriverHandler)
+ return m_keyboardDriverHandler->OnKeyPress(key);
+
+ return false;
+}
+
+void CAddonInputHandling::OnKeyRelease(const CKey& key)
+{
+ if (m_keyboardDriverHandler)
+ m_keyboardDriverHandler->OnKeyRelease(key);
+}
+
+bool CAddonInputHandling::OnPosition(int x, int y)
+{
+ if (m_mouseDriverHandler)
+ return m_mouseDriverHandler->OnPosition(x, y);
+
+ return false;
+}
+
+bool CAddonInputHandling::OnButtonPress(MOUSE::BUTTON_ID button)
+{
+ if (m_mouseDriverHandler)
+ return m_mouseDriverHandler->OnButtonPress(button);
+
+ return false;
+}
+
+void CAddonInputHandling::OnButtonRelease(MOUSE::BUTTON_ID button)
+{
+ if (m_mouseDriverHandler)
+ m_mouseDriverHandler->OnButtonRelease(button);
+}
+
+bool CAddonInputHandling::SetRumbleState(const JOYSTICK::FeatureName& feature, float magnitude)
+{
+ if (m_joystickInputReceiver)
+ return m_joystickInputReceiver->SetRumbleState(feature, magnitude);
+
+ return false;
+}
diff --git a/xbmc/peripherals/addons/AddonInputHandling.h b/xbmc/peripherals/addons/AddonInputHandling.h
new file mode 100644
index 0000000..295e6d4
--- /dev/null
+++ b/xbmc/peripherals/addons/AddonInputHandling.h
@@ -0,0 +1,108 @@
+/*
+ * 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 "input/joysticks/interfaces/IDriverHandler.h"
+#include "input/joysticks/interfaces/IInputReceiver.h"
+#include "input/keyboard/interfaces/IKeyboardDriverHandler.h"
+#include "input/mouse/interfaces/IMouseDriverHandler.h"
+
+#include <memory>
+
+namespace KODI
+{
+namespace JOYSTICK
+{
+class IButtonMap;
+class IDriverReceiver;
+class IInputHandler;
+} // namespace JOYSTICK
+
+namespace KEYBOARD
+{
+class IKeyboardInputHandler;
+}
+
+namespace MOUSE
+{
+class IMouseInputHandler;
+}
+} // namespace KODI
+
+namespace PERIPHERALS
+{
+class CPeripheral;
+class CPeripherals;
+class CPeripheralAddon;
+
+class CAddonInputHandling : public KODI::JOYSTICK::IDriverHandler,
+ public KODI::JOYSTICK::IInputReceiver,
+ public KODI::KEYBOARD::IKeyboardDriverHandler,
+ public KODI::MOUSE::IMouseDriverHandler
+{
+public:
+ CAddonInputHandling(CPeripherals& manager,
+ CPeripheral* peripheral,
+ std::shared_ptr<CPeripheralAddon> addon,
+ KODI::JOYSTICK::IInputHandler* handler,
+ KODI::JOYSTICK::IDriverReceiver* receiver);
+
+ CAddonInputHandling(CPeripherals& manager,
+ CPeripheral* peripheral,
+ std::shared_ptr<CPeripheralAddon> addon,
+ KODI::KEYBOARD::IKeyboardInputHandler* handler);
+
+ CAddonInputHandling(CPeripherals& manager,
+ CPeripheral* peripheral,
+ std::shared_ptr<CPeripheralAddon> addon,
+ KODI::MOUSE::IMouseInputHandler* handler);
+
+ ~CAddonInputHandling(void) override;
+
+ bool Load();
+
+ // implementation of IDriverHandler
+ bool OnButtonMotion(unsigned int buttonIndex, bool bPressed) override;
+ bool OnHatMotion(unsigned int hatIndex, KODI::JOYSTICK::HAT_STATE state) override;
+ bool OnAxisMotion(unsigned int axisIndex,
+ float position,
+ int center,
+ unsigned int range) override;
+ void OnInputFrame(void) 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(KODI::MOUSE::BUTTON_ID button) override;
+ void OnButtonRelease(KODI::MOUSE::BUTTON_ID button) override;
+
+ // implementation of IInputReceiver
+ bool SetRumbleState(const KODI::JOYSTICK::FeatureName& feature, float magnitude) override;
+
+private:
+ // Construction parameters
+ CPeripherals& m_manager;
+ CPeripheral* const m_peripheral;
+ const std::shared_ptr<CPeripheralAddon> m_addon;
+ KODI::JOYSTICK::IInputHandler* const m_joystickInputHandler{nullptr};
+ KODI::JOYSTICK::IDriverReceiver* const m_joystickDriverReceiver{nullptr};
+ KODI::KEYBOARD::IKeyboardInputHandler* m_keyboardInputHandler{nullptr};
+ KODI::MOUSE::IMouseInputHandler* const m_mouseInputHandler{nullptr};
+
+ // Input parameters
+ std::unique_ptr<KODI::JOYSTICK::IDriverHandler> m_joystickDriverHandler;
+ std::unique_ptr<KODI::JOYSTICK::IInputReceiver> m_joystickInputReceiver;
+ std::unique_ptr<KODI::KEYBOARD::IKeyboardDriverHandler> m_keyboardDriverHandler;
+ std::unique_ptr<KODI::MOUSE::IMouseDriverHandler> m_mouseDriverHandler;
+ std::unique_ptr<KODI::JOYSTICK::IButtonMap> m_buttonMap;
+};
+} // namespace PERIPHERALS
diff --git a/xbmc/peripherals/addons/CMakeLists.txt b/xbmc/peripherals/addons/CMakeLists.txt
new file mode 100644
index 0000000..9f31978
--- /dev/null
+++ b/xbmc/peripherals/addons/CMakeLists.txt
@@ -0,0 +1,13 @@
+set(SOURCES AddonButtonMap.cpp
+ AddonButtonMapping.cpp
+ AddonInputHandling.cpp
+ PeripheralAddon.cpp
+ PeripheralAddonTranslator.cpp)
+
+set(HEADERS AddonButtonMap.h
+ AddonButtonMapping.h
+ AddonInputHandling.h
+ PeripheralAddon.h
+ PeripheralAddonTranslator.h)
+
+core_add_library(peripherals_addons)
diff --git a/xbmc/peripherals/addons/PeripheralAddon.cpp b/xbmc/peripherals/addons/PeripheralAddon.cpp
new file mode 100644
index 0000000..7a55bb3
--- /dev/null
+++ b/xbmc/peripherals/addons/PeripheralAddon.cpp
@@ -0,0 +1,990 @@
+/*
+ * 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 "PeripheralAddon.h"
+
+#include "FileItem.h"
+#include "PeripheralAddonTranslator.h"
+#include "addons/addoninfo/AddonInfo.h"
+#include "addons/addoninfo/AddonType.h"
+#include "filesystem/Directory.h"
+#include "filesystem/SpecialProtocol.h"
+#include "games/controllers/Controller.h"
+#include "games/controllers/ControllerManager.h"
+#include "input/joysticks/DriverPrimitive.h"
+#include "input/joysticks/interfaces/IButtonMap.h"
+#include "peripherals/Peripherals.h"
+#include "peripherals/bus/virtual/PeripheralBusAddon.h"
+#include "peripherals/devices/PeripheralJoystick.h"
+#include "utils/StringUtils.h"
+#include "utils/log.h"
+
+#include <algorithm>
+#include <mutex>
+#include <shared_mutex>
+#include <string.h>
+#include <utility>
+
+using namespace KODI;
+using namespace JOYSTICK;
+using namespace PERIPHERALS;
+using namespace XFILE;
+
+#define KEYBOARD_BUTTON_MAP_NAME "Keyboard"
+#define KEYBOARD_PROVIDER "application"
+
+#define MOUSE_BUTTON_MAP_NAME "Mouse"
+#define MOUSE_PROVIDER "application"
+
+#ifndef SAFE_DELETE
+#define SAFE_DELETE(p) \
+ do \
+ { \
+ delete (p); \
+ (p) = NULL; \
+ } while (0)
+#endif
+
+CPeripheralAddon::CPeripheralAddon(const ADDON::AddonInfoPtr& addonInfo, CPeripherals& manager)
+ : IAddonInstanceHandler(ADDON_INSTANCE_PERIPHERAL, addonInfo),
+ m_manager(manager),
+ m_bSupportsJoystickRumble(false),
+ m_bSupportsJoystickPowerOff(false)
+{
+ m_bProvidesJoysticks =
+ addonInfo->Type(ADDON::AddonType::PERIPHERALDLL)->GetValue("@provides_joysticks").asBoolean();
+ m_bProvidesButtonMaps = addonInfo->Type(ADDON::AddonType::PERIPHERALDLL)
+ ->GetValue("@provides_buttonmaps")
+ .asBoolean();
+
+ // Create "C" interface structures, used as own parts to prevent API problems on update
+ m_ifc.peripheral = new AddonInstance_Peripheral;
+ m_ifc.peripheral->props = new AddonProps_Peripheral();
+ m_ifc.peripheral->toAddon = new KodiToAddonFuncTable_Peripheral();
+ m_ifc.peripheral->toKodi = new AddonToKodiFuncTable_Peripheral();
+
+ ResetProperties();
+}
+
+CPeripheralAddon::~CPeripheralAddon(void)
+{
+ DestroyAddon();
+
+ if (m_ifc.peripheral)
+ {
+ delete m_ifc.peripheral->toAddon;
+ delete m_ifc.peripheral->toKodi;
+ delete m_ifc.peripheral->props;
+ }
+ delete m_ifc.peripheral;
+}
+
+void CPeripheralAddon::ResetProperties(void)
+{
+ // Initialise members
+ m_strUserPath = CSpecialProtocol::TranslatePath(Profile());
+ m_strClientPath = CSpecialProtocol::TranslatePath(Path());
+
+ m_ifc.peripheral->props->user_path = m_strUserPath.c_str();
+ m_ifc.peripheral->props->addon_path = m_strClientPath.c_str();
+
+ m_ifc.peripheral->toKodi->kodiInstance = this;
+ m_ifc.peripheral->toKodi->feature_count = cb_feature_count;
+ m_ifc.peripheral->toKodi->feature_type = cb_feature_type;
+ m_ifc.peripheral->toKodi->refresh_button_maps = cb_refresh_button_maps;
+ m_ifc.peripheral->toKodi->trigger_scan = cb_trigger_scan;
+
+ memset(m_ifc.peripheral->toAddon, 0, sizeof(KodiToAddonFuncTable_Peripheral));
+}
+
+bool CPeripheralAddon::CreateAddon(void)
+{
+ std::unique_lock<CSharedSection> lock(m_dllSection);
+
+ // Reset all properties to defaults
+ ResetProperties();
+
+ // Create directory for user data
+ if (!CDirectory::Exists(m_strUserPath))
+ CDirectory::Create(m_strUserPath);
+
+ // Initialise the add-on
+ CLog::Log(LOGDEBUG, "PERIPHERAL - {} - creating peripheral add-on instance '{}'", __FUNCTION__,
+ Name());
+
+ if (CreateInstance() != ADDON_STATUS_OK)
+ return false;
+
+ if (!GetAddonProperties())
+ {
+ DestroyInstance();
+ return false;
+ }
+
+ return true;
+}
+
+void CPeripheralAddon::DestroyAddon()
+{
+ {
+ std::unique_lock<CCriticalSection> lock(m_critSection);
+ m_peripherals.clear();
+ }
+
+ {
+ std::unique_lock<CCriticalSection> lock(m_buttonMapMutex);
+ // only clear buttonMaps but don't delete them as they are owned by a
+ // CAddonJoystickInputHandling instance
+ m_buttonMaps.clear();
+ }
+
+ {
+ std::unique_lock<CSharedSection> lock(m_dllSection);
+ DestroyInstance();
+ }
+}
+
+bool CPeripheralAddon::GetAddonProperties(void)
+{
+ PERIPHERAL_CAPABILITIES addonCapabilities = {};
+
+ // Get the capabilities
+ m_ifc.peripheral->toAddon->get_capabilities(m_ifc.peripheral, &addonCapabilities);
+
+ // Verify capabilities against addon.xml
+ if (m_bProvidesJoysticks != addonCapabilities.provides_joysticks)
+ {
+ CLog::Log(
+ LOGERROR,
+ "PERIPHERAL - Add-on '{}': provides_joysticks'({}) in add-on DLL doesn't match "
+ "'provides_joysticks'({}) in addon.xml. Please contact the developer of this add-on: {}",
+ Name(), addonCapabilities.provides_joysticks ? "true" : "false",
+ m_bProvidesJoysticks ? "true" : "false", Author());
+ return false;
+ }
+ if (m_bProvidesButtonMaps != addonCapabilities.provides_buttonmaps)
+ {
+ CLog::Log(
+ LOGERROR,
+ "PERIPHERAL - Add-on '{}': provides_buttonmaps' ({}) in add-on DLL doesn't match "
+ "'provides_buttonmaps' ({}) in addon.xml. Please contact the developer of this add-on: {}",
+ Name(), addonCapabilities.provides_buttonmaps ? "true" : "false",
+ m_bProvidesButtonMaps ? "true" : "false", Author());
+ return false;
+ }
+
+ // Read properties that depend on underlying driver
+ m_bSupportsJoystickRumble = addonCapabilities.provides_joystick_rumble;
+ m_bSupportsJoystickPowerOff = addonCapabilities.provides_joystick_power_off;
+
+ return true;
+}
+
+bool CPeripheralAddon::Register(unsigned int peripheralIndex, const PeripheralPtr& peripheral)
+{
+ if (!peripheral)
+ return false;
+
+ std::unique_lock<CCriticalSection> lock(m_critSection);
+ if (m_peripherals.find(peripheralIndex) == m_peripherals.end())
+ {
+ if (peripheral->Type() == PERIPHERAL_JOYSTICK)
+ {
+ m_peripherals[peripheralIndex] = std::static_pointer_cast<CPeripheralJoystick>(peripheral);
+
+ CLog::Log(LOGINFO, "{} - new {} device registered on {}->{}: {}", __FUNCTION__,
+ PeripheralTypeTranslator::TypeToString(peripheral->Type()),
+ PeripheralTypeTranslator::BusTypeToString(PERIPHERAL_BUS_ADDON),
+ peripheral->Location(), peripheral->DeviceName());
+
+ return true;
+ }
+ }
+ return false;
+}
+
+void CPeripheralAddon::UnregisterRemovedDevices(const PeripheralScanResults& results,
+ PeripheralVector& removedPeripherals)
+{
+ std::vector<unsigned int> removedIndexes;
+
+ {
+ std::unique_lock<CCriticalSection> lock(m_critSection);
+ for (auto& it : m_peripherals)
+ {
+ const PeripheralPtr& peripheral = it.second;
+ PeripheralScanResult updatedDevice(PERIPHERAL_BUS_ADDON);
+ if (!results.GetDeviceOnLocation(peripheral->Location(), &updatedDevice) ||
+ *peripheral != updatedDevice)
+ {
+ // Device removed
+ removedIndexes.push_back(it.first);
+ }
+ }
+ }
+
+ for (auto index : removedIndexes)
+ {
+ auto it = m_peripherals.find(index);
+ const PeripheralPtr& peripheral = it->second;
+ CLog::Log(LOGINFO, "{} - device removed from {}/{}: {} ({}:{})", __FUNCTION__,
+ PeripheralTypeTranslator::TypeToString(peripheral->Type()), peripheral->Location(),
+ peripheral->DeviceName(), peripheral->VendorIdAsString(),
+ peripheral->ProductIdAsString());
+ UnregisterButtonMap(peripheral.get());
+ peripheral->OnDeviceRemoved();
+ removedPeripherals.push_back(peripheral);
+ m_peripherals.erase(it);
+ }
+}
+
+bool CPeripheralAddon::HasFeature(const PeripheralFeature feature) const
+{
+ if (feature == FEATURE_JOYSTICK)
+ return m_bProvidesJoysticks;
+
+ return false;
+}
+
+void CPeripheralAddon::GetFeatures(std::vector<PeripheralFeature>& features) const
+{
+ if (m_bProvidesJoysticks &&
+ std::find(features.begin(), features.end(), FEATURE_JOYSTICK) == features.end())
+ features.push_back(FEATURE_JOYSTICK);
+}
+
+PeripheralPtr CPeripheralAddon::GetPeripheral(unsigned int index) const
+{
+ PeripheralPtr peripheral;
+ std::unique_lock<CCriticalSection> lock(m_critSection);
+ auto it = m_peripherals.find(index);
+ if (it != m_peripherals.end())
+ peripheral = it->second;
+ return peripheral;
+}
+
+PeripheralPtr CPeripheralAddon::GetByPath(const std::string& strPath) const
+{
+ PeripheralPtr result;
+
+ std::unique_lock<CCriticalSection> lock(m_critSection);
+ for (const auto& it : m_peripherals)
+ {
+ if (StringUtils::EqualsNoCase(strPath, it.second->FileLocation()))
+ {
+ result = it.second;
+ break;
+ }
+ }
+
+ return result;
+}
+
+bool CPeripheralAddon::SupportsFeature(PeripheralFeature feature) const
+{
+ switch (feature)
+ {
+ case FEATURE_RUMBLE:
+ return m_bSupportsJoystickRumble;
+ case FEATURE_POWER_OFF:
+ return m_bSupportsJoystickPowerOff;
+ default:
+ break;
+ }
+
+ return false;
+}
+
+unsigned int CPeripheralAddon::GetPeripheralsWithFeature(PeripheralVector& results,
+ const PeripheralFeature feature) const
+{
+ unsigned int iReturn = 0;
+ std::unique_lock<CCriticalSection> lock(m_critSection);
+ for (const auto& it : m_peripherals)
+ {
+ if (it.second->HasFeature(feature))
+ {
+ results.push_back(it.second);
+ ++iReturn;
+ }
+ }
+ return iReturn;
+}
+
+unsigned int CPeripheralAddon::GetNumberOfPeripherals(void) const
+{
+ std::unique_lock<CCriticalSection> lock(m_critSection);
+ return static_cast<unsigned int>(m_peripherals.size());
+}
+
+unsigned int CPeripheralAddon::GetNumberOfPeripheralsWithId(const int iVendorId,
+ const int iProductId) const
+{
+ unsigned int iReturn = 0;
+ std::unique_lock<CCriticalSection> lock(m_critSection);
+ for (const auto& it : m_peripherals)
+ {
+ if (it.second->VendorId() == iVendorId && it.second->ProductId() == iProductId)
+ iReturn++;
+ }
+
+ return iReturn;
+}
+
+void CPeripheralAddon::GetDirectory(const std::string& strPath, CFileItemList& items) const
+{
+ std::unique_lock<CCriticalSection> lock(m_critSection);
+ for (const auto& it : m_peripherals)
+ {
+ const PeripheralPtr& peripheral = it.second;
+ if (peripheral->IsHidden())
+ continue;
+
+ CFileItemPtr peripheralFile(new CFileItem(peripheral->DeviceName()));
+ peripheralFile->SetPath(peripheral->FileLocation());
+ peripheralFile->SetProperty("vendor", peripheral->VendorIdAsString());
+ peripheralFile->SetProperty("product", peripheral->ProductIdAsString());
+ peripheralFile->SetProperty(
+ "bus", PeripheralTypeTranslator::BusTypeToString(peripheral->GetBusType()));
+ peripheralFile->SetProperty("location", peripheral->Location());
+ peripheralFile->SetProperty("class",
+ PeripheralTypeTranslator::TypeToString(peripheral->Type()));
+ peripheralFile->SetProperty("version", peripheral->GetVersionInfo());
+ peripheralFile->SetArt("icon", peripheral->GetIcon());
+ items.Add(peripheralFile);
+ }
+}
+
+bool CPeripheralAddon::PerformDeviceScan(PeripheralScanResults& results)
+{
+ unsigned int peripheralCount;
+ PERIPHERAL_INFO* pScanResults;
+ PERIPHERAL_ERROR retVal;
+
+ std::shared_lock<CSharedSection> lock(m_dllSection);
+
+ if (!m_ifc.peripheral->toAddon->perform_device_scan)
+ return false;
+
+ LogError(retVal = m_ifc.peripheral->toAddon->perform_device_scan(m_ifc.peripheral,
+ &peripheralCount, &pScanResults),
+ "PerformDeviceScan()");
+
+ if (retVal == PERIPHERAL_NO_ERROR)
+ {
+ for (unsigned int i = 0; i < peripheralCount; i++)
+ {
+ kodi::addon::Peripheral peripheral(pScanResults[i]);
+ PeripheralScanResult result(PERIPHERAL_BUS_ADDON);
+ switch (peripheral.Type())
+ {
+ case PERIPHERAL_TYPE_JOYSTICK:
+ result.m_type = PERIPHERAL_JOYSTICK;
+ break;
+ default:
+ continue;
+ }
+
+ result.m_strDeviceName = peripheral.Name();
+ result.m_strLocation = StringUtils::Format("{}/{}", ID(), peripheral.Index());
+ result.m_iVendorId = peripheral.VendorID();
+ result.m_iProductId = peripheral.ProductID();
+ result.m_mappedType = PERIPHERAL_JOYSTICK;
+ result.m_mappedBusType = PERIPHERAL_BUS_ADDON;
+ result.m_iSequence = 0;
+
+ if (!results.ContainsResult(result))
+ results.m_results.push_back(result);
+ }
+
+ m_ifc.peripheral->toAddon->free_scan_results(m_ifc.peripheral, peripheralCount, pScanResults);
+
+ return true;
+ }
+
+ return false;
+}
+
+bool CPeripheralAddon::ProcessEvents(void)
+{
+ if (!m_bProvidesJoysticks)
+ return false;
+
+ std::shared_lock<CSharedSection> lock(m_dllSection);
+
+ if (!m_ifc.peripheral->toAddon->get_events)
+ return false;
+
+ PERIPHERAL_ERROR retVal;
+
+ unsigned int eventCount = 0;
+ PERIPHERAL_EVENT* pEvents = nullptr;
+
+ LogError(retVal = m_ifc.peripheral->toAddon->get_events(m_ifc.peripheral, &eventCount, &pEvents),
+ "GetEvents()");
+ if (retVal == PERIPHERAL_NO_ERROR)
+ {
+ for (unsigned int i = 0; i < eventCount; i++)
+ {
+ kodi::addon::PeripheralEvent event(pEvents[i]);
+ PeripheralPtr device = GetPeripheral(event.PeripheralIndex());
+ if (!device)
+ continue;
+
+ switch (device->Type())
+ {
+ case PERIPHERAL_JOYSTICK:
+ {
+ std::shared_ptr<CPeripheralJoystick> joystickDevice =
+ std::static_pointer_cast<CPeripheralJoystick>(device);
+
+ switch (event.Type())
+ {
+ case PERIPHERAL_EVENT_TYPE_DRIVER_BUTTON:
+ {
+ const bool bPressed = (event.ButtonState() == JOYSTICK_STATE_BUTTON_PRESSED);
+ joystickDevice->OnButtonMotion(event.DriverIndex(), bPressed);
+ break;
+ }
+ case PERIPHERAL_EVENT_TYPE_DRIVER_HAT:
+ {
+ const HAT_STATE state =
+ CPeripheralAddonTranslator::TranslateHatState(event.HatState());
+ joystickDevice->OnHatMotion(event.DriverIndex(), state);
+ break;
+ }
+ case PERIPHERAL_EVENT_TYPE_DRIVER_AXIS:
+ {
+ joystickDevice->OnAxisMotion(event.DriverIndex(), event.AxisState());
+ break;
+ }
+ default:
+ break;
+ }
+ break;
+ }
+ default:
+ break;
+ }
+ }
+
+ for (const auto& it : m_peripherals)
+ {
+ if (it.second->Type() == PERIPHERAL_JOYSTICK)
+ std::static_pointer_cast<CPeripheralJoystick>(it.second)->OnInputFrame();
+ }
+
+ m_ifc.peripheral->toAddon->free_events(m_ifc.peripheral, eventCount, pEvents);
+
+ return true;
+ }
+
+ return false;
+}
+
+bool CPeripheralAddon::SendRumbleEvent(unsigned int peripheralIndex,
+ unsigned int driverIndex,
+ float magnitude)
+{
+ if (!m_bProvidesJoysticks)
+ return false;
+
+ std::shared_lock<CSharedSection> lock(m_dllSection);
+
+ if (!m_ifc.peripheral->toAddon->send_event)
+ return false;
+
+ PERIPHERAL_EVENT eventStruct = {};
+
+ eventStruct.peripheral_index = peripheralIndex;
+ eventStruct.type = PERIPHERAL_EVENT_TYPE_SET_MOTOR;
+ eventStruct.driver_index = driverIndex;
+ eventStruct.motor_state = magnitude;
+
+ return m_ifc.peripheral->toAddon->send_event(m_ifc.peripheral, &eventStruct);
+}
+
+bool CPeripheralAddon::GetJoystickProperties(unsigned int index, CPeripheralJoystick& joystick)
+{
+ if (!m_bProvidesJoysticks)
+ return false;
+
+ std::shared_lock<CSharedSection> lock(m_dllSection);
+
+ if (!m_ifc.peripheral->toAddon->get_joystick_info)
+ return false;
+
+ PERIPHERAL_ERROR retVal;
+
+ JOYSTICK_INFO joystickStruct;
+
+ LogError(retVal = m_ifc.peripheral->toAddon->get_joystick_info(m_ifc.peripheral, index,
+ &joystickStruct),
+ "GetJoystickInfo()");
+ if (retVal == PERIPHERAL_NO_ERROR)
+ {
+ kodi::addon::Joystick addonJoystick(joystickStruct);
+ SetJoystickInfo(joystick, addonJoystick);
+
+ m_ifc.peripheral->toAddon->free_joystick_info(m_ifc.peripheral, &joystickStruct);
+
+ return true;
+ }
+
+ return false;
+}
+
+bool CPeripheralAddon::GetFeatures(const CPeripheral* device,
+ const std::string& strControllerId,
+ FeatureMap& features)
+{
+ if (!m_bProvidesButtonMaps)
+ return false;
+
+ std::shared_lock<CSharedSection> lock(m_dllSection);
+
+ if (!m_ifc.peripheral->toAddon->get_features)
+ return false;
+
+ PERIPHERAL_ERROR retVal;
+
+ kodi::addon::Joystick joystickInfo;
+ GetJoystickInfo(device, joystickInfo);
+
+ JOYSTICK_INFO joystickStruct;
+ joystickInfo.ToStruct(joystickStruct);
+
+ unsigned int featureCount = 0;
+ JOYSTICK_FEATURE* pFeatures = nullptr;
+
+ LogError(retVal = m_ifc.peripheral->toAddon->get_features(m_ifc.peripheral, &joystickStruct,
+ strControllerId.c_str(), &featureCount,
+ &pFeatures),
+ "GetFeatures()");
+
+ kodi::addon::Joystick::FreeStruct(joystickStruct);
+
+ if (retVal == PERIPHERAL_NO_ERROR)
+ {
+ for (unsigned int i = 0; i < featureCount; i++)
+ {
+ kodi::addon::JoystickFeature feature(pFeatures[i]);
+ if (feature.Type() != JOYSTICK_FEATURE_TYPE_UNKNOWN)
+ features[feature.Name()] = feature;
+ }
+
+ m_ifc.peripheral->toAddon->free_features(m_ifc.peripheral, featureCount, pFeatures);
+
+ return true;
+ }
+
+ return false;
+}
+
+bool CPeripheralAddon::MapFeature(const CPeripheral* device,
+ const std::string& strControllerId,
+ const kodi::addon::JoystickFeature& feature)
+{
+ if (!m_bProvidesButtonMaps)
+ return false;
+
+ std::shared_lock<CSharedSection> lock(m_dllSection);
+
+ if (!m_ifc.peripheral->toAddon->map_features)
+ return false;
+
+ PERIPHERAL_ERROR retVal;
+
+ kodi::addon::Joystick joystickInfo;
+ GetJoystickInfo(device, joystickInfo);
+
+ JOYSTICK_INFO joystickStruct;
+ joystickInfo.ToStruct(joystickStruct);
+
+ JOYSTICK_FEATURE addonFeature;
+ feature.ToStruct(addonFeature);
+
+ LogError(retVal = m_ifc.peripheral->toAddon->map_features(
+ m_ifc.peripheral, &joystickStruct, strControllerId.c_str(), 1, &addonFeature),
+ "MapFeatures()");
+
+ kodi::addon::Joystick::FreeStruct(joystickStruct);
+ kodi::addon::JoystickFeature::FreeStruct(addonFeature);
+
+ return retVal == PERIPHERAL_NO_ERROR;
+}
+
+bool CPeripheralAddon::GetIgnoredPrimitives(const CPeripheral* device, PrimitiveVector& primitives)
+{
+ if (!m_bProvidesButtonMaps)
+ return false;
+
+ std::shared_lock<CSharedSection> lock(m_dllSection);
+
+ if (!m_ifc.peripheral->toAddon->get_ignored_primitives)
+ return false;
+
+ PERIPHERAL_ERROR retVal;
+
+ kodi::addon::Joystick joystickInfo;
+ GetJoystickInfo(device, joystickInfo);
+
+ JOYSTICK_INFO joystickStruct;
+ joystickInfo.ToStruct(joystickStruct);
+
+ unsigned int primitiveCount = 0;
+ JOYSTICK_DRIVER_PRIMITIVE* pPrimitives = nullptr;
+
+ LogError(retVal = m_ifc.peripheral->toAddon->get_ignored_primitives(
+ m_ifc.peripheral, &joystickStruct, &primitiveCount, &pPrimitives),
+ "GetIgnoredPrimitives()");
+
+ kodi::addon::Joystick::FreeStruct(joystickStruct);
+
+ if (retVal == PERIPHERAL_NO_ERROR)
+ {
+ for (unsigned int i = 0; i < primitiveCount; i++)
+ primitives.emplace_back(pPrimitives[i]);
+
+ m_ifc.peripheral->toAddon->free_primitives(m_ifc.peripheral, primitiveCount, pPrimitives);
+
+ return true;
+ }
+
+ return false;
+}
+
+bool CPeripheralAddon::SetIgnoredPrimitives(const CPeripheral* device,
+ const PrimitiveVector& primitives)
+{
+ if (!m_bProvidesButtonMaps)
+ return false;
+
+ std::shared_lock<CSharedSection> lock(m_dllSection);
+
+ if (!m_ifc.peripheral->toAddon->set_ignored_primitives)
+ return false;
+
+ PERIPHERAL_ERROR retVal;
+
+ kodi::addon::Joystick joystickInfo;
+ GetJoystickInfo(device, joystickInfo);
+
+ JOYSTICK_INFO joystickStruct;
+ joystickInfo.ToStruct(joystickStruct);
+
+ JOYSTICK_DRIVER_PRIMITIVE* addonPrimitives = nullptr;
+ kodi::addon::DriverPrimitives::ToStructs(primitives, &addonPrimitives);
+ const unsigned int primitiveCount = static_cast<unsigned int>(primitives.size());
+
+ LogError(retVal = m_ifc.peripheral->toAddon->set_ignored_primitives(
+ m_ifc.peripheral, &joystickStruct, primitiveCount, addonPrimitives),
+ "SetIgnoredPrimitives()");
+
+ kodi::addon::Joystick::FreeStruct(joystickStruct);
+ kodi::addon::DriverPrimitives::FreeStructs(primitiveCount, addonPrimitives);
+
+ return retVal == PERIPHERAL_NO_ERROR;
+}
+
+void CPeripheralAddon::SaveButtonMap(const CPeripheral* device)
+{
+ if (!m_bProvidesButtonMaps)
+ return;
+
+ std::shared_lock<CSharedSection> lock(m_dllSection);
+
+ if (!m_ifc.peripheral->toAddon->save_button_map)
+ return;
+
+ kodi::addon::Joystick joystickInfo;
+ GetJoystickInfo(device, joystickInfo);
+
+ JOYSTICK_INFO joystickStruct;
+ joystickInfo.ToStruct(joystickStruct);
+
+ m_ifc.peripheral->toAddon->save_button_map(m_ifc.peripheral, &joystickStruct);
+
+ kodi::addon::Joystick::FreeStruct(joystickStruct);
+
+ // Notify observing button maps
+ RefreshButtonMaps(device->DeviceName());
+}
+
+void CPeripheralAddon::RevertButtonMap(const CPeripheral* device)
+{
+ if (!m_bProvidesButtonMaps)
+ return;
+
+ std::shared_lock<CSharedSection> lock(m_dllSection);
+
+ if (!m_ifc.peripheral->toAddon->revert_button_map)
+ return;
+
+ kodi::addon::Joystick joystickInfo;
+ GetJoystickInfo(device, joystickInfo);
+
+ JOYSTICK_INFO joystickStruct;
+ joystickInfo.ToStruct(joystickStruct);
+
+ m_ifc.peripheral->toAddon->revert_button_map(m_ifc.peripheral, &joystickStruct);
+
+ kodi::addon::Joystick::FreeStruct(joystickStruct);
+}
+
+void CPeripheralAddon::ResetButtonMap(const CPeripheral* device, const std::string& strControllerId)
+{
+ if (!m_bProvidesButtonMaps)
+ return;
+
+ kodi::addon::Joystick joystickInfo;
+ GetJoystickInfo(device, joystickInfo);
+
+ JOYSTICK_INFO joystickStruct;
+ joystickInfo.ToStruct(joystickStruct);
+
+ m_ifc.peripheral->toAddon->reset_button_map(m_ifc.peripheral, &joystickStruct,
+ strControllerId.c_str());
+
+ kodi::addon::Joystick::FreeStruct(joystickStruct);
+
+ // Notify observing button maps
+ RefreshButtonMaps(device->DeviceName());
+}
+
+void CPeripheralAddon::PowerOffJoystick(unsigned int index)
+{
+ if (!HasFeature(FEATURE_JOYSTICK))
+ return;
+
+ if (!SupportsFeature(FEATURE_POWER_OFF))
+ return;
+
+ std::shared_lock<CSharedSection> lock(m_dllSection);
+
+ if (!m_ifc.peripheral->toAddon->power_off_joystick)
+ return;
+
+ m_ifc.peripheral->toAddon->power_off_joystick(m_ifc.peripheral, index);
+}
+
+void CPeripheralAddon::RegisterButtonMap(CPeripheral* device, IButtonMap* buttonMap)
+{
+ std::unique_lock<CCriticalSection> lock(m_buttonMapMutex);
+
+ UnregisterButtonMap(buttonMap);
+ m_buttonMaps.emplace_back(device, buttonMap);
+}
+
+void CPeripheralAddon::UnregisterButtonMap(IButtonMap* buttonMap)
+{
+ std::unique_lock<CCriticalSection> lock(m_buttonMapMutex);
+
+ for (auto it = m_buttonMaps.begin(); it != m_buttonMaps.end(); ++it)
+ {
+ if (it->second == buttonMap)
+ {
+ m_buttonMaps.erase(it);
+ break;
+ }
+ }
+}
+
+void CPeripheralAddon::UnregisterButtonMap(CPeripheral* device)
+{
+ std::unique_lock<CCriticalSection> lock(m_buttonMapMutex);
+
+ m_buttonMaps.erase(
+ std::remove_if(m_buttonMaps.begin(), m_buttonMaps.end(),
+ [device](const std::pair<CPeripheral*, JOYSTICK::IButtonMap*>& buttonMap) {
+ return buttonMap.first == device;
+ }),
+ m_buttonMaps.end());
+}
+
+void CPeripheralAddon::RefreshButtonMaps(const std::string& strDeviceName /* = "" */)
+{
+ std::unique_lock<CCriticalSection> lock(m_buttonMapMutex);
+
+ for (auto it = m_buttonMaps.begin(); it != m_buttonMaps.end(); ++it)
+ {
+ if (strDeviceName.empty() || strDeviceName == it->first->DeviceName())
+ it->second->Load();
+ }
+}
+
+bool CPeripheralAddon::ProvidesJoysticks(const ADDON::AddonInfoPtr& addonInfo)
+{
+ return addonInfo->Type(ADDON::AddonType::PERIPHERALDLL)
+ ->GetValue("@provides_joysticks")
+ .asBoolean();
+}
+
+bool CPeripheralAddon::ProvidesButtonMaps(const ADDON::AddonInfoPtr& addonInfo)
+{
+ return addonInfo->Type(ADDON::AddonType::PERIPHERALDLL)
+ ->GetValue("@provides_buttonmaps")
+ .asBoolean();
+}
+
+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()));
+ peripheralInfo.SetName(device->DeviceName());
+ peripheralInfo.SetVendorID(device->VendorId());
+ peripheralInfo.SetProductID(device->ProductId());
+}
+
+void CPeripheralAddon::GetJoystickInfo(const CPeripheral* device,
+ kodi::addon::Joystick& joystickInfo)
+{
+ GetPeripheralInfo(device, joystickInfo);
+
+ if (device->Type() == PERIPHERAL_JOYSTICK)
+ {
+ const CPeripheralJoystick* joystick = static_cast<const CPeripheralJoystick*>(device);
+ joystickInfo.SetProvider(joystick->Provider());
+ joystickInfo.SetButtonCount(joystick->ButtonCount());
+ joystickInfo.SetHatCount(joystick->HatCount());
+ joystickInfo.SetAxisCount(joystick->AxisCount());
+ joystickInfo.SetMotorCount(joystick->MotorCount());
+ joystickInfo.SetSupportsPowerOff(joystick->SupportsPowerOff());
+ }
+ else if (device->Type() == PERIPHERAL_KEYBOARD || device->Type() == PERIPHERAL_MOUSE)
+ {
+ joystickInfo.SetName(GetDeviceName(device->Type())); // Override name with non-localized version
+ joystickInfo.SetProvider(GetProvider(device->Type()));
+ }
+}
+
+void CPeripheralAddon::SetJoystickInfo(CPeripheralJoystick& joystick,
+ const kodi::addon::Joystick& joystickInfo)
+{
+ joystick.SetProvider(joystickInfo.Provider());
+ joystick.SetRequestedPort(joystickInfo.RequestedPort());
+ joystick.SetButtonCount(joystickInfo.ButtonCount());
+ joystick.SetHatCount(joystickInfo.HatCount());
+ joystick.SetAxisCount(joystickInfo.AxisCount());
+ joystick.SetMotorCount(joystickInfo.MotorCount());
+ joystick.SetSupportsPowerOff(joystickInfo.SupportsPowerOff());
+}
+
+bool CPeripheralAddon::LogError(const PERIPHERAL_ERROR error, const char* strMethod) const
+{
+ if (error != PERIPHERAL_NO_ERROR)
+ {
+ CLog::Log(LOGERROR, "PERIPHERAL - {} - addon '{}' returned an error: {}", strMethod, Name(),
+ CPeripheralAddonTranslator::TranslateError(error));
+ return false;
+ }
+ return true;
+}
+
+std::string CPeripheralAddon::GetDeviceName(PeripheralType type)
+{
+ switch (type)
+ {
+ case PERIPHERAL_KEYBOARD:
+ return KEYBOARD_BUTTON_MAP_NAME;
+ case PERIPHERAL_MOUSE:
+ return MOUSE_BUTTON_MAP_NAME;
+ default:
+ break;
+ }
+
+ return "";
+}
+
+std::string CPeripheralAddon::GetProvider(PeripheralType type)
+{
+ switch (type)
+ {
+ case PERIPHERAL_KEYBOARD:
+ return KEYBOARD_PROVIDER;
+ case PERIPHERAL_MOUSE:
+ return MOUSE_PROVIDER;
+ default:
+ break;
+ }
+
+ return "";
+}
+
+void CPeripheralAddon::cb_trigger_scan(void* kodiInstance)
+{
+ if (kodiInstance == nullptr)
+ return;
+
+ static_cast<CPeripheralAddon*>(kodiInstance)->TriggerDeviceScan();
+}
+
+void CPeripheralAddon::cb_refresh_button_maps(void* kodiInstance,
+ const char* deviceName,
+ const char* controllerId)
+{
+ if (!kodiInstance)
+ return;
+
+ static_cast<CPeripheralAddon*>(kodiInstance)->RefreshButtonMaps(deviceName ? deviceName : "");
+}
+
+unsigned int CPeripheralAddon::cb_feature_count(void* kodiInstance,
+ const char* controllerId,
+ JOYSTICK_FEATURE_TYPE type)
+{
+ if (kodiInstance == nullptr || controllerId == nullptr)
+ return 0;
+
+ return static_cast<CPeripheralAddon*>(kodiInstance)->FeatureCount(controllerId, type);
+}
+
+JOYSTICK_FEATURE_TYPE CPeripheralAddon::cb_feature_type(void* kodiInstance,
+ const char* controllerId,
+ const char* featureName)
+{
+ if (kodiInstance == nullptr || controllerId == nullptr || featureName == nullptr)
+ return JOYSTICK_FEATURE_TYPE_UNKNOWN;
+
+ return static_cast<CPeripheralAddon*>(kodiInstance)->FeatureType(controllerId, featureName);
+}
diff --git a/xbmc/peripherals/addons/PeripheralAddon.h b/xbmc/peripherals/addons/PeripheralAddon.h
new file mode 100644
index 0000000..2dd9d22
--- /dev/null
+++ b/xbmc/peripherals/addons/PeripheralAddon.h
@@ -0,0 +1,178 @@
+/*
+ * 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/binary-addons/AddonInstanceHandler.h"
+#include "addons/kodi-dev-kit/include/kodi/addon-instance/Peripheral.h"
+#include "input/joysticks/JoystickTypes.h"
+#include "peripherals/PeripheralTypes.h"
+#include "threads/CriticalSection.h"
+#include "threads/SharedSection.h"
+
+#include <map>
+#include <memory>
+#include <vector>
+
+class CFileItemList;
+
+namespace KODI
+{
+namespace JOYSTICK
+{
+class IButtonMap;
+class IDriverHandler;
+} // namespace JOYSTICK
+} // namespace KODI
+
+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::AddonInfoPtr& addonInfo, CPeripherals& manager);
+ ~CPeripheralAddon(void) override;
+
+ /*!
+ * @brief Initialise the instance of this add-on
+ */
+ bool CreateAddon(void);
+
+ /*!
+ * \brief Deinitialize the instance of this add-on
+ */
+ void DestroyAddon();
+
+ bool Register(unsigned int peripheralIndex, const PeripheralPtr& peripheral);
+ void UnregisterRemovedDevices(const PeripheralScanResults& results,
+ PeripheralVector& removedPeripherals);
+ void GetFeatures(std::vector<PeripheralFeature>& features) const;
+ bool HasFeature(const PeripheralFeature feature) const;
+ PeripheralPtr GetPeripheral(unsigned int index) const;
+ PeripheralPtr GetByPath(const std::string& strPath) const;
+ bool SupportsFeature(PeripheralFeature feature) const;
+ unsigned int GetPeripheralsWithFeature(PeripheralVector& results,
+ const PeripheralFeature feature) const;
+ unsigned int GetNumberOfPeripherals(void) const;
+ unsigned int GetNumberOfPeripheralsWithId(const int iVendorId, const int iProductId) const;
+ void GetDirectory(const std::string& strPath, CFileItemList& items) const;
+
+ /** @name Peripheral add-on methods */
+ //@{
+ bool PerformDeviceScan(PeripheralScanResults& results);
+ bool ProcessEvents(void);
+ bool SendRumbleEvent(unsigned int index, unsigned int driverIndex, float magnitude);
+ //@}
+
+ /** @name Joystick methods */
+ //@{
+ bool GetJoystickProperties(unsigned int index, CPeripheralJoystick& joystick);
+ bool HasButtonMaps(void) const { return m_bProvidesButtonMaps; }
+ bool GetFeatures(const CPeripheral* device,
+ const std::string& strControllerId,
+ FeatureMap& features);
+ bool MapFeature(const CPeripheral* device,
+ const std::string& strControllerId,
+ const kodi::addon::JoystickFeature& feature);
+ bool GetIgnoredPrimitives(const CPeripheral* device, PrimitiveVector& primitives);
+ bool SetIgnoredPrimitives(const CPeripheral* device, const PrimitiveVector& primitives);
+ void SaveButtonMap(const CPeripheral* device);
+ void RevertButtonMap(const CPeripheral* device);
+ void ResetButtonMap(const CPeripheral* device, const std::string& strControllerId);
+ void PowerOffJoystick(unsigned int index);
+ //@}
+
+ void RegisterButtonMap(CPeripheral* device, KODI::JOYSTICK::IButtonMap* buttonMap);
+ void UnregisterButtonMap(KODI::JOYSTICK::IButtonMap* buttonMap);
+
+ static bool ProvidesJoysticks(const ADDON::AddonInfoPtr& addonInfo);
+ static bool ProvidesButtonMaps(const ADDON::AddonInfoPtr& addonInfo);
+
+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
+ */
+ static void GetPeripheralInfo(const CPeripheral* device, kodi::addon::Peripheral& peripheralInfo);
+
+ static void GetJoystickInfo(const CPeripheral* device, kodi::addon::Joystick& joystickInfo);
+ static void SetJoystickInfo(CPeripheralJoystick& joystick,
+ const kodi::addon::Joystick& joystickInfo);
+
+ /*!
+ * @brief Reset all class members to their defaults. Called by the constructors
+ */
+ void ResetProperties(void);
+
+ /*!
+ * @brief Retrieve add-on properties from the add-on
+ */
+ bool GetAddonProperties(void);
+
+ bool LogError(const PERIPHERAL_ERROR error, const char* strMethod) const;
+
+ 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 */
+
+ /*!
+ * @brief Callback functions from addon to kodi
+ */
+ //@{
+ static void cb_trigger_scan(void* kodiInstance);
+ static void cb_refresh_button_maps(void* kodiInstance,
+ const char* deviceName,
+ const char* controllerId);
+ static unsigned int cb_feature_count(void* kodiInstance,
+ const char* controllerId,
+ JOYSTICK_FEATURE_TYPE type);
+ static JOYSTICK_FEATURE_TYPE cb_feature_type(void* kodiInstance,
+ const char* controllerId,
+ const char* featureName);
+ //@}
+
+ /* @brief Add-on properties */
+ bool m_bProvidesJoysticks;
+ bool m_bSupportsJoystickRumble;
+ bool m_bSupportsJoystickPowerOff;
+ bool m_bProvidesButtonMaps;
+
+ /* @brief Map of peripherals belonging to the add-on */
+ std::map<unsigned int, PeripheralPtr> m_peripherals;
+
+ /* @brief Button map observers */
+ std::vector<std::pair<CPeripheral*, KODI::JOYSTICK::IButtonMap*>> m_buttonMaps;
+ CCriticalSection m_buttonMapMutex;
+
+ /* @brief Thread synchronization */
+ mutable CCriticalSection m_critSection;
+
+ CSharedSection m_dllSection;
+};
+} // namespace PERIPHERALS
diff --git a/xbmc/peripherals/addons/PeripheralAddonTranslator.cpp b/xbmc/peripherals/addons/PeripheralAddonTranslator.cpp
new file mode 100644
index 0000000..16dd529
--- /dev/null
+++ b/xbmc/peripherals/addons/PeripheralAddonTranslator.cpp
@@ -0,0 +1,449 @@
+/*
+ * 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 "PeripheralAddonTranslator.h"
+
+#include "games/controllers/ControllerTranslator.h"
+#include "input/joysticks/JoystickUtils.h"
+
+#include <algorithm>
+#include <iterator>
+
+using namespace KODI;
+using namespace JOYSTICK;
+using namespace PERIPHERALS;
+
+// --- Helper function ---------------------------------------------------------
+
+JOYSTICK_DRIVER_SEMIAXIS_DIRECTION operator*(JOYSTICK_DRIVER_SEMIAXIS_DIRECTION dir, int i)
+{
+ return static_cast<JOYSTICK_DRIVER_SEMIAXIS_DIRECTION>(static_cast<int>(dir) * i);
+}
+
+// --- CPeripheralAddonTranslator ----------------------------------------------
+
+const char* CPeripheralAddonTranslator::TranslateError(const PERIPHERAL_ERROR error)
+{
+ switch (error)
+ {
+ case PERIPHERAL_NO_ERROR:
+ return "no error";
+ case PERIPHERAL_ERROR_FAILED:
+ return "command failed";
+ case PERIPHERAL_ERROR_INVALID_PARAMETERS:
+ return "invalid parameters";
+ case PERIPHERAL_ERROR_NOT_IMPLEMENTED:
+ return "not implemented";
+ case PERIPHERAL_ERROR_NOT_CONNECTED:
+ return "not connected";
+ case PERIPHERAL_ERROR_CONNECTION_FAILED:
+ return "connection failed";
+ case PERIPHERAL_ERROR_UNKNOWN:
+ default:
+ return "unknown error";
+ }
+}
+
+PeripheralType CPeripheralAddonTranslator::TranslateType(PERIPHERAL_TYPE type)
+{
+ switch (type)
+ {
+ case PERIPHERAL_TYPE_JOYSTICK:
+ return PERIPHERAL_JOYSTICK;
+ default:
+ break;
+ }
+ return PERIPHERAL_UNKNOWN;
+}
+
+PERIPHERAL_TYPE CPeripheralAddonTranslator::TranslateType(PeripheralType type)
+{
+ switch (type)
+ {
+ case PERIPHERAL_JOYSTICK:
+ return PERIPHERAL_TYPE_JOYSTICK;
+ default:
+ break;
+ }
+ return PERIPHERAL_TYPE_UNKNOWN;
+}
+
+CDriverPrimitive CPeripheralAddonTranslator::TranslatePrimitive(
+ const kodi::addon::DriverPrimitive& primitive)
+{
+ CDriverPrimitive retVal;
+
+ switch (primitive.Type())
+ {
+ case JOYSTICK_DRIVER_PRIMITIVE_TYPE_BUTTON:
+ {
+ retVal = CDriverPrimitive(PRIMITIVE_TYPE::BUTTON, primitive.DriverIndex());
+ break;
+ }
+ case JOYSTICK_DRIVER_PRIMITIVE_TYPE_HAT_DIRECTION:
+ {
+ retVal = CDriverPrimitive(primitive.DriverIndex(),
+ TranslateHatDirection(primitive.HatDirection()));
+ break;
+ }
+ case JOYSTICK_DRIVER_PRIMITIVE_TYPE_SEMIAXIS:
+ {
+ retVal = CDriverPrimitive(primitive.DriverIndex(), primitive.Center(),
+ TranslateSemiAxisDirection(primitive.SemiAxisDirection()),
+ primitive.Range());
+ break;
+ }
+ case JOYSTICK_DRIVER_PRIMITIVE_TYPE_MOTOR:
+ {
+ retVal = CDriverPrimitive(PRIMITIVE_TYPE::MOTOR, primitive.DriverIndex());
+ break;
+ }
+ case JOYSTICK_DRIVER_PRIMITIVE_TYPE_KEY:
+ {
+ KEYBOARD::KeySymbol keycode =
+ GAME::CControllerTranslator::TranslateKeysym(primitive.Keycode());
+ retVal = CDriverPrimitive(keycode);
+ break;
+ }
+ case JOYSTICK_DRIVER_PRIMITIVE_TYPE_MOUSE_BUTTON:
+ {
+ retVal = CDriverPrimitive(TranslateMouseButton(primitive.MouseIndex()));
+ break;
+ }
+ case JOYSTICK_DRIVER_PRIMITIVE_TYPE_RELPOINTER_DIRECTION:
+ {
+ retVal = CDriverPrimitive(TranslateRelPointerDirection(primitive.RelPointerDirection()));
+ break;
+ }
+ default:
+ break;
+ }
+
+ return retVal;
+}
+
+kodi::addon::DriverPrimitive CPeripheralAddonTranslator::TranslatePrimitive(
+ const CDriverPrimitive& primitive)
+{
+ kodi::addon::DriverPrimitive retVal;
+
+ switch (primitive.Type())
+ {
+ case PRIMITIVE_TYPE::BUTTON:
+ {
+ retVal = kodi::addon::DriverPrimitive::CreateButton(primitive.Index());
+ break;
+ }
+ case PRIMITIVE_TYPE::HAT:
+ {
+ retVal = kodi::addon::DriverPrimitive(primitive.Index(),
+ TranslateHatDirection(primitive.HatDirection()));
+ break;
+ }
+ case PRIMITIVE_TYPE::SEMIAXIS:
+ {
+ retVal = kodi::addon::DriverPrimitive(
+ primitive.Index(), primitive.Center(),
+ TranslateSemiAxisDirection(primitive.SemiAxisDirection()), primitive.Range());
+ break;
+ }
+ case PRIMITIVE_TYPE::MOTOR:
+ {
+ retVal = kodi::addon::DriverPrimitive::CreateMotor(primitive.Index());
+ break;
+ }
+ case PRIMITIVE_TYPE::KEY:
+ {
+ std::string keysym = GAME::CControllerTranslator::TranslateKeycode(primitive.Keycode());
+ retVal = kodi::addon::DriverPrimitive(keysym);
+ break;
+ }
+ case PRIMITIVE_TYPE::MOUSE_BUTTON:
+ {
+ retVal = kodi::addon::DriverPrimitive::CreateMouseButton(
+ TranslateMouseButton(primitive.MouseButton()));
+ break;
+ }
+ case PRIMITIVE_TYPE::RELATIVE_POINTER:
+ {
+ retVal =
+ kodi::addon::DriverPrimitive(TranslateRelPointerDirection(primitive.PointerDirection()));
+ break;
+ }
+ default:
+ break;
+ }
+
+ return retVal;
+}
+
+std::vector<JOYSTICK::CDriverPrimitive> CPeripheralAddonTranslator::TranslatePrimitives(
+ const std::vector<kodi::addon::DriverPrimitive>& primitives)
+{
+ std::vector<JOYSTICK::CDriverPrimitive> ret;
+ std::transform(primitives.begin(), primitives.end(), std::back_inserter(ret),
+ [](const kodi::addon::DriverPrimitive& primitive) {
+ return CPeripheralAddonTranslator::TranslatePrimitive(primitive);
+ });
+ return ret;
+}
+
+std::vector<kodi::addon::DriverPrimitive> CPeripheralAddonTranslator::TranslatePrimitives(
+ const std::vector<JOYSTICK::CDriverPrimitive>& primitives)
+{
+ std::vector<kodi::addon::DriverPrimitive> ret;
+ std::transform(primitives.begin(), primitives.end(), std::back_inserter(ret),
+ [](const JOYSTICK::CDriverPrimitive& primitive) {
+ return CPeripheralAddonTranslator::TranslatePrimitive(primitive);
+ });
+ return ret;
+}
+
+HAT_DIRECTION CPeripheralAddonTranslator::TranslateHatDirection(JOYSTICK_DRIVER_HAT_DIRECTION dir)
+{
+ switch (dir)
+ {
+ case JOYSTICK_DRIVER_HAT_LEFT:
+ return HAT_DIRECTION::LEFT;
+ case JOYSTICK_DRIVER_HAT_RIGHT:
+ return HAT_DIRECTION::RIGHT;
+ case JOYSTICK_DRIVER_HAT_UP:
+ return HAT_DIRECTION::UP;
+ case JOYSTICK_DRIVER_HAT_DOWN:
+ return HAT_DIRECTION::DOWN;
+ default:
+ break;
+ }
+ return HAT_DIRECTION::NONE;
+}
+
+JOYSTICK_DRIVER_HAT_DIRECTION CPeripheralAddonTranslator::TranslateHatDirection(HAT_DIRECTION dir)
+{
+ switch (dir)
+ {
+ case HAT_DIRECTION::UP:
+ return JOYSTICK_DRIVER_HAT_UP;
+ case HAT_DIRECTION::DOWN:
+ return JOYSTICK_DRIVER_HAT_DOWN;
+ case HAT_DIRECTION::RIGHT:
+ return JOYSTICK_DRIVER_HAT_RIGHT;
+ case HAT_DIRECTION::LEFT:
+ return JOYSTICK_DRIVER_HAT_LEFT;
+ default:
+ break;
+ }
+ return JOYSTICK_DRIVER_HAT_UNKNOWN;
+}
+
+HAT_STATE CPeripheralAddonTranslator::TranslateHatState(JOYSTICK_STATE_HAT state)
+{
+ HAT_STATE translatedState = HAT_STATE::NONE;
+
+ if (state & JOYSTICK_STATE_HAT_UP)
+ translatedState |= HAT_STATE::UP;
+ if (state & JOYSTICK_STATE_HAT_DOWN)
+ translatedState |= HAT_STATE::DOWN;
+ if (state & JOYSTICK_STATE_HAT_RIGHT)
+ translatedState |= HAT_STATE::RIGHT;
+ if (state & JOYSTICK_STATE_HAT_LEFT)
+ translatedState |= HAT_STATE::LEFT;
+
+ return translatedState;
+}
+
+SEMIAXIS_DIRECTION CPeripheralAddonTranslator::TranslateSemiAxisDirection(
+ JOYSTICK_DRIVER_SEMIAXIS_DIRECTION dir)
+{
+ switch (dir)
+ {
+ case JOYSTICK_DRIVER_SEMIAXIS_POSITIVE:
+ return SEMIAXIS_DIRECTION::POSITIVE;
+ case JOYSTICK_DRIVER_SEMIAXIS_NEGATIVE:
+ return SEMIAXIS_DIRECTION::NEGATIVE;
+ default:
+ break;
+ }
+ return SEMIAXIS_DIRECTION::ZERO;
+}
+
+JOYSTICK_DRIVER_SEMIAXIS_DIRECTION CPeripheralAddonTranslator::TranslateSemiAxisDirection(
+ SEMIAXIS_DIRECTION dir)
+{
+ switch (dir)
+ {
+ case SEMIAXIS_DIRECTION::POSITIVE:
+ return JOYSTICK_DRIVER_SEMIAXIS_POSITIVE;
+ case SEMIAXIS_DIRECTION::NEGATIVE:
+ return JOYSTICK_DRIVER_SEMIAXIS_NEGATIVE;
+ default:
+ break;
+ }
+ return JOYSTICK_DRIVER_SEMIAXIS_UNKNOWN;
+}
+
+MOUSE::BUTTON_ID CPeripheralAddonTranslator::TranslateMouseButton(
+ JOYSTICK_DRIVER_MOUSE_INDEX button)
+{
+ switch (button)
+ {
+ case JOYSTICK_DRIVER_MOUSE_INDEX_LEFT:
+ return MOUSE::BUTTON_ID::LEFT;
+ case JOYSTICK_DRIVER_MOUSE_INDEX_RIGHT:
+ return MOUSE::BUTTON_ID::RIGHT;
+ case JOYSTICK_DRIVER_MOUSE_INDEX_MIDDLE:
+ return MOUSE::BUTTON_ID::MIDDLE;
+ case JOYSTICK_DRIVER_MOUSE_INDEX_BUTTON4:
+ return MOUSE::BUTTON_ID::BUTTON4;
+ case JOYSTICK_DRIVER_MOUSE_INDEX_BUTTON5:
+ return MOUSE::BUTTON_ID::BUTTON5;
+ case JOYSTICK_DRIVER_MOUSE_INDEX_WHEEL_UP:
+ return MOUSE::BUTTON_ID::WHEEL_UP;
+ case JOYSTICK_DRIVER_MOUSE_INDEX_WHEEL_DOWN:
+ return MOUSE::BUTTON_ID::WHEEL_DOWN;
+ case JOYSTICK_DRIVER_MOUSE_INDEX_HORIZ_WHEEL_LEFT:
+ return MOUSE::BUTTON_ID::HORIZ_WHEEL_LEFT;
+ case JOYSTICK_DRIVER_MOUSE_INDEX_HORIZ_WHEEL_RIGHT:
+ return MOUSE::BUTTON_ID::HORIZ_WHEEL_RIGHT;
+ default:
+ break;
+ }
+
+ return MOUSE::BUTTON_ID::UNKNOWN;
+}
+
+JOYSTICK_DRIVER_MOUSE_INDEX CPeripheralAddonTranslator::TranslateMouseButton(
+ MOUSE::BUTTON_ID button)
+{
+ switch (button)
+ {
+ case MOUSE::BUTTON_ID::LEFT:
+ return JOYSTICK_DRIVER_MOUSE_INDEX_LEFT;
+ case MOUSE::BUTTON_ID::RIGHT:
+ return JOYSTICK_DRIVER_MOUSE_INDEX_RIGHT;
+ case MOUSE::BUTTON_ID::MIDDLE:
+ return JOYSTICK_DRIVER_MOUSE_INDEX_MIDDLE;
+ case MOUSE::BUTTON_ID::BUTTON4:
+ return JOYSTICK_DRIVER_MOUSE_INDEX_BUTTON4;
+ case MOUSE::BUTTON_ID::BUTTON5:
+ return JOYSTICK_DRIVER_MOUSE_INDEX_BUTTON5;
+ case MOUSE::BUTTON_ID::WHEEL_UP:
+ return JOYSTICK_DRIVER_MOUSE_INDEX_WHEEL_UP;
+ case MOUSE::BUTTON_ID::WHEEL_DOWN:
+ return JOYSTICK_DRIVER_MOUSE_INDEX_WHEEL_DOWN;
+ case MOUSE::BUTTON_ID::HORIZ_WHEEL_LEFT:
+ return JOYSTICK_DRIVER_MOUSE_INDEX_HORIZ_WHEEL_LEFT;
+ case MOUSE::BUTTON_ID::HORIZ_WHEEL_RIGHT:
+ return JOYSTICK_DRIVER_MOUSE_INDEX_HORIZ_WHEEL_RIGHT;
+ default:
+ break;
+ }
+
+ return JOYSTICK_DRIVER_MOUSE_INDEX_UNKNOWN;
+}
+
+RELATIVE_POINTER_DIRECTION CPeripheralAddonTranslator::TranslateRelPointerDirection(
+ JOYSTICK_DRIVER_RELPOINTER_DIRECTION dir)
+{
+ switch (dir)
+ {
+ case JOYSTICK_DRIVER_RELPOINTER_LEFT:
+ return RELATIVE_POINTER_DIRECTION::LEFT;
+ case JOYSTICK_DRIVER_RELPOINTER_RIGHT:
+ return RELATIVE_POINTER_DIRECTION::RIGHT;
+ case JOYSTICK_DRIVER_RELPOINTER_UP:
+ return RELATIVE_POINTER_DIRECTION::UP;
+ case JOYSTICK_DRIVER_RELPOINTER_DOWN:
+ return RELATIVE_POINTER_DIRECTION::DOWN;
+ default:
+ break;
+ }
+
+ return RELATIVE_POINTER_DIRECTION::NONE;
+}
+
+JOYSTICK_DRIVER_RELPOINTER_DIRECTION CPeripheralAddonTranslator::TranslateRelPointerDirection(
+ RELATIVE_POINTER_DIRECTION dir)
+{
+ switch (dir)
+ {
+ case RELATIVE_POINTER_DIRECTION::UP:
+ return JOYSTICK_DRIVER_RELPOINTER_UP;
+ case RELATIVE_POINTER_DIRECTION::DOWN:
+ return JOYSTICK_DRIVER_RELPOINTER_DOWN;
+ case RELATIVE_POINTER_DIRECTION::RIGHT:
+ return JOYSTICK_DRIVER_RELPOINTER_RIGHT;
+ case RELATIVE_POINTER_DIRECTION::LEFT:
+ return JOYSTICK_DRIVER_RELPOINTER_LEFT;
+ default:
+ break;
+ }
+ return JOYSTICK_DRIVER_RELPOINTER_UNKNOWN;
+}
+
+JOYSTICK::FEATURE_TYPE CPeripheralAddonTranslator::TranslateFeatureType(JOYSTICK_FEATURE_TYPE type)
+{
+ switch (type)
+ {
+ case JOYSTICK_FEATURE_TYPE_SCALAR:
+ return JOYSTICK::FEATURE_TYPE::SCALAR;
+ case JOYSTICK_FEATURE_TYPE_ANALOG_STICK:
+ return JOYSTICK::FEATURE_TYPE::ANALOG_STICK;
+ case JOYSTICK_FEATURE_TYPE_ACCELEROMETER:
+ return JOYSTICK::FEATURE_TYPE::ACCELEROMETER;
+ case JOYSTICK_FEATURE_TYPE_MOTOR:
+ return JOYSTICK::FEATURE_TYPE::MOTOR;
+ case JOYSTICK_FEATURE_TYPE_RELPOINTER:
+ return JOYSTICK::FEATURE_TYPE::RELPOINTER;
+ case JOYSTICK_FEATURE_TYPE_ABSPOINTER:
+ return JOYSTICK::FEATURE_TYPE::ABSPOINTER;
+ case JOYSTICK_FEATURE_TYPE_WHEEL:
+ return JOYSTICK::FEATURE_TYPE::WHEEL;
+ case JOYSTICK_FEATURE_TYPE_THROTTLE:
+ return JOYSTICK::FEATURE_TYPE::THROTTLE;
+ case JOYSTICK_FEATURE_TYPE_KEY:
+ return JOYSTICK::FEATURE_TYPE::KEY;
+ default:
+ break;
+ }
+ return JOYSTICK::FEATURE_TYPE::UNKNOWN;
+}
+
+JOYSTICK_FEATURE_TYPE CPeripheralAddonTranslator::TranslateFeatureType(JOYSTICK::FEATURE_TYPE type)
+{
+ switch (type)
+ {
+ case JOYSTICK::FEATURE_TYPE::SCALAR:
+ return JOYSTICK_FEATURE_TYPE_SCALAR;
+ case JOYSTICK::FEATURE_TYPE::ANALOG_STICK:
+ return JOYSTICK_FEATURE_TYPE_ANALOG_STICK;
+ case JOYSTICK::FEATURE_TYPE::ACCELEROMETER:
+ return JOYSTICK_FEATURE_TYPE_ACCELEROMETER;
+ case JOYSTICK::FEATURE_TYPE::MOTOR:
+ return JOYSTICK_FEATURE_TYPE_MOTOR;
+ case JOYSTICK::FEATURE_TYPE::RELPOINTER:
+ return JOYSTICK_FEATURE_TYPE_RELPOINTER;
+ case JOYSTICK::FEATURE_TYPE::ABSPOINTER:
+ return JOYSTICK_FEATURE_TYPE_ABSPOINTER;
+ case JOYSTICK::FEATURE_TYPE::WHEEL:
+ return JOYSTICK_FEATURE_TYPE_WHEEL;
+ case JOYSTICK::FEATURE_TYPE::THROTTLE:
+ return JOYSTICK_FEATURE_TYPE_THROTTLE;
+ case JOYSTICK::FEATURE_TYPE::KEY:
+ return JOYSTICK_FEATURE_TYPE_KEY;
+ default:
+ break;
+ }
+ return JOYSTICK_FEATURE_TYPE_UNKNOWN;
+}
+
+kodi::addon::DriverPrimitive CPeripheralAddonTranslator::Opposite(
+ const kodi::addon::DriverPrimitive& primitive)
+{
+ return kodi::addon::DriverPrimitive(primitive.DriverIndex(), primitive.Center() * -1,
+ primitive.SemiAxisDirection() * -1, primitive.Range());
+}
diff --git a/xbmc/peripherals/addons/PeripheralAddonTranslator.h b/xbmc/peripherals/addons/PeripheralAddonTranslator.h
new file mode 100644
index 0000000..308d62c
--- /dev/null
+++ b/xbmc/peripherals/addons/PeripheralAddonTranslator.h
@@ -0,0 +1,62 @@
+/*
+ * 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 "addons/kodi-dev-kit/include/kodi/addon-instance/Peripheral.h"
+#include "input/joysticks/DriverPrimitive.h"
+#include "input/joysticks/JoystickTypes.h"
+#include "input/mouse/MouseTypes.h"
+#include "peripherals/PeripheralTypes.h"
+
+#include <vector>
+
+namespace PERIPHERALS
+{
+class CPeripheralAddonTranslator
+{
+public:
+ static const char* TranslateError(PERIPHERAL_ERROR error);
+
+ static PeripheralType TranslateType(PERIPHERAL_TYPE type);
+ static PERIPHERAL_TYPE TranslateType(PeripheralType type);
+
+ static KODI::JOYSTICK::CDriverPrimitive TranslatePrimitive(
+ const kodi::addon::DriverPrimitive& primitive);
+ static kodi::addon::DriverPrimitive TranslatePrimitive(
+ const KODI::JOYSTICK::CDriverPrimitive& primitive);
+
+ static std::vector<KODI::JOYSTICK::CDriverPrimitive> TranslatePrimitives(
+ const std::vector<kodi::addon::DriverPrimitive>& primitives);
+ static std::vector<kodi::addon::DriverPrimitive> TranslatePrimitives(
+ const std::vector<KODI::JOYSTICK::CDriverPrimitive>& primitives);
+
+ static KODI::JOYSTICK::HAT_DIRECTION TranslateHatDirection(JOYSTICK_DRIVER_HAT_DIRECTION dir);
+ static JOYSTICK_DRIVER_HAT_DIRECTION TranslateHatDirection(KODI::JOYSTICK::HAT_DIRECTION dir);
+
+ static KODI::JOYSTICK::HAT_STATE TranslateHatState(JOYSTICK_STATE_HAT state);
+
+ static KODI::JOYSTICK::SEMIAXIS_DIRECTION TranslateSemiAxisDirection(
+ JOYSTICK_DRIVER_SEMIAXIS_DIRECTION dir);
+ static JOYSTICK_DRIVER_SEMIAXIS_DIRECTION TranslateSemiAxisDirection(
+ KODI::JOYSTICK::SEMIAXIS_DIRECTION dir);
+
+ static KODI::MOUSE::BUTTON_ID TranslateMouseButton(JOYSTICK_DRIVER_MOUSE_INDEX button);
+ static JOYSTICK_DRIVER_MOUSE_INDEX TranslateMouseButton(KODI::MOUSE::BUTTON_ID button);
+
+ static KODI::JOYSTICK::RELATIVE_POINTER_DIRECTION TranslateRelPointerDirection(
+ JOYSTICK_DRIVER_RELPOINTER_DIRECTION dir);
+ static JOYSTICK_DRIVER_RELPOINTER_DIRECTION TranslateRelPointerDirection(
+ KODI::JOYSTICK::RELATIVE_POINTER_DIRECTION dir);
+
+ static KODI::JOYSTICK::FEATURE_TYPE TranslateFeatureType(JOYSTICK_FEATURE_TYPE type);
+ static JOYSTICK_FEATURE_TYPE TranslateFeatureType(KODI::JOYSTICK::FEATURE_TYPE type);
+
+ static kodi::addon::DriverPrimitive Opposite(const kodi::addon::DriverPrimitive& semiaxis);
+};
+} // namespace PERIPHERALS
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-10 23:41:36 +0000