diff options
Diffstat (limited to 'xbmc/input/joysticks')
47 files changed, 6150 insertions, 0 deletions
diff --git a/xbmc/input/joysticks/CMakeLists.txt b/xbmc/input/joysticks/CMakeLists.txt new file mode 100644 index 0000000..0155e5e --- /dev/null +++ b/xbmc/input/joysticks/CMakeLists.txt @@ -0,0 +1,30 @@ +set(SOURCES DeadzoneFilter.cpp + DriverPrimitive.cpp + JoystickEasterEgg.cpp + JoystickMonitor.cpp + JoystickTranslator.cpp + JoystickUtils.cpp + RumbleGenerator.cpp) + +set(HEADERS interfaces/IButtonMap.h + interfaces/IButtonMapCallback.h + interfaces/IButtonMapper.h + interfaces/IButtonSequence.h + interfaces/IDriverHandler.h + interfaces/IDriverReceiver.h + interfaces/IInputHandler.h + interfaces/IInputProvider.h + interfaces/IInputReceiver.h + interfaces/IKeyHandler.h + interfaces/IKeymapHandler.h + DeadzoneFilter.h + DriverPrimitive.h + JoystickEasterEgg.h + JoystickIDs.h + JoystickMonitor.h + JoystickTranslator.h + JoystickTypes.h + JoystickUtils.h + RumbleGenerator.h) + +core_add_library(input_joystick) diff --git a/xbmc/input/joysticks/DeadzoneFilter.cpp b/xbmc/input/joysticks/DeadzoneFilter.cpp new file mode 100644 index 0000000..c437f30 --- /dev/null +++ b/xbmc/input/joysticks/DeadzoneFilter.cpp @@ -0,0 +1,96 @@ +/* + * Copyright (C) 2016-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "DeadzoneFilter.h" + +#include "JoystickIDs.h" +#include "games/controllers/ControllerIDs.h" +#include "input/joysticks/interfaces/IButtonMap.h" +#include "peripherals/devices/Peripheral.h" +#include "utils/log.h" + +#include <cmath> +#include <vector> + +using namespace KODI; +using namespace JOYSTICK; + +//! Allowed noise for detecting discrete D-pads (value of 0.007 when centered +//! has been observed) +#define AXIS_EPSILON 0.01f + +// Settings for analog sticks +#define SETTING_LEFT_STICK_DEADZONE "left_stick_deadzone" +#define SETTING_RIGHT_STICK_DEADZONE "right_stick_deadzone" + +CDeadzoneFilter::CDeadzoneFilter(IButtonMap* buttonMap, PERIPHERALS::CPeripheral* peripheral) + : m_buttonMap(buttonMap), m_peripheral(peripheral) +{ + if (m_buttonMap->ControllerID() != DEFAULT_CONTROLLER_ID) + CLog::Log(LOGERROR, "ERROR: Must use default controller profile instead of {}", + m_buttonMap->ControllerID()); +} + +float CDeadzoneFilter::FilterAxis(unsigned int axisIndex, float axisValue) +{ + float deadzone = 0.0f; + + bool bSuccess = + GetDeadzone(axisIndex, deadzone, DEFAULT_LEFT_STICK_NAME, SETTING_LEFT_STICK_DEADZONE) || + GetDeadzone(axisIndex, deadzone, DEFAULT_RIGHT_STICK_NAME, SETTING_RIGHT_STICK_DEADZONE); + + if (bSuccess) + return ApplyDeadzone(axisValue, deadzone); + + // Always filter noise about the center + if (std::abs(axisValue) < AXIS_EPSILON) + axisValue = 0.0f; + + return axisValue; +} + +bool CDeadzoneFilter::GetDeadzone(unsigned int axisIndex, + float& deadzone, + const char* featureName, + const char* settingName) +{ + std::vector<ANALOG_STICK_DIRECTION> dirs = { + ANALOG_STICK_DIRECTION::UP, + ANALOG_STICK_DIRECTION::RIGHT, + ANALOG_STICK_DIRECTION::DOWN, + ANALOG_STICK_DIRECTION::LEFT, + }; + + CDriverPrimitive primitive; + for (auto dir : dirs) + { + if (m_buttonMap->GetAnalogStick(featureName, dir, primitive)) + { + if (primitive.Type() == PRIMITIVE_TYPE::SEMIAXIS && primitive.Index() == axisIndex) + { + deadzone = m_peripheral->GetSettingFloat(settingName); + return true; + } + } + } + + return false; +} + +float CDeadzoneFilter::ApplyDeadzone(float value, float deadzone) +{ + if (deadzone < 0.0f || deadzone >= 1.0f) + return 0.0f; + + if (value > deadzone) + return (value - deadzone) / (1.0f - deadzone); + else if (value < -deadzone) + return (value + deadzone) / (1.0f - deadzone); + + return 0.0f; +} diff --git a/xbmc/input/joysticks/DeadzoneFilter.h b/xbmc/input/joysticks/DeadzoneFilter.h new file mode 100644 index 0000000..4547050 --- /dev/null +++ b/xbmc/input/joysticks/DeadzoneFilter.h @@ -0,0 +1,82 @@ +/* + * Copyright (C) 2016-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +namespace PERIPHERALS +{ +class CPeripheral; +} + +namespace KODI +{ +namespace JOYSTICK +{ +class IButtonMap; + +/*! + * \ingroup joystick + * \brief Analog axis deadzone filtering + * + * Axis is scaled appropriately, so position is continuous + * from -1.0 to 1.0: + * + * | / 1.0 + * | / + * __|__/ + * / | + * / |--| Deadzone + * -1.0 / | + * + * After deadzone filtering, the value will be: + * + * - Negative in the interval [-1.0, -deadzone) + * - Zero in the interval [-deadzone, deadzone] + * - Positive in the interval (deadzone, 1.0] + */ +class CDeadzoneFilter +{ +public: + CDeadzoneFilter(IButtonMap* buttonMap, PERIPHERALS::CPeripheral* peripheral); + + /*! + * \brief Apply deadzone filtering to an axis + * \param axisIndex The axis index + * \param axisValue The axis value + * \return The value after applying deadzone filtering + */ + float FilterAxis(unsigned int axisIndex, float axisValue); + +private: + /*! + * \brief Get the deadzone value from the peripheral's settings + * \param axisIndex The axis index + * \param[out] result The deadzone value + * \param featureName The feature that axisIndex is mapped to + * \param settingName The setting corresponding to the given feature + * \return True if the feature is an analog stick and the peripheral has the setting + */ + bool GetDeadzone(unsigned int axisIndex, + float& result, + const char* featureName, + const char* settingName); + + /*! + * \brief Utility function to calculate the deadzone + * \param value The value + * \param deadzone The deadzone + * \return The scaled deadzone + */ + static float ApplyDeadzone(float value, float deadzone); + + // Construction parameters + IButtonMap* const m_buttonMap; + PERIPHERALS::CPeripheral* const m_peripheral; +}; +} // namespace JOYSTICK +} // namespace KODI diff --git a/xbmc/input/joysticks/DriverPrimitive.cpp b/xbmc/input/joysticks/DriverPrimitive.cpp new file mode 100644 index 0000000..166e926 --- /dev/null +++ b/xbmc/input/joysticks/DriverPrimitive.cpp @@ -0,0 +1,271 @@ +/* + * 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 "DriverPrimitive.h" + +#include "games/controllers/ControllerTranslator.h" +#include "utils/StringUtils.h" + +#include <utility> + +using namespace KODI; +using namespace JOYSTICK; + +CDriverPrimitive::CDriverPrimitive(void) = default; + +CDriverPrimitive::CDriverPrimitive(PRIMITIVE_TYPE type, unsigned int index) + : m_type(type), m_driverIndex(index) +{ +} + +CDriverPrimitive::CDriverPrimitive(unsigned int hatIndex, HAT_DIRECTION direction) + : m_type(PRIMITIVE_TYPE::HAT), m_driverIndex(hatIndex), m_hatDirection(direction) +{ +} + +CDriverPrimitive::CDriverPrimitive(unsigned int axisIndex, + int center, + SEMIAXIS_DIRECTION direction, + unsigned int range) + : m_type(PRIMITIVE_TYPE::SEMIAXIS), + m_driverIndex(axisIndex), + m_center(center), + m_semiAxisDirection(direction), + m_range(range) +{ +} + +CDriverPrimitive::CDriverPrimitive(XBMCKey keycode) + : m_type(PRIMITIVE_TYPE::KEY), m_keycode(keycode) +{ +} + +CDriverPrimitive::CDriverPrimitive(MOUSE::BUTTON_ID index) + : m_type(PRIMITIVE_TYPE::MOUSE_BUTTON), m_driverIndex(static_cast<unsigned int>(index)) +{ +} + +CDriverPrimitive::CDriverPrimitive(RELATIVE_POINTER_DIRECTION direction) + : m_type(PRIMITIVE_TYPE::RELATIVE_POINTER), m_pointerDirection(direction) +{ +} + +bool CDriverPrimitive::operator==(const CDriverPrimitive& rhs) const +{ + if (m_type == rhs.m_type) + { + switch (m_type) + { + case PRIMITIVE_TYPE::BUTTON: + case PRIMITIVE_TYPE::MOTOR: + case PRIMITIVE_TYPE::MOUSE_BUTTON: + return m_driverIndex == rhs.m_driverIndex; + case PRIMITIVE_TYPE::HAT: + return m_driverIndex == rhs.m_driverIndex && m_hatDirection == rhs.m_hatDirection; + case PRIMITIVE_TYPE::SEMIAXIS: + return m_driverIndex == rhs.m_driverIndex && m_center == rhs.m_center && + m_semiAxisDirection == rhs.m_semiAxisDirection && m_range == rhs.m_range; + case PRIMITIVE_TYPE::KEY: + return m_keycode == rhs.m_keycode; + case PRIMITIVE_TYPE::RELATIVE_POINTER: + return m_pointerDirection == rhs.m_pointerDirection; + default: + return true; + } + } + return false; +} + +bool CDriverPrimitive::operator<(const CDriverPrimitive& rhs) const +{ + if (m_type < rhs.m_type) + return true; + if (m_type > rhs.m_type) + return false; + + if (m_type == PRIMITIVE_TYPE::BUTTON || m_type == PRIMITIVE_TYPE::HAT || + m_type == PRIMITIVE_TYPE::SEMIAXIS || m_type == PRIMITIVE_TYPE::MOTOR || + m_type == PRIMITIVE_TYPE::MOUSE_BUTTON) + { + if (m_driverIndex < rhs.m_driverIndex) + return true; + if (m_driverIndex > rhs.m_driverIndex) + return false; + } + + if (m_type == PRIMITIVE_TYPE::HAT) + { + if (m_hatDirection < rhs.m_hatDirection) + return true; + if (m_hatDirection > rhs.m_hatDirection) + return false; + } + + if (m_type == PRIMITIVE_TYPE::SEMIAXIS) + { + if (m_center < rhs.m_center) + return true; + if (m_center > rhs.m_center) + return false; + + if (m_semiAxisDirection < rhs.m_semiAxisDirection) + return true; + if (m_semiAxisDirection > rhs.m_semiAxisDirection) + return false; + + if (m_range < rhs.m_range) + return true; + if (m_range > rhs.m_range) + return false; + } + + if (m_type == PRIMITIVE_TYPE::KEY) + { + if (m_keycode < rhs.m_keycode) + return true; + if (m_keycode > rhs.m_keycode) + return false; + } + + if (m_type == PRIMITIVE_TYPE::RELATIVE_POINTER) + { + if (m_pointerDirection < rhs.m_pointerDirection) + return true; + if (m_pointerDirection > rhs.m_pointerDirection) + return false; + } + + return false; +} + +bool CDriverPrimitive::IsValid(void) const +{ + if (m_type == PRIMITIVE_TYPE::BUTTON || m_type == PRIMITIVE_TYPE::MOTOR || + m_type == PRIMITIVE_TYPE::MOUSE_BUTTON) + return true; + + if (m_type == PRIMITIVE_TYPE::HAT) + { + return m_hatDirection == HAT_DIRECTION::UP || m_hatDirection == HAT_DIRECTION::DOWN || + m_hatDirection == HAT_DIRECTION::RIGHT || m_hatDirection == HAT_DIRECTION::LEFT; + } + + if (m_type == PRIMITIVE_TYPE::SEMIAXIS) + { + unsigned int maxRange = 1; + + switch (m_center) + { + case -1: + { + if (m_semiAxisDirection != SEMIAXIS_DIRECTION::POSITIVE) + return false; + maxRange = 2; + break; + } + case 0: + { + if (m_semiAxisDirection != SEMIAXIS_DIRECTION::POSITIVE && + m_semiAxisDirection != SEMIAXIS_DIRECTION::NEGATIVE) + return false; + break; + } + case 1: + { + if (m_semiAxisDirection != SEMIAXIS_DIRECTION::POSITIVE) + return false; + maxRange = 2; + break; + } + default: + break; + } + + return 1 <= m_range && m_range <= maxRange; + } + + if (m_type == PRIMITIVE_TYPE::KEY) + return m_keycode != XBMCK_UNKNOWN; + + if (m_type == PRIMITIVE_TYPE::RELATIVE_POINTER) + { + return m_pointerDirection == RELATIVE_POINTER_DIRECTION::UP || + m_pointerDirection == RELATIVE_POINTER_DIRECTION::DOWN || + m_pointerDirection == RELATIVE_POINTER_DIRECTION::RIGHT || + m_pointerDirection == RELATIVE_POINTER_DIRECTION::LEFT; + } + + return false; +} + +std::string CDriverPrimitive::ToString() const +{ + switch (m_type) + { + case PRIMITIVE_TYPE::BUTTON: + return StringUtils::Format("button {}", m_driverIndex); + case PRIMITIVE_TYPE::MOTOR: + return StringUtils::Format("motor {}", m_driverIndex); + case PRIMITIVE_TYPE::MOUSE_BUTTON: + return StringUtils::Format("mouse button {}", m_driverIndex); + case PRIMITIVE_TYPE::HAT: + { + switch (m_hatDirection) + { + case HAT_DIRECTION::UP: + return StringUtils::Format("hat {} up", m_driverIndex); + case HAT_DIRECTION::DOWN: + return StringUtils::Format("hat {} down", m_driverIndex); + case HAT_DIRECTION::RIGHT: + return StringUtils::Format("hat {} right", m_driverIndex); + case HAT_DIRECTION::LEFT: + return StringUtils::Format("hat {} left", m_driverIndex); + default: + break; + } + break; + } + case PRIMITIVE_TYPE::SEMIAXIS: + { + switch (m_semiAxisDirection) + { + case SEMIAXIS_DIRECTION::POSITIVE: + return StringUtils::Format("semiaxis +{}", m_driverIndex); + case SEMIAXIS_DIRECTION::NEGATIVE: + return StringUtils::Format("semiaxis -{}", m_driverIndex); + default: + break; + } + break; + } + case PRIMITIVE_TYPE::KEY: + return StringUtils::Format("key {}", + GAME::CControllerTranslator::TranslateKeycode(m_keycode)); + case PRIMITIVE_TYPE::RELATIVE_POINTER: + { + switch (m_pointerDirection) + { + case RELATIVE_POINTER_DIRECTION::UP: + return StringUtils::Format("pointer {} up", m_driverIndex); + case RELATIVE_POINTER_DIRECTION::DOWN: + return StringUtils::Format("pointer {} down", m_driverIndex); + case RELATIVE_POINTER_DIRECTION::RIGHT: + return StringUtils::Format("pointer {} right", m_driverIndex); + case RELATIVE_POINTER_DIRECTION::LEFT: + return StringUtils::Format("pointer {} left", m_driverIndex); + default: + break; + } + break; + } + default: + break; + } + + return ""; +} diff --git a/xbmc/input/joysticks/DriverPrimitive.h b/xbmc/input/joysticks/DriverPrimitive.h new file mode 100644 index 0000000..11d391b --- /dev/null +++ b/xbmc/input/joysticks/DriverPrimitive.h @@ -0,0 +1,200 @@ +/* + * 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 "JoystickTypes.h" +#include "input/keyboard/KeyboardTypes.h" +#include "input/mouse/MouseTypes.h" + +#include <stdint.h> + +namespace KODI +{ +namespace JOYSTICK +{ +/*! + * \ingroup joystick + * \brief Basic driver element associated with input events + * + * Driver input (bools, floats and enums) is split into primitives that better + * map to the physical features on a joystick. + * + * A bool obviously only maps to a single feature, so it is a driver + * primitive. Here, these are called "buttons". + * + * A hat enum encodes the state of the four hat directions. Each direction + * can map to a different feature, so a hat enum consists of four driver + * primitives called "hat directions". + * + * A float is a little trickier. Trivially, it can map to an analog stick or + * trigger. However, DirectInput combines two triggers onto a single axis. + * Therefore, the axis is split into two primitives called "semiaxes". + * + * The type determines the fields in use: + * + * Button: + * - driver index + * + * Hat direction: + * - driver index + * - hat direction (up/right/down/left) + * + * Semiaxis: + * - driver index + * - center (-1, 0 or 1) + * - semiaxis direction (positive/negative) + * - range (1 or 2) + * + * Motor: + * - driver index + * + * Key: + * - keycode + * + * Mouse button: + * - driver index + * + * Relative pointer: + * - pointer direction + * + * For more info, see "Chapter 2. Joystick drivers" in the documentation + * thread: http://forum.kodi.tv/showthread.php?tid=257764 + */ +class CDriverPrimitive +{ +public: + /*! + * \brief Construct an invalid driver primitive + */ + CDriverPrimitive(void); + + /*! + * \brief Construct a driver primitive representing a button or motor + */ + CDriverPrimitive(PRIMITIVE_TYPE type, unsigned int index); + + /*! + * \brief Construct a driver primitive representing one of the four + * direction arrows on a dpad + */ + CDriverPrimitive(unsigned int hatIndex, HAT_DIRECTION direction); + + /*! + * \brief Construct a driver primitive representing the positive or negative + * half of an axis + */ + CDriverPrimitive(unsigned int axisIndex, + int center, + SEMIAXIS_DIRECTION direction, + unsigned int range); + + /*! + * \brief Construct a driver primitive representing a key on a keyboard + */ + CDriverPrimitive(KEYBOARD::KeySymbol keycode); + + /*! + * \brief Construct a driver primitive representing a mouse button + */ + CDriverPrimitive(MOUSE::BUTTON_ID index); + + /*! + * \brief Construct a driver primitive representing a relative pointer + */ + CDriverPrimitive(RELATIVE_POINTER_DIRECTION direction); + + bool operator==(const CDriverPrimitive& rhs) const; + bool operator<(const CDriverPrimitive& rhs) const; + + bool operator!=(const CDriverPrimitive& rhs) const { return !operator==(rhs); } + bool operator>(const CDriverPrimitive& rhs) const { return !(operator<(rhs) || operator==(rhs)); } + bool operator<=(const CDriverPrimitive& rhs) const { return operator<(rhs) || operator==(rhs); } + bool operator>=(const CDriverPrimitive& rhs) const { return !operator<(rhs); } + + /*! + * \brief The type of driver primitive + */ + PRIMITIVE_TYPE Type(void) const { return m_type; } + + /*! + * \brief The index used by the joystick driver + * + * Valid for: + * - buttons + * - hats + * - semiaxes + * - motors + */ + unsigned int Index(void) const { return m_driverIndex; } + + /*! + * \brief The direction arrow (valid for hat directions) + */ + HAT_DIRECTION HatDirection(void) const { return m_hatDirection; } + + /*! + * \brief The location of the zero point of the semiaxis + */ + int Center() const { return m_center; } + + /*! + * \brief The semiaxis direction (valid for semiaxes) + */ + SEMIAXIS_DIRECTION SemiAxisDirection(void) const { return m_semiAxisDirection; } + + /*! + * \brief The distance between the center and the farthest valid value (valid for semiaxes) + */ + unsigned int Range() const { return m_range; } + + /*! + * \brief The keyboard symbol (valid for keys) + */ + KEYBOARD::KeySymbol Keycode() const { return m_keycode; } + + /*! + * \brief The mouse button ID (valid for mouse buttons) + */ + MOUSE::BUTTON_ID MouseButton() const { return static_cast<MOUSE::BUTTON_ID>(m_driverIndex); } + + /*! + * \brief The relative pointer direction (valid for relative pointers) + */ + RELATIVE_POINTER_DIRECTION PointerDirection() const { return m_pointerDirection; } + + /*! + * \brief Test if an driver primitive is valid + * + * A driver primitive is valid if it has a known type and: + * + * 1) for hats, it is a cardinal direction + * 2) for semi-axes, it is a positive or negative direction + * 3) for keys, the keycode is non-empty + */ + bool IsValid(void) const; + + /*! + * \brief Convert primitive to a string suitable for logging + * + * \return The primitive as described by a short string, or empty if invalid + */ + std::string ToString() const; + +private: + PRIMITIVE_TYPE m_type = PRIMITIVE_TYPE::UNKNOWN; + unsigned int m_driverIndex = 0; + HAT_DIRECTION m_hatDirection = HAT_DIRECTION::NONE; + int m_center = 0; + SEMIAXIS_DIRECTION m_semiAxisDirection = SEMIAXIS_DIRECTION::ZERO; + unsigned int m_range = 1; + KEYBOARD::KeySymbol m_keycode = XBMCK_UNKNOWN; + RELATIVE_POINTER_DIRECTION m_pointerDirection = RELATIVE_POINTER_DIRECTION::NONE; +}; +} // namespace JOYSTICK +} // namespace KODI diff --git a/xbmc/input/joysticks/JoystickEasterEgg.cpp b/xbmc/input/joysticks/JoystickEasterEgg.cpp new file mode 100644 index 0000000..b0259a6 --- /dev/null +++ b/xbmc/input/joysticks/JoystickEasterEgg.cpp @@ -0,0 +1,107 @@ +/* + * Copyright (C) 2016-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "JoystickEasterEgg.h" + +#include "ServiceBroker.h" +#include "games/GameServices.h" +#include "games/GameSettings.h" +#include "games/controllers/ControllerIDs.h" +#include "games/controllers/DefaultController.h" +#include "guilib/GUIAudioManager.h" +#include "guilib/WindowIDs.h" + +using namespace KODI; +using namespace JOYSTICK; + +const std::map<std::string, std::vector<FeatureName>> CJoystickEasterEgg::m_sequence = { + { + DEFAULT_CONTROLLER_ID, + { + GAME::CDefaultController::FEATURE_UP, + GAME::CDefaultController::FEATURE_UP, + GAME::CDefaultController::FEATURE_DOWN, + GAME::CDefaultController::FEATURE_DOWN, + GAME::CDefaultController::FEATURE_LEFT, + GAME::CDefaultController::FEATURE_RIGHT, + GAME::CDefaultController::FEATURE_LEFT, + GAME::CDefaultController::FEATURE_RIGHT, + GAME::CDefaultController::FEATURE_B, + GAME::CDefaultController::FEATURE_A, + }, + }, + { + DEFAULT_REMOTE_ID, + { + "up", + "up", + "down", + "down", + "left", + "right", + "left", + "right", + "back", + "ok", + }, + }, +}; + +CJoystickEasterEgg::CJoystickEasterEgg(const std::string& controllerId) + : m_controllerId(controllerId), m_state(0) +{ +} + +bool CJoystickEasterEgg::OnButtonPress(const FeatureName& feature) +{ + bool bHandled = false; + + auto it = m_sequence.find(m_controllerId); + if (it != m_sequence.end()) + { + const auto& sequence = it->second; + + // Reset state if it previously finished + if (m_state >= sequence.size()) + m_state = 0; + + if (feature == sequence[m_state]) + m_state++; + else + m_state = 0; + + if (IsCapturing()) + { + bHandled = true; + + if (m_state >= sequence.size()) + OnFinish(); + } + } + + return bHandled; +} + +bool CJoystickEasterEgg::IsCapturing() +{ + // Capture input when finished with arrows (2 x up/down/left/right) + return m_state > 8; +} + +void CJoystickEasterEgg::OnFinish(void) +{ + GAME::CGameSettings& gameSettings = CServiceBroker::GetGameServices().GameSettings(); + gameSettings.ToggleGames(); + + WINDOW_SOUND sound = gameSettings.GamesEnabled() ? SOUND_INIT : SOUND_DEINIT; + CGUIComponent* gui = CServiceBroker::GetGUI(); + if (gui) + gui->GetAudioManager().PlayWindowSound(WINDOW_DIALOG_KAI_TOAST, sound); + + //! @todo Shake screen +} diff --git a/xbmc/input/joysticks/JoystickEasterEgg.h b/xbmc/input/joysticks/JoystickEasterEgg.h new file mode 100644 index 0000000..7059d13 --- /dev/null +++ b/xbmc/input/joysticks/JoystickEasterEgg.h @@ -0,0 +1,45 @@ +/* + * Copyright (C) 2016-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include "input/joysticks/interfaces/IButtonSequence.h" + +#include <map> +#include <string> +#include <vector> + +namespace KODI +{ +namespace JOYSTICK +{ +/*! + * \brief Hush!!! + */ +class CJoystickEasterEgg : public IButtonSequence +{ +public: + explicit CJoystickEasterEgg(const std::string& controllerId); + ~CJoystickEasterEgg() override = default; + + // implementation of IButtonSequence + bool OnButtonPress(const FeatureName& feature) override; + bool IsCapturing() override; + + static void OnFinish(void); + +private: + // Construction parameters + const std::string m_controllerId; + + static const std::map<std::string, std::vector<FeatureName>> m_sequence; + + unsigned int m_state; +}; +} // namespace JOYSTICK +} // namespace KODI diff --git a/xbmc/input/joysticks/JoystickIDs.h b/xbmc/input/joysticks/JoystickIDs.h new file mode 100644 index 0000000..52ffcf4 --- /dev/null +++ b/xbmc/input/joysticks/JoystickIDs.h @@ -0,0 +1,13 @@ +/* + * Copyright (C) 2017-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +// Analog sticks on the default controller +#define DEFAULT_LEFT_STICK_NAME "leftstick" +#define DEFAULT_RIGHT_STICK_NAME "rightstick" diff --git a/xbmc/input/joysticks/JoystickMonitor.cpp b/xbmc/input/joysticks/JoystickMonitor.cpp new file mode 100644 index 0000000..6375a41 --- /dev/null +++ b/xbmc/input/joysticks/JoystickMonitor.cpp @@ -0,0 +1,111 @@ +/* + * 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 "JoystickMonitor.h" + +#include "ServiceBroker.h" +#include "application/ApplicationComponents.h" +#include "application/ApplicationPowerHandling.h" +#include "games/controllers/ControllerIDs.h" +#include "input/InputManager.h" + +#include <cmath> + +using namespace KODI; +using namespace JOYSTICK; + +#define AXIS_DEADZONE 0.05f + +std::string CJoystickMonitor::ControllerID() const +{ + return DEFAULT_CONTROLLER_ID; +} + +bool CJoystickMonitor::AcceptsInput(const FeatureName& feature) const +{ + // Only accept input when screen saver is active + auto& components = CServiceBroker::GetAppComponents(); + const auto appPower = components.GetComponent<CApplicationPowerHandling>(); + return appPower->IsInScreenSaver(); +} + +bool CJoystickMonitor::OnButtonPress(const FeatureName& feature, bool bPressed) +{ + if (bPressed) + { + CServiceBroker::GetInputManager().SetMouseActive(false); + return ResetTimers(); + } + + return false; +} + +bool CJoystickMonitor::OnButtonMotion(const FeatureName& feature, + float magnitude, + unsigned int motionTimeMs) +{ + if (std::fabs(magnitude) > AXIS_DEADZONE) + { + CServiceBroker::GetInputManager().SetMouseActive(false); + return ResetTimers(); + } + + return false; +} + +bool CJoystickMonitor::OnAnalogStickMotion(const FeatureName& feature, + float x, + float y, + unsigned int motionTimeMs) +{ + // Analog stick deadzone already processed + if (x != 0.0f || y != 0.0f) + { + CServiceBroker::GetInputManager().SetMouseActive(false); + return ResetTimers(); + } + + return false; +} + +bool CJoystickMonitor::OnWheelMotion(const FeatureName& feature, + float position, + unsigned int motionTimeMs) +{ + if (std::fabs(position) > AXIS_DEADZONE) + { + CServiceBroker::GetInputManager().SetMouseActive(false); + return ResetTimers(); + } + + return false; +} + +bool CJoystickMonitor::OnThrottleMotion(const FeatureName& feature, + float position, + unsigned int motionTimeMs) +{ + if (std::fabs(position) > AXIS_DEADZONE) + { + CServiceBroker::GetInputManager().SetMouseActive(false); + return ResetTimers(); + } + + return false; +} + +bool CJoystickMonitor::ResetTimers(void) +{ + auto& components = CServiceBroker::GetAppComponents(); + const auto appPower = components.GetComponent<CApplicationPowerHandling>(); + appPower->ResetSystemIdleTimer(); + appPower->ResetScreenSaver(); + return appPower->WakeUpScreenSaverAndDPMS(); + + return true; +} diff --git a/xbmc/input/joysticks/JoystickMonitor.h b/xbmc/input/joysticks/JoystickMonitor.h new file mode 100644 index 0000000..783fff1 --- /dev/null +++ b/xbmc/input/joysticks/JoystickMonitor.h @@ -0,0 +1,58 @@ +/* + * Copyright (C) 2015-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include "input/joysticks/interfaces/IInputHandler.h" + +namespace KODI +{ +namespace JOYSTICK +{ +/*! + * \ingroup joystick + * \brief Monitors joystick input and resets screensaver/shutdown timers + * whenever motion occurs. + */ +class CJoystickMonitor : public IInputHandler +{ +public: + // implementation of IInputHandler + std::string ControllerID() const override; + bool HasFeature(const FeatureName& feature) const override { return true; } + bool AcceptsInput(const FeatureName& feature) const override; + bool OnButtonPress(const FeatureName& feature, bool bPressed) override; + void OnButtonHold(const FeatureName& feature, unsigned int holdTimeMs) override {} + bool OnButtonMotion(const FeatureName& feature, + float magnitude, + unsigned int motionTimeMs) override; + bool OnAnalogStickMotion(const FeatureName& feature, + float x, + float y, + unsigned int motionTimeMs) override; + bool OnAccelerometerMotion(const FeatureName& feature, float x, float y, float z) override + { + return false; + } + bool OnWheelMotion(const FeatureName& feature, + float position, + unsigned int motionTimeMs) override; + bool OnThrottleMotion(const FeatureName& feature, + float position, + unsigned int motionTimeMs) override; + void OnInputFrame() override {} + +private: + /*! + * \brief Reset screensaver and shutdown timers + * \return True if the application was woken from screensaver + */ + bool ResetTimers(void); +}; +} // namespace JOYSTICK +} // namespace KODI diff --git a/xbmc/input/joysticks/JoystickTranslator.cpp b/xbmc/input/joysticks/JoystickTranslator.cpp new file mode 100644 index 0000000..7edfeaf --- /dev/null +++ b/xbmc/input/joysticks/JoystickTranslator.cpp @@ -0,0 +1,175 @@ +/* + * 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 "JoystickTranslator.h" + +#include "guilib/LocalizeStrings.h" +#include "input/joysticks/DriverPrimitive.h" +#include "utils/StringUtils.h" + +using namespace KODI; +using namespace JOYSTICK; + +const char* CJoystickTranslator::HatStateToString(HAT_STATE state) +{ + switch (state) + { + case HAT_STATE::UP: + return "UP"; + case HAT_STATE::DOWN: + return "DOWN"; + case HAT_STATE::RIGHT: + return "RIGHT"; + case HAT_STATE::LEFT: + return "LEFT"; + case HAT_STATE::RIGHTUP: + return "UP RIGHT"; + case HAT_STATE::RIGHTDOWN: + return "DOWN RIGHT"; + case HAT_STATE::LEFTUP: + return "UP LEFT"; + case HAT_STATE::LEFTDOWN: + return "DOWN LEFT"; + default: + break; + } + + return "RELEASED"; +} + +const char* CJoystickTranslator::TranslateAnalogStickDirection(ANALOG_STICK_DIRECTION dir) +{ + switch (dir) + { + case ANALOG_STICK_DIRECTION::UP: + return "up"; + case ANALOG_STICK_DIRECTION::DOWN: + return "down"; + case ANALOG_STICK_DIRECTION::RIGHT: + return "right"; + case ANALOG_STICK_DIRECTION::LEFT: + return "left"; + default: + break; + } + + return ""; +} + +ANALOG_STICK_DIRECTION CJoystickTranslator::TranslateAnalogStickDirection(const std::string& dir) +{ + if (dir == "up") + return ANALOG_STICK_DIRECTION::UP; + if (dir == "down") + return ANALOG_STICK_DIRECTION::DOWN; + if (dir == "right") + return ANALOG_STICK_DIRECTION::RIGHT; + if (dir == "left") + return ANALOG_STICK_DIRECTION::LEFT; + + return ANALOG_STICK_DIRECTION::NONE; +} + +const char* CJoystickTranslator::TranslateWheelDirection(WHEEL_DIRECTION dir) +{ + switch (dir) + { + case WHEEL_DIRECTION::RIGHT: + return "right"; + case WHEEL_DIRECTION::LEFT: + return "left"; + default: + break; + } + + return ""; +} + +WHEEL_DIRECTION CJoystickTranslator::TranslateWheelDirection(const std::string& dir) +{ + if (dir == "right") + return WHEEL_DIRECTION::RIGHT; + if (dir == "left") + return WHEEL_DIRECTION::LEFT; + + return WHEEL_DIRECTION::NONE; +} + +const char* CJoystickTranslator::TranslateThrottleDirection(THROTTLE_DIRECTION dir) +{ + switch (dir) + { + case THROTTLE_DIRECTION::UP: + return "up"; + case THROTTLE_DIRECTION::DOWN: + return "down"; + default: + break; + } + + return ""; +} + +THROTTLE_DIRECTION CJoystickTranslator::TranslateThrottleDirection(const std::string& dir) +{ + if (dir == "up") + return THROTTLE_DIRECTION::UP; + if (dir == "down") + return THROTTLE_DIRECTION::DOWN; + + return THROTTLE_DIRECTION::NONE; +} + +SEMIAXIS_DIRECTION CJoystickTranslator::PositionToSemiAxisDirection(float position) +{ + if (position > 0) + return SEMIAXIS_DIRECTION::POSITIVE; + else if (position < 0) + return SEMIAXIS_DIRECTION::NEGATIVE; + + return SEMIAXIS_DIRECTION::ZERO; +} + +WHEEL_DIRECTION CJoystickTranslator::PositionToWheelDirection(float position) +{ + if (position > 0.0f) + return WHEEL_DIRECTION::RIGHT; + else if (position < 0.0f) + return WHEEL_DIRECTION::LEFT; + + return WHEEL_DIRECTION::NONE; +} + +THROTTLE_DIRECTION CJoystickTranslator::PositionToThrottleDirection(float position) +{ + if (position > 0.0f) + return THROTTLE_DIRECTION::UP; + else if (position < 0.0f) + return THROTTLE_DIRECTION::DOWN; + + return THROTTLE_DIRECTION::NONE; +} + +std::string CJoystickTranslator::GetPrimitiveName(const CDriverPrimitive& primitive) +{ + std::string primitiveTemplate; + + switch (primitive.Type()) + { + case PRIMITIVE_TYPE::BUTTON: + primitiveTemplate = g_localizeStrings.Get(35015); // "Button %d" + break; + case PRIMITIVE_TYPE::SEMIAXIS: + primitiveTemplate = g_localizeStrings.Get(35016); // "Axis %d" + break; + default: + break; + } + + return StringUtils::Format(primitiveTemplate, primitive.Index()); +} diff --git a/xbmc/input/joysticks/JoystickTranslator.h b/xbmc/input/joysticks/JoystickTranslator.h new file mode 100644 index 0000000..2efeacc --- /dev/null +++ b/xbmc/input/joysticks/JoystickTranslator.h @@ -0,0 +1,125 @@ +/* + * 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 "JoystickTypes.h" + +namespace KODI +{ +namespace JOYSTICK +{ +class CDriverPrimitive; + +/*! + * \brief Joystick translation utilities + */ +class CJoystickTranslator +{ +public: + /*! + * \brief Translate a hat state to a string representation + * + * \param state The hat state + * + * \return A capitalized string representation, or "RELEASED" if the hat is centered. + */ + static const char* HatStateToString(HAT_STATE state); + + /*! + * \brief Translate an analog stick direction to a lower-case string + * + * \param dir The analog stick direction + * + * \return A lower-case string representation, or "" if the direction is invalid + */ + static const char* TranslateAnalogStickDirection(ANALOG_STICK_DIRECTION dir); + + /*! + * \brief Translate an analog stick direction string to an enum value + * + * \param dir The analog stick direction + * + * \return The translated direction, or ANALOG_STICK_DIRECTION::UNKNOWN if unknown + */ + static ANALOG_STICK_DIRECTION TranslateAnalogStickDirection(const std::string& dir); + + /*! + * \brief Translate a wheel direction to a lower-case string + * + * \param dir The wheel direction + * + * \return A lower-case string representation, or "" if the direction is invalid + */ + static const char* TranslateWheelDirection(WHEEL_DIRECTION dir); + + /*! + * \brief Translate a wheel direction string to an enum value + * + * \param dir The wheel direction + * + * \return The translated direction, or WHEEL_DIRECTION::UNKNOWN if unknown + */ + static WHEEL_DIRECTION TranslateWheelDirection(const std::string& dir); + + /*! + * \brief Translate a throttle direction to a lower-case string + * + * \param dir The analog stick direction + * + * \return A lower-case string representation, or "" if the direction is invalid + */ + static const char* TranslateThrottleDirection(THROTTLE_DIRECTION dir); + + /*! + * \brief Translate a throttle direction string to an enum value + * + * \param dir The throttle direction + * + * \return The translated direction, or THROTTLE_DIRECTION::UNKNOWN if unknown + */ + static THROTTLE_DIRECTION TranslateThrottleDirection(const std::string& dir); + + /*! + * \brief Get the semi-axis direction containing the specified position + * + * \param position The position of the axis + * + * \return POSITIVE, NEGATIVE, or UNKNOWN if position is 0 + */ + static SEMIAXIS_DIRECTION PositionToSemiAxisDirection(float position); + + /*! + * \brief Get the wheel direction containing the specified position + * + * \param position The position of the axis + * + * \return LEFT, RIGHT, or UNKNOWN if position is 0 + */ + static WHEEL_DIRECTION PositionToWheelDirection(float position); + + /*! + * \brief Get the throttle direction containing the specified position + * + * \param position The position of the axis + * + * \return UP, DOWN, or UNKNOWN if position is 0 + */ + static THROTTLE_DIRECTION PositionToThrottleDirection(float position); + + /*! + * \brief Get the localized name of the primitive + * + * \param primitive The primitive, currently only buttons and axes are supported + * + * \return A title for the primitive, e.g. "Button 0" or "Axis 1" + */ + static std::string GetPrimitiveName(const CDriverPrimitive& primitive); +}; +} // namespace JOYSTICK +} // namespace KODI diff --git a/xbmc/input/joysticks/JoystickTypes.h b/xbmc/input/joysticks/JoystickTypes.h new file mode 100644 index 0000000..5925793 --- /dev/null +++ b/xbmc/input/joysticks/JoystickTypes.h @@ -0,0 +1,186 @@ +/* + * 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 + +/*! + \file + \ingroup joystick + */ + +#include "input/InputTypes.h" + +#include <set> +#include <string> + +namespace KODI +{ +namespace JOYSTICK +{ +/*! + * \brief Name of a physical feature belonging to the joystick + */ +using FeatureName = std::string; + +/*! + * \brief Types of features used in the joystick library + * + * Available types: + * + * 1) scalar[*] + * 2) analog stick + * 3) accelerometer + * 4) rumble motor + * 5) relative pointer + * 6) absolute pointer + * 7) wheel + * 8) throttle + * 9) keyboard key + * + * [*] All three driver primitives (buttons, hats and axes) have a state that + * can be represented using a single scalar value. For this reason, + * features that map to a single primitive are called "scalar features". + */ +enum class FEATURE_TYPE +{ + UNKNOWN, + SCALAR, + ANALOG_STICK, + ACCELEROMETER, + MOTOR, + RELPOINTER, + ABSPOINTER, + WHEEL, + THROTTLE, + KEY, +}; + +/*! + * \brief Categories of features used in the joystick library + */ +enum class FEATURE_CATEGORY +{ + UNKNOWN, + FACE, + SHOULDER, + TRIGGER, + ANALOG_STICK, + ACCELEROMETER, + HAPTICS, + MOUSE_BUTTON, + POINTER, + LIGHTGUN, + OFFSCREEN, // Virtual button to shoot light gun offscreen + KEY, // A keyboard key + KEYPAD, // A key on a numeric keymap, including star and pound + HARDWARE, // A button or functionality on the console + WHEEL, + JOYSTICK, + PADDLE, +}; + +/*! + * \brief Direction arrows on the hat (directional pad) + */ +using HAT_DIRECTION = INPUT::CARDINAL_DIRECTION; + +/*! + * \brief States in which a hat can be + */ +using HAT_STATE = INPUT::INTERCARDINAL_DIRECTION; + +/*! + * \brief Typedef for analog stick directions + */ +using ANALOG_STICK_DIRECTION = INPUT::CARDINAL_DIRECTION; + +/*! + * \brief Directions of motion for a relative pointer + */ +using RELATIVE_POINTER_DIRECTION = INPUT::CARDINAL_DIRECTION; + +/*! + * \brief Directions in which a semiaxis can point + */ +enum class SEMIAXIS_DIRECTION +{ + NEGATIVE = -1, // semiaxis lies in the interval [-1.0, 0.0] + ZERO = 0, // semiaxis is unknown or invalid + POSITIVE = 1, // semiaxis lies in the interval [0.0, 1.0] +}; + +/*! + * \brief Directions on a wheel + */ +enum class WHEEL_DIRECTION +{ + NONE, + RIGHT, + LEFT, +}; + +/*! + * \brief Directions on a throttle + */ +enum class THROTTLE_DIRECTION +{ + NONE, + UP, + DOWN, +}; + +/*! + * \brief Types of input available for scalar features + */ +enum class INPUT_TYPE +{ + UNKNOWN, + DIGITAL, + ANALOG, +}; + +/*! + * \brief Type of driver primitive + */ +enum class PRIMITIVE_TYPE +{ + UNKNOWN = 0, // primitive has no type (invalid) + BUTTON, // a digital button + HAT, // one of the four direction arrows on a D-pad + SEMIAXIS, // the positive or negative half of an axis + MOTOR, // a rumble motor + KEY, // a keyboard key + MOUSE_BUTTON, // a mouse button + RELATIVE_POINTER, // a relative pointer, such as on a mouse +}; + +/*! + * \ingroup joystick + * \brief Action entry in joystick.xml + */ +struct KeymapAction +{ + unsigned int actionId; + std::string actionString; + unsigned int holdTimeMs; + std::set<std::string> hotkeys; + + bool operator<(const KeymapAction& rhs) const { return holdTimeMs < rhs.holdTimeMs; } +}; + +/*! + * \ingroup joystick + * \brief Container that sorts action entries by their holdtime + */ +struct KeymapActionGroup +{ + int windowId = -1; + std::set<KeymapAction> actions; +}; +} // namespace JOYSTICK +} // namespace KODI diff --git a/xbmc/input/joysticks/JoystickUtils.cpp b/xbmc/input/joysticks/JoystickUtils.cpp new file mode 100644 index 0000000..3c25121 --- /dev/null +++ b/xbmc/input/joysticks/JoystickUtils.cpp @@ -0,0 +1,103 @@ +/* + * Copyright (C) 2017-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "JoystickUtils.h" + +#include "JoystickTranslator.h" +#include "utils/StringUtils.h" + +using namespace KODI; +using namespace JOYSTICK; + +std::string CJoystickUtils::MakeKeyName(const FeatureName& feature) +{ + return feature; +} + +std::string CJoystickUtils::MakeKeyName(const FeatureName& feature, ANALOG_STICK_DIRECTION dir) +{ + std::string keyName = feature; + + if (dir != ANALOG_STICK_DIRECTION::NONE) + keyName += CJoystickTranslator::TranslateAnalogStickDirection(dir); + + return keyName; +} + +std::string CJoystickUtils::MakeKeyName(const FeatureName& feature, WHEEL_DIRECTION dir) +{ + ANALOG_STICK_DIRECTION stickDir = ANALOG_STICK_DIRECTION::NONE; + + switch (dir) + { + case WHEEL_DIRECTION::LEFT: + stickDir = ANALOG_STICK_DIRECTION::LEFT; + break; + case WHEEL_DIRECTION::RIGHT: + stickDir = ANALOG_STICK_DIRECTION::RIGHT; + break; + default: + break; + } + + return MakeKeyName(feature, stickDir); +} + +std::string CJoystickUtils::MakeKeyName(const FeatureName& feature, THROTTLE_DIRECTION dir) +{ + ANALOG_STICK_DIRECTION stickDir = ANALOG_STICK_DIRECTION::NONE; + + switch (dir) + { + case THROTTLE_DIRECTION::UP: + stickDir = ANALOG_STICK_DIRECTION::UP; + break; + case THROTTLE_DIRECTION::DOWN: + stickDir = ANALOG_STICK_DIRECTION::DOWN; + break; + default: + break; + } + + return MakeKeyName(feature, stickDir); +} + +const std::vector<ANALOG_STICK_DIRECTION>& CJoystickUtils::GetAnalogStickDirections() +{ + static std::vector<ANALOG_STICK_DIRECTION> directions; + if (directions.empty()) + { + directions.push_back(ANALOG_STICK_DIRECTION::UP); + directions.push_back(ANALOG_STICK_DIRECTION::DOWN); + directions.push_back(ANALOG_STICK_DIRECTION::RIGHT); + directions.push_back(ANALOG_STICK_DIRECTION::LEFT); + } + return directions; +} + +const std::vector<WHEEL_DIRECTION>& CJoystickUtils::GetWheelDirections() +{ + static std::vector<WHEEL_DIRECTION> directions; + if (directions.empty()) + { + directions.push_back(WHEEL_DIRECTION::RIGHT); + directions.push_back(WHEEL_DIRECTION::LEFT); + } + return directions; +} + +const std::vector<THROTTLE_DIRECTION>& CJoystickUtils::GetThrottleDirections() +{ + static std::vector<THROTTLE_DIRECTION> directions; + if (directions.empty()) + { + directions.push_back(THROTTLE_DIRECTION::UP); + directions.push_back(THROTTLE_DIRECTION::DOWN); + } + return directions; +} diff --git a/xbmc/input/joysticks/JoystickUtils.h b/xbmc/input/joysticks/JoystickUtils.h new file mode 100644 index 0000000..49095d2 --- /dev/null +++ b/xbmc/input/joysticks/JoystickUtils.h @@ -0,0 +1,110 @@ +/* + * 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 "JoystickTypes.h" + +#include <string> +#include <vector> + +/// \ingroup joystick +/// \{ + +namespace KODI +{ +namespace JOYSTICK +{ + +inline HAT_DIRECTION& operator|=(HAT_DIRECTION& lhs, HAT_DIRECTION rhs) +{ + return lhs = static_cast<HAT_DIRECTION>(static_cast<int>(lhs) | static_cast<int>(rhs)); +} + +inline HAT_STATE& operator|=(HAT_STATE& lhs, HAT_STATE rhs) +{ + return lhs = static_cast<HAT_STATE>(static_cast<int>(lhs) | static_cast<int>(rhs)); +} + +inline bool operator&(HAT_STATE lhs, HAT_DIRECTION rhs) +{ + return (static_cast<int>(lhs) & static_cast<int>(rhs)) ? true : false; +} + +inline SEMIAXIS_DIRECTION operator*(SEMIAXIS_DIRECTION lhs, int rhs) +{ + return static_cast<SEMIAXIS_DIRECTION>(static_cast<int>(lhs) * rhs); +} + +inline float operator*(float lhs, SEMIAXIS_DIRECTION rhs) +{ + return lhs * static_cast<int>(rhs); +} + +class CJoystickUtils +{ +public: + /*! + * \brief Create a key name used to index an action in the keymap + * + * \param feature The feature name + * + * \return A valid name for a key in the joystick keymap + */ + static std::string MakeKeyName(const FeatureName& feature); + + /*! + * \brief Create a key name used to index an action in the keymap + * + * \param feature The feature name + * \param dir The direction for analog sticks + * + * \return A valid name for a key in the joystick keymap + */ + static std::string MakeKeyName(const FeatureName& feature, ANALOG_STICK_DIRECTION dir); + + /*! + * \brief Create a key name used to index an action in the keymap + * + * \param feature The feature name + * \param dir The direction for a wheel to turn + * + * \return A valid name for a key in the joystick keymap + */ + static std::string MakeKeyName(const FeatureName& feature, WHEEL_DIRECTION dir); + + /*! + * \brief Create a key name used to index an action in the keymap + * + * \param feature The feature name + * \param dir The direction for a throttle to move + * + * \return A valid name for a key in the joystick keymap + */ + static std::string MakeKeyName(const FeatureName& feature, THROTTLE_DIRECTION dir); + + /*! + * \brief Return a vector of the four cardinal directions + */ + static const std::vector<ANALOG_STICK_DIRECTION>& GetAnalogStickDirections(); + + /*! + * \brief Return a vector of the two wheel directions + */ + static const std::vector<WHEEL_DIRECTION>& GetWheelDirections(); + + /*! + * \brief Return a vector of the two throttle directions + */ + static const std::vector<THROTTLE_DIRECTION>& GetThrottleDirections(); +}; + +} // namespace JOYSTICK +} // namespace KODI + +/// \} diff --git a/xbmc/input/joysticks/RumbleGenerator.cpp b/xbmc/input/joysticks/RumbleGenerator.cpp new file mode 100644 index 0000000..db60cfa --- /dev/null +++ b/xbmc/input/joysticks/RumbleGenerator.cpp @@ -0,0 +1,130 @@ +/* + * Copyright (C) 2016-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "RumbleGenerator.h" + +#include "ServiceBroker.h" +#include "games/controllers/Controller.h" +#include "games/controllers/ControllerIDs.h" +#include "games/controllers/ControllerManager.h" +#include "input/joysticks/interfaces/IInputReceiver.h" + +#include <algorithm> + +using namespace std::chrono_literals; + +namespace +{ +constexpr auto RUMBLE_TEST_DURATION_MS = 1000ms; // Per motor +constexpr auto RUMBLE_NOTIFICATION_DURATION_MS = 300ms; + +// From game.controller.default profile +#define WEAK_MOTOR_NAME "rightmotor" +} // namespace + +using namespace KODI; +using namespace JOYSTICK; + +CRumbleGenerator::CRumbleGenerator() + : CThread("RumbleGenerator"), m_motors(GetMotors(ControllerID())) +{ +} + +std::string CRumbleGenerator::ControllerID() const +{ + return DEFAULT_CONTROLLER_ID; +} + +void CRumbleGenerator::NotifyUser(IInputReceiver* receiver) +{ + if (receiver && !m_motors.empty()) + { + if (IsRunning()) + StopThread(true); + + m_receiver = receiver; + m_type = RUMBLE_NOTIFICATION; + Create(); + } +} + +bool CRumbleGenerator::DoTest(IInputReceiver* receiver) +{ + if (receiver && !m_motors.empty()) + { + if (IsRunning()) + StopThread(true); + + m_receiver = receiver; + m_type = RUMBLE_TEST; + Create(); + + return true; + } + return false; +} + +void CRumbleGenerator::Process(void) +{ + switch (m_type) + { + case RUMBLE_NOTIFICATION: + { + std::vector<std::string> motors; + + if (std::find(m_motors.begin(), m_motors.end(), WEAK_MOTOR_NAME) != m_motors.end()) + motors.emplace_back(WEAK_MOTOR_NAME); + else + motors = m_motors; // Not using default profile? Just rumble all motors + + for (const std::string& motor : motors) + m_receiver->SetRumbleState(motor, 1.0f); + + CThread::Sleep(RUMBLE_NOTIFICATION_DURATION_MS); + + if (m_bStop) + break; + + for (const std::string& motor : motors) + m_receiver->SetRumbleState(motor, 0.0f); + + break; + } + case RUMBLE_TEST: + { + for (const std::string& motor : m_motors) + { + m_receiver->SetRumbleState(motor, 1.0f); + + CThread::Sleep(RUMBLE_TEST_DURATION_MS); + + if (m_bStop) + break; + + m_receiver->SetRumbleState(motor, 0.0f); + } + break; + } + default: + break; + } +} + +std::vector<std::string> CRumbleGenerator::GetMotors(const std::string& controllerId) +{ + using namespace GAME; + + std::vector<std::string> motors; + + CControllerManager& controllerManager = CServiceBroker::GetGameControllerManager(); + ControllerPtr controller = controllerManager.GetController(controllerId); + if (controller) + controller->GetFeatures(motors, FEATURE_TYPE::MOTOR); + + return motors; +} diff --git a/xbmc/input/joysticks/RumbleGenerator.h b/xbmc/input/joysticks/RumbleGenerator.h new file mode 100644 index 0000000..a6e9853 --- /dev/null +++ b/xbmc/input/joysticks/RumbleGenerator.h @@ -0,0 +1,58 @@ +/* + * Copyright (C) 2016-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include "threads/Thread.h" + +#include <string> +#include <vector> + +namespace KODI +{ +namespace JOYSTICK +{ +class IInputReceiver; + +class CRumbleGenerator : public CThread +{ +public: + CRumbleGenerator(); + + ~CRumbleGenerator() override { AbortRumble(); } + + std::string ControllerID() const; + + void NotifyUser(IInputReceiver* receiver); + bool DoTest(IInputReceiver* receiver); + + void AbortRumble(void) { StopThread(); } + +protected: + // implementation of CThread + void Process() override; + +private: + enum RUMBLE_TYPE + { + RUMBLE_UNKNOWN, + RUMBLE_NOTIFICATION, + RUMBLE_TEST, + }; + + static std::vector<std::string> GetMotors(const std::string& controllerId); + + // Construction param + const std::vector<std::string> m_motors; + + // Test param + IInputReceiver* m_receiver = nullptr; + RUMBLE_TYPE m_type = RUMBLE_UNKNOWN; +}; +} // namespace JOYSTICK +} // namespace KODI diff --git a/xbmc/input/joysticks/dialogs/CMakeLists.txt b/xbmc/input/joysticks/dialogs/CMakeLists.txt new file mode 100644 index 0000000..73adcec --- /dev/null +++ b/xbmc/input/joysticks/dialogs/CMakeLists.txt @@ -0,0 +1,5 @@ +set(SOURCES GUIDialogNewJoystick.cpp) + +set(HEADERS GUIDialogNewJoystick.h) + +core_add_library(input_joystick_dialogs) diff --git a/xbmc/input/joysticks/dialogs/GUIDialogNewJoystick.cpp b/xbmc/input/joysticks/dialogs/GUIDialogNewJoystick.cpp new file mode 100644 index 0000000..b66ce89 --- /dev/null +++ b/xbmc/input/joysticks/dialogs/GUIDialogNewJoystick.cpp @@ -0,0 +1,59 @@ +/* + * Copyright (C) 2016-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "GUIDialogNewJoystick.h" + +#include "ServiceBroker.h" +#include "guilib/GUIComponent.h" +#include "guilib/GUIWindowManager.h" +#include "guilib/WindowIDs.h" +#include "messaging/helpers/DialogHelper.h" +#include "settings/Settings.h" +#include "settings/SettingsComponent.h" + +using namespace KODI; +using namespace JOYSTICK; + +CGUIDialogNewJoystick::CGUIDialogNewJoystick() : CThread("NewJoystickDlg") +{ +} + +void CGUIDialogNewJoystick::ShowAsync() +{ + bool bShow = true; + + if (IsRunning()) + bShow = false; + else if (!CServiceBroker::GetSettingsComponent()->GetSettings()->GetBool( + CSettings::SETTING_INPUT_ASKNEWCONTROLLERS)) + bShow = false; + else if (CServiceBroker::GetGUI()->GetWindowManager().IsWindowActive( + WINDOW_DIALOG_GAME_CONTROLLERS, false)) + bShow = false; + + if (bShow) + Create(); +} + +void CGUIDialogNewJoystick::Process() +{ + using namespace MESSAGING::HELPERS; + + // "New controller detected" + // "A new controller has been detected. Configuration can be done at any time in "Settings -> + // System Settings -> Input". Would you like to configure it now?" + if (ShowYesNoDialogText(CVariant{35011}, CVariant{35012}) == DialogResponse::CHOICE_YES) + { + CServiceBroker::GetGUI()->GetWindowManager().ActivateWindow(WINDOW_DIALOG_GAME_CONTROLLERS); + } + else + { + CServiceBroker::GetSettingsComponent()->GetSettings()->SetBool( + CSettings::SETTING_INPUT_ASKNEWCONTROLLERS, false); + } +} diff --git a/xbmc/input/joysticks/dialogs/GUIDialogNewJoystick.h b/xbmc/input/joysticks/dialogs/GUIDialogNewJoystick.h new file mode 100644 index 0000000..334191f --- /dev/null +++ b/xbmc/input/joysticks/dialogs/GUIDialogNewJoystick.h @@ -0,0 +1,30 @@ +/* + * Copyright (C) 2016-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include "threads/Thread.h" + +namespace KODI +{ +namespace JOYSTICK +{ +class CGUIDialogNewJoystick : protected CThread +{ +public: + CGUIDialogNewJoystick(); + ~CGUIDialogNewJoystick() override = default; + + void ShowAsync(); + +protected: + // implementation of CThread + void Process() override; +}; +} // namespace JOYSTICK +} // namespace KODI diff --git a/xbmc/input/joysticks/generic/ButtonMapping.cpp b/xbmc/input/joysticks/generic/ButtonMapping.cpp new file mode 100644 index 0000000..665a233 --- /dev/null +++ b/xbmc/input/joysticks/generic/ButtonMapping.cpp @@ -0,0 +1,592 @@ +/* + * 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 "ButtonMapping.h" + +#include "ServiceBroker.h" +#include "games/controllers/Controller.h" +#include "games/controllers/ControllerManager.h" +#include "games/controllers/input/PhysicalFeature.h" +#include "input/IKeymap.h" +#include "input/InputTranslator.h" +#include "input/Key.h" +#include "input/joysticks/DriverPrimitive.h" +#include "input/joysticks/JoystickTranslator.h" +#include "input/joysticks/JoystickUtils.h" +#include "input/joysticks/interfaces/IButtonMap.h" +#include "input/joysticks/interfaces/IButtonMapper.h" +#include "utils/log.h" + +#include <algorithm> +#include <assert.h> +#include <cmath> + +using namespace KODI; +using namespace JOYSTICK; + +#define MAPPING_COOLDOWN_MS 50 // Guard against repeated input +#define AXIS_THRESHOLD 0.75f // Axis must exceed this value to be mapped +#define TRIGGER_DELAY_MS \ + 200 // Delay trigger detection to handle anomalous triggers with non-zero center + +// --- CPrimitiveDetector ------------------------------------------------------ + +CPrimitiveDetector::CPrimitiveDetector(CButtonMapping* buttonMapping) + : m_buttonMapping(buttonMapping) +{ +} + +bool CPrimitiveDetector::MapPrimitive(const CDriverPrimitive& primitive) +{ + if (primitive.IsValid()) + return m_buttonMapping->MapPrimitive(primitive); + + return false; +} + +// --- CButtonDetector --------------------------------------------------------- + +CButtonDetector::CButtonDetector(CButtonMapping* buttonMapping, unsigned int buttonIndex) + : CPrimitiveDetector(buttonMapping), m_buttonIndex(buttonIndex) +{ +} + +bool CButtonDetector::OnMotion(bool bPressed) +{ + if (bPressed) + return MapPrimitive(CDriverPrimitive(PRIMITIVE_TYPE::BUTTON, m_buttonIndex)); + + return false; +} + +// --- CHatDetector ------------------------------------------------------------ + +CHatDetector::CHatDetector(CButtonMapping* buttonMapping, unsigned int hatIndex) + : CPrimitiveDetector(buttonMapping), m_hatIndex(hatIndex) +{ +} + +bool CHatDetector::OnMotion(HAT_STATE state) +{ + return MapPrimitive(CDriverPrimitive(m_hatIndex, static_cast<HAT_DIRECTION>(state))); +} + +// --- CAxisDetector ----------------------------------------------------------- + +CAxisDetector::CAxisDetector(CButtonMapping* buttonMapping, + unsigned int axisIndex, + const AxisConfiguration& config) + : CPrimitiveDetector(buttonMapping), + m_axisIndex(axisIndex), + m_config(config), + m_state(AXIS_STATE::INACTIVE), + m_type(AXIS_TYPE::UNKNOWN), + m_initialPositionKnown(false), + m_initialPosition(0.0f), + m_initialPositionChanged(false) +{ +} + +bool CAxisDetector::OnMotion(float position) +{ + DetectType(position); + + if (m_type != AXIS_TYPE::UNKNOWN) + { + // Update position if this axis is an anomalous trigger + if (m_type == AXIS_TYPE::OFFSET) + position = (position - m_config.center) / m_config.range; + + // Reset state if position crosses zero + if (m_state == AXIS_STATE::MAPPED) + { + SEMIAXIS_DIRECTION activatedDir = m_activatedPrimitive.SemiAxisDirection(); + SEMIAXIS_DIRECTION newDir = CJoystickTranslator::PositionToSemiAxisDirection(position); + + if (activatedDir != newDir) + m_state = AXIS_STATE::INACTIVE; + } + + // Check if axis has become activated + if (m_state == AXIS_STATE::INACTIVE) + { + if (std::abs(position) >= AXIS_THRESHOLD) + m_state = AXIS_STATE::ACTIVATED; + + if (m_state == AXIS_STATE::ACTIVATED) + { + // Range is set later for anomalous triggers + m_activatedPrimitive = + CDriverPrimitive(m_axisIndex, m_config.center, + CJoystickTranslator::PositionToSemiAxisDirection(position), 1); + m_activationTimeMs = std::chrono::steady_clock::now(); + } + } + } + + return true; +} + +void CAxisDetector::ProcessMotion() +{ + // Process newly-activated axis + if (m_state == AXIS_STATE::ACTIVATED) + { + // Ignore anomalous triggers for a bit so we can detect the full range + bool bIgnore = false; + if (m_type == AXIS_TYPE::OFFSET) + { + auto now = std::chrono::steady_clock::now(); + auto duration = + std::chrono::duration_cast<std::chrono::milliseconds>(now - m_activationTimeMs); + + if (duration.count() < TRIGGER_DELAY_MS) + bIgnore = true; + } + + if (!bIgnore) + { + // Update driver primitive's range if we're mapping an anomalous trigger + if (m_type == AXIS_TYPE::OFFSET) + { + m_activatedPrimitive = + CDriverPrimitive(m_activatedPrimitive.Index(), m_activatedPrimitive.Center(), + m_activatedPrimitive.SemiAxisDirection(), m_config.range); + } + + // Map primitive + if (!MapPrimitive(m_activatedPrimitive)) + { + if (m_type == AXIS_TYPE::OFFSET) + CLog::Log(LOGDEBUG, "Mapping offset axis {} failed", m_axisIndex); + else + CLog::Log(LOGDEBUG, "Mapping normal axis {} failed", m_axisIndex); + } + + m_state = AXIS_STATE::MAPPED; + } + } +} + +void CAxisDetector::SetEmitted(const CDriverPrimitive& activePrimitive) +{ + m_state = AXIS_STATE::MAPPED; + m_activatedPrimitive = activePrimitive; +} + +void CAxisDetector::DetectType(float position) +{ + // Some platforms don't report a value until the axis is first changed. + // Detection relies on an initial value, so this axis will be disabled until + // the user begins button mapping again. + if (m_config.bLateDiscovery) + return; + + // Update range if a range of > 1 is observed + if (std::abs(position - m_config.center) > 1.0f) + m_config.range = 2; + + if (m_type != AXIS_TYPE::UNKNOWN) + return; + + if (m_config.bKnown) + { + if (m_config.center == 0) + m_type = AXIS_TYPE::NORMAL; + else + m_type = AXIS_TYPE::OFFSET; + } + + if (m_type != AXIS_TYPE::UNKNOWN) + return; + + if (!m_initialPositionKnown) + { + m_initialPositionKnown = true; + m_initialPosition = position; + } + + if (position != m_initialPosition) + m_initialPositionChanged = true; + + if (m_initialPositionChanged) + { + // Calculate center based on initial position. + if (m_initialPosition < -0.5f) + { + m_config.center = -1; + m_type = AXIS_TYPE::OFFSET; + CLog::Log(LOGDEBUG, "Anomalous trigger detected on axis {} with center {}", m_axisIndex, + m_config.center); + } + else if (m_initialPosition > 0.5f) + { + m_config.center = 1; + m_type = AXIS_TYPE::OFFSET; + CLog::Log(LOGDEBUG, "Anomalous trigger detected on axis {} with center {}", m_axisIndex, + m_config.center); + } + else + { + m_type = AXIS_TYPE::NORMAL; + CLog::Log(LOGDEBUG, "Normal axis detected on axis {}", m_axisIndex); + } + } +} + +// --- CKeyDetector --------------------------------------------------------- + +CKeyDetector::CKeyDetector(CButtonMapping* buttonMapping, XBMCKey keycode) + : CPrimitiveDetector(buttonMapping), m_keycode(keycode) +{ +} + +bool CKeyDetector::OnMotion(bool bPressed) +{ + if (bPressed) + return MapPrimitive(CDriverPrimitive(m_keycode)); + + return false; +} + +// --- CMouseButtonDetector ---------------------------------------------------- + +CMouseButtonDetector::CMouseButtonDetector(CButtonMapping* buttonMapping, + MOUSE::BUTTON_ID buttonIndex) + : CPrimitiveDetector(buttonMapping), m_buttonIndex(buttonIndex) +{ +} + +bool CMouseButtonDetector::OnMotion(bool bPressed) +{ + if (bPressed) + return MapPrimitive(CDriverPrimitive(m_buttonIndex)); + + return false; +} + +// --- CPointerDetector -------------------------------------------------------- + +CPointerDetector::CPointerDetector(CButtonMapping* buttonMapping) + : CPrimitiveDetector(buttonMapping) +{ +} + +bool CPointerDetector::OnMotion(int x, int y) +{ + if (!m_bStarted) + { + m_bStarted = true; + m_startX = x; + m_startY = y; + m_frameCount = 0; + } + + if (m_frameCount++ >= MIN_FRAME_COUNT) + { + int dx = x - m_startX; + int dy = y - m_startY; + + INPUT::INTERCARDINAL_DIRECTION dir = GetPointerDirection(dx, dy); + + CDriverPrimitive primitive(static_cast<RELATIVE_POINTER_DIRECTION>(dir)); + if (primitive.IsValid()) + { + if (MapPrimitive(primitive)) + m_bStarted = false; + } + } + + return true; +} + +KODI::INPUT::INTERCARDINAL_DIRECTION CPointerDetector::GetPointerDirection(int x, int y) +{ + using namespace INPUT; + + // Translate from left-handed coordinate system to right-handed coordinate system + y *= -1; + + return CInputTranslator::VectorToIntercardinalDirection(static_cast<float>(x), + static_cast<float>(y)); +} + +// --- CButtonMapping ---------------------------------------------------------- + +CButtonMapping::CButtonMapping(IButtonMapper* buttonMapper, IButtonMap* buttonMap, IKeymap* keymap) + : m_buttonMapper(buttonMapper), m_buttonMap(buttonMap), m_keymap(keymap), m_frameCount(0) +{ + assert(m_buttonMapper != nullptr); + assert(m_buttonMap != nullptr); + + // Make sure axes mapped to Select are centered before they can be mapped. + // This ensures that they are not immediately mapped to the first button. + if (m_keymap) + { + using namespace GAME; + + CControllerManager& controllerManager = CServiceBroker::GetGameControllerManager(); + ControllerPtr controller = controllerManager.GetController(m_keymap->ControllerID()); + + const auto& features = controller->Features(); + for (const auto& feature : features) + { + bool bIsSelectAction = false; + + const auto& actions = + m_keymap->GetActions(CJoystickUtils::MakeKeyName(feature.Name())).actions; + if (!actions.empty() && actions.begin()->actionId == ACTION_SELECT_ITEM) + bIsSelectAction = true; + + if (!bIsSelectAction) + continue; + + CDriverPrimitive primitive; + if (!m_buttonMap->GetScalar(feature.Name(), primitive)) + continue; + + if (primitive.Type() != PRIMITIVE_TYPE::SEMIAXIS) + continue; + + // Set initial config, as detection will fail because axis is already activated + AxisConfiguration axisConfig; + axisConfig.bKnown = true; + axisConfig.center = primitive.Center(); + axisConfig.range = primitive.Range(); + + GetAxis(primitive.Index(), static_cast<float>(primitive.Center()), axisConfig) + .SetEmitted(primitive); + } + } +} + +bool CButtonMapping::OnButtonMotion(unsigned int buttonIndex, bool bPressed) +{ + if (!m_buttonMapper->AcceptsPrimitive(PRIMITIVE_TYPE::BUTTON)) + return false; + + return GetButton(buttonIndex).OnMotion(bPressed); +} + +bool CButtonMapping::OnHatMotion(unsigned int hatIndex, HAT_STATE state) +{ + if (!m_buttonMapper->AcceptsPrimitive(PRIMITIVE_TYPE::HAT)) + return false; + + return GetHat(hatIndex).OnMotion(state); +} + +bool CButtonMapping::OnAxisMotion(unsigned int axisIndex, + float position, + int center, + unsigned int range) +{ + if (!m_buttonMapper->AcceptsPrimitive(PRIMITIVE_TYPE::SEMIAXIS)) + return false; + + return GetAxis(axisIndex, position).OnMotion(position); +} + +void CButtonMapping::OnInputFrame(void) +{ + for (auto& axis : m_axes) + axis.second.ProcessMotion(); + + m_buttonMapper->OnEventFrame(m_buttonMap, IsMapping()); + + m_frameCount++; +} + +bool CButtonMapping::OnKeyPress(const CKey& key) +{ + if (!m_buttonMapper->AcceptsPrimitive(PRIMITIVE_TYPE::KEY)) + return false; + + return GetKey(static_cast<XBMCKey>(key.GetKeycode())).OnMotion(true); +} + +bool CButtonMapping::OnPosition(int x, int y) +{ + if (!m_buttonMapper->AcceptsPrimitive(PRIMITIVE_TYPE::RELATIVE_POINTER)) + return false; + + return GetPointer().OnMotion(x, y); +} + +bool CButtonMapping::OnButtonPress(MOUSE::BUTTON_ID button) +{ + if (!m_buttonMapper->AcceptsPrimitive(PRIMITIVE_TYPE::MOUSE_BUTTON)) + return false; + + return GetMouseButton(button).OnMotion(true); +} + +void CButtonMapping::OnButtonRelease(MOUSE::BUTTON_ID button) +{ + if (!m_buttonMapper->AcceptsPrimitive(PRIMITIVE_TYPE::MOUSE_BUTTON)) + return; + + GetMouseButton(button).OnMotion(false); +} + +void CButtonMapping::SaveButtonMap() +{ + m_buttonMap->SaveButtonMap(); +} + +void CButtonMapping::ResetIgnoredPrimitives() +{ + std::vector<CDriverPrimitive> empty; + m_buttonMap->SetIgnoredPrimitives(empty); +} + +void CButtonMapping::RevertButtonMap() +{ + m_buttonMap->RevertButtonMap(); +} + +bool CButtonMapping::MapPrimitive(const CDriverPrimitive& primitive) +{ + bool bHandled = false; + + if (m_buttonMap->IsIgnored(primitive)) + { + bHandled = true; + } + else + { + auto now = std::chrono::steady_clock::now(); + + bool bTimeoutElapsed = true; + + if (m_buttonMapper->NeedsCooldown()) + bTimeoutElapsed = (now >= m_lastAction + std::chrono::milliseconds(MAPPING_COOLDOWN_MS)); + + if (bTimeoutElapsed) + { + bHandled = m_buttonMapper->MapPrimitive(m_buttonMap, m_keymap, primitive); + + if (bHandled) + m_lastAction = std::chrono::steady_clock::now(); + } + else + { + auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(now - m_lastAction); + + CLog::Log(LOGDEBUG, "Button mapping: rapid input after {}ms dropped for profile \"{}\"", + duration.count(), m_buttonMapper->ControllerID()); + bHandled = true; + } + } + + return bHandled; +} + +bool CButtonMapping::IsMapping() const +{ + for (auto itAxis : m_axes) + { + if (itAxis.second.IsMapping()) + return true; + } + + return false; +} + +CButtonDetector& CButtonMapping::GetButton(unsigned int buttonIndex) +{ + auto itButton = m_buttons.find(buttonIndex); + + if (itButton == m_buttons.end()) + { + m_buttons.insert(std::make_pair(buttonIndex, CButtonDetector(this, buttonIndex))); + itButton = m_buttons.find(buttonIndex); + } + + return itButton->second; +} + +CHatDetector& CButtonMapping::GetHat(unsigned int hatIndex) +{ + auto itHat = m_hats.find(hatIndex); + + if (itHat == m_hats.end()) + { + m_hats.insert(std::make_pair(hatIndex, CHatDetector(this, hatIndex))); + itHat = m_hats.find(hatIndex); + } + + return itHat->second; +} + +CAxisDetector& CButtonMapping::GetAxis( + unsigned int axisIndex, + float position, + const AxisConfiguration& initialConfig /* = AxisConfiguration() */) +{ + auto itAxis = m_axes.find(axisIndex); + + if (itAxis == m_axes.end()) + { + AxisConfiguration config(initialConfig); + + if (m_frameCount >= 2) + { + config.bLateDiscovery = true; + OnLateDiscovery(axisIndex); + } + + // Report axis + CLog::Log(LOGDEBUG, "Axis {} discovered at position {:.4f} after {} frames", axisIndex, + position, static_cast<unsigned long>(m_frameCount)); + + m_axes.insert(std::make_pair(axisIndex, CAxisDetector(this, axisIndex, config))); + itAxis = m_axes.find(axisIndex); + } + + return itAxis->second; +} + +CKeyDetector& CButtonMapping::GetKey(XBMCKey keycode) +{ + auto itKey = m_keys.find(keycode); + + if (itKey == m_keys.end()) + { + m_keys.insert(std::make_pair(keycode, CKeyDetector(this, keycode))); + itKey = m_keys.find(keycode); + } + + return itKey->second; +} + +CMouseButtonDetector& CButtonMapping::GetMouseButton(MOUSE::BUTTON_ID buttonIndex) +{ + auto itButton = m_mouseButtons.find(buttonIndex); + + if (itButton == m_mouseButtons.end()) + { + m_mouseButtons.insert(std::make_pair(buttonIndex, CMouseButtonDetector(this, buttonIndex))); + itButton = m_mouseButtons.find(buttonIndex); + } + + return itButton->second; +} + +CPointerDetector& CButtonMapping::GetPointer() +{ + if (!m_pointer) + m_pointer.reset(new CPointerDetector(this)); + + return *m_pointer; +} + +void CButtonMapping::OnLateDiscovery(unsigned int axisIndex) +{ + m_buttonMapper->OnLateAxis(m_buttonMap, axisIndex); +} diff --git a/xbmc/input/joysticks/generic/ButtonMapping.h b/xbmc/input/joysticks/generic/ButtonMapping.h new file mode 100644 index 0000000..3f76767 --- /dev/null +++ b/xbmc/input/joysticks/generic/ButtonMapping.h @@ -0,0 +1,393 @@ +/* + * 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/DriverPrimitive.h" +#include "input/joysticks/interfaces/IButtonMapCallback.h" +#include "input/joysticks/interfaces/IDriverHandler.h" +#include "input/keyboard/interfaces/IKeyboardDriverHandler.h" +#include "input/mouse/MouseTypes.h" +#include "input/mouse/interfaces/IMouseDriverHandler.h" + +#include <chrono> +#include <map> +#include <memory> +#include <stdint.h> + +class IKeymap; + +namespace KODI +{ +namespace JOYSTICK +{ +class CButtonMapping; +class IButtonMap; +class IButtonMapper; + +/*! + * \brief Detects and dispatches mapping events + * + * A mapping event usually occurs when a driver primitive is pressed or + * exceeds a certain threshold. + * + * Detection can be quite complicated due to driver bugs, so each type of + * driver primitive is given its own detector class inheriting from this one. + */ +class CPrimitiveDetector +{ +protected: + CPrimitiveDetector(CButtonMapping* buttonMapping); + + /*! + * \brief Dispatch a mapping event + * + * \return True if the primitive was mapped, false otherwise + */ + bool MapPrimitive(const CDriverPrimitive& primitive); + +private: + CButtonMapping* const m_buttonMapping; +}; + +/*! + * \brief Detects when a button should be mapped + */ +class CButtonDetector : public CPrimitiveDetector +{ +public: + CButtonDetector(CButtonMapping* buttonMapping, unsigned int buttonIndex); + + /*! + * \brief Button state has been updated + * + * \param bPressed The new state + * + * \return True if this press was handled, false if it should fall through + * to the next driver handler + */ + bool OnMotion(bool bPressed); + +private: + // Construction parameters + const unsigned int m_buttonIndex; +}; + +/*! + * \brief Detects when a D-pad direction should be mapped + */ +class CHatDetector : public CPrimitiveDetector +{ +public: + CHatDetector(CButtonMapping* buttonMapping, unsigned int hatIndex); + + /*! + * \brief Hat state has been updated + * + * \param state The new state + * + * \return True if state is a cardinal direction, false otherwise + */ + bool OnMotion(HAT_STATE state); + +private: + // Construction parameters + const unsigned int m_hatIndex; +}; + +struct AxisConfiguration +{ + bool bKnown = false; + int center = 0; + unsigned int range = 1; + bool bLateDiscovery = false; +}; + +/*! + * \brief Detects when an axis should be mapped + */ +class CAxisDetector : public CPrimitiveDetector +{ +public: + CAxisDetector(CButtonMapping* buttonMapping, + unsigned int axisIndex, + const AxisConfiguration& config); + + /*! + * \brief Axis state has been updated + * + * \param position The new state + * + * \return Always true - axis motion events are always absorbed while button mapping + */ + bool OnMotion(float position); + + /*! + * \brief Called once per frame + * + * If an axis was activated, the button mapping command will be emitted + * here. + */ + void ProcessMotion(); + + /*! + * \brief Check if the axis was mapped and is still in motion + * + * \return True between when the axis is mapped and when it crosses zero + */ + bool IsMapping() const { return m_state == AXIS_STATE::MAPPED; } + + /*! + * \brief Set the state such that this axis has generated a mapping event + * + * If an axis is mapped to the Select action, it may be pressed when button + * mapping begins. This function is used to indicate that the axis shouldn't + * be mapped until after it crosses zero again. + */ + void SetEmitted(const CDriverPrimitive& activePrimitive); + +private: + enum class AXIS_STATE + { + /*! + * \brief Axis is inactive (position is less than threshold) + */ + INACTIVE, + + /*! + * \brief Axis is activated (position has exceeded threshold) + */ + ACTIVATED, + + /*! + * \brief Axis has generated a mapping event, but has not been centered yet + */ + MAPPED, + }; + + enum class AXIS_TYPE + { + /*! + * \brief Axis type is initially unknown + */ + UNKNOWN, + + /*! + * \brief Axis is centered about 0 + * + * - If the axis is an analog stick, it can travel to -1 or +1. + * - If the axis is a pressure-sensitive button or a normal trigger, + * it can travel to +1. + * - If the axis is a DirectInput trigger, then it is possible that two + * triggers can be on the same axis in opposite directions. + * - Normally, D-pads appear as a hat or four buttons. However, some + * D-pads are reported as two axes that can have the discrete values + * -1, 0 or 1. This is called a "discrete D-pad". + */ + NORMAL, + + /*! + * \brief Axis is centered about -1 or 1 + * + * - On OSX, with the cocoa driver, triggers are centered about -1 and + * travel to +1. In this case, the range is 2 and the direction is + * positive. + * - The author of SDL has observed triggers centered at +1 and travel + * to 0. In this case, the range is 1 and the direction is negative. + */ + OFFSET, + }; + + void DetectType(float position); + + // Construction parameters + const unsigned int m_axisIndex; + AxisConfiguration m_config; // mutable + + // State variables + AXIS_STATE m_state; + CDriverPrimitive m_activatedPrimitive; + AXIS_TYPE m_type; + bool m_initialPositionKnown; // set to true on first motion + float m_initialPosition; // set to position of first motion + bool m_initialPositionChanged; // set to true when position differs from the initial position + std::chrono::time_point<std::chrono::steady_clock> + m_activationTimeMs; // only used to delay anomalous trigger mapping to detect full range +}; + +/*! + * \brief Detects when a keyboard key should be mapped + */ +class CKeyDetector : public CPrimitiveDetector +{ +public: + CKeyDetector(CButtonMapping* buttonMapping, XBMCKey keycode); + + /*! + * \brief Key state has been updated + * + * \param bPressed The new state + * + * \return True if this press was handled, false if it should fall through + * to the next driver handler + */ + bool OnMotion(bool bPressed); + +private: + // Construction parameters + const XBMCKey m_keycode; +}; + +/*! + * \brief Detects when a mouse button should be mapped + */ +class CMouseButtonDetector : public CPrimitiveDetector +{ +public: + CMouseButtonDetector(CButtonMapping* buttonMapping, MOUSE::BUTTON_ID buttonIndex); + + /*! + * \brief Button state has been updated + * + * \param bPressed The new state + * + * \return True if this press was handled, false if it should fall through + * to the next driver handler + */ + bool OnMotion(bool bPressed); + +private: + // Construction parameters + const MOUSE::BUTTON_ID m_buttonIndex; +}; + +/*! + * \brief Detects when a mouse button should be mapped + */ +class CPointerDetector : public CPrimitiveDetector +{ +public: + CPointerDetector(CButtonMapping* buttonMapping); + + /*! + * \brief Pointer position has been updated + * + * \param x The new x coordinate + * \param y The new y coordinate + * + * \return Always true - pointer motion events are always absorbed while + * button mapping + */ + bool OnMotion(int x, int y); + +private: + // Utility function + static INPUT::INTERCARDINAL_DIRECTION GetPointerDirection(int x, int y); + + static const unsigned int MIN_FRAME_COUNT = 10; + + // State variables + bool m_bStarted = false; + int m_startX = 0; + int m_startY = 0; + unsigned int m_frameCount = 0; +}; + +/*! + * \ingroup joystick + * \brief Generic implementation of a class that provides button mapping by + * translating driver events to button mapping commands + * + * Button mapping commands are invoked instantly for buttons and hats. + * + * Button mapping commands are deferred for a short while after an axis is + * activated, and only one button mapping command will be invoked per + * activation. + */ +class CButtonMapping : public IDriverHandler, + public KEYBOARD::IKeyboardDriverHandler, + public MOUSE::IMouseDriverHandler, + public IButtonMapCallback +{ +public: + /*! + * \brief Constructor for CButtonMapping + * + * \param buttonMapper Carries out button-mapping commands using <buttonMap> + * \param buttonMap The button map given to <buttonMapper> on each command + */ + CButtonMapping(IButtonMapper* buttonMapper, IButtonMap* buttonMap, IKeymap* keymap); + + ~CButtonMapping() override = default; + + // implementation of IDriverHandler + bool OnButtonMotion(unsigned int buttonIndex, bool bPressed) override; + bool OnHatMotion(unsigned int hatIndex, HAT_STATE state) override; + bool OnAxisMotion(unsigned int axisIndex, + float position, + int center, + unsigned int range) override; + void OnInputFrame() override; + + // implementation of IKeyboardDriverHandler + bool OnKeyPress(const CKey& key) override; + void OnKeyRelease(const CKey& key) override {} + + // implementation of IMouseDriverHandler + bool OnPosition(int x, int y) override; + bool OnButtonPress(MOUSE::BUTTON_ID button) override; + void OnButtonRelease(MOUSE::BUTTON_ID button) override; + + // implementation of IButtonMapCallback + void SaveButtonMap() override; + void ResetIgnoredPrimitives() override; + void RevertButtonMap() override; + + /*! + * \brief Process the primitive mapping command + * + * First, this function checks if the input should be dropped. This can + * happen if the input is ignored or the cooldown period is active. If the + * input is dropped, this returns true with no effect, effectively absorbing + * the input. Otherwise, the mapping command is sent to m_buttonMapper. + * + * \param primitive The primitive being mapped + * \return True if the mapping command was handled, false otherwise + */ + bool MapPrimitive(const CDriverPrimitive& primitive); + +private: + bool IsMapping() const; + + void OnLateDiscovery(unsigned int axisIndex); + + CButtonDetector& GetButton(unsigned int buttonIndex); + CHatDetector& GetHat(unsigned int hatIndex); + CAxisDetector& GetAxis(unsigned int axisIndex, + float position, + const AxisConfiguration& initialConfig = AxisConfiguration()); + CKeyDetector& GetKey(XBMCKey keycode); + CMouseButtonDetector& GetMouseButton(MOUSE::BUTTON_ID buttonIndex); + CPointerDetector& GetPointer(); + + // Construction parameters + IButtonMapper* const m_buttonMapper; + IButtonMap* const m_buttonMap; + IKeymap* const m_keymap; + + std::map<unsigned int, CButtonDetector> m_buttons; + std::map<unsigned int, CHatDetector> m_hats; + std::map<unsigned int, CAxisDetector> m_axes; + std::map<XBMCKey, CKeyDetector> m_keys; + std::map<MOUSE::BUTTON_ID, CMouseButtonDetector> m_mouseButtons; + std::unique_ptr<CPointerDetector> m_pointer; + std::chrono::time_point<std::chrono::steady_clock> m_lastAction; + uint64_t m_frameCount; +}; +} // namespace JOYSTICK +} // namespace KODI diff --git a/xbmc/input/joysticks/generic/CMakeLists.txt b/xbmc/input/joysticks/generic/CMakeLists.txt new file mode 100644 index 0000000..f44258a --- /dev/null +++ b/xbmc/input/joysticks/generic/CMakeLists.txt @@ -0,0 +1,11 @@ +set(SOURCES ButtonMapping.cpp + DriverReceiving.cpp + FeatureHandling.cpp + InputHandling.cpp) + +set(HEADERS ButtonMapping.h + DriverReceiving.h + FeatureHandling.h + InputHandling.h) + +core_add_library(input_joystick_generic) diff --git a/xbmc/input/joysticks/generic/DriverReceiving.cpp b/xbmc/input/joysticks/generic/DriverReceiving.cpp new file mode 100644 index 0000000..bf52f4f --- /dev/null +++ b/xbmc/input/joysticks/generic/DriverReceiving.cpp @@ -0,0 +1,38 @@ +/* + * Copyright (C) 2016-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "DriverReceiving.h" + +#include "input/joysticks/DriverPrimitive.h" +#include "input/joysticks/interfaces/IButtonMap.h" +#include "input/joysticks/interfaces/IDriverReceiver.h" + +using namespace KODI; +using namespace JOYSTICK; + +CDriverReceiving::CDriverReceiving(IDriverReceiver* receiver, IButtonMap* buttonMap) + : m_receiver(receiver), m_buttonMap(buttonMap) +{ +} + +bool CDriverReceiving::SetRumbleState(const FeatureName& feature, float magnitude) +{ + bool bHandled = false; + + if (m_receiver != nullptr && m_buttonMap != nullptr) + { + CDriverPrimitive primitive; + if (m_buttonMap->GetScalar(feature, primitive)) + { + if (primitive.Type() == PRIMITIVE_TYPE::MOTOR) + bHandled = m_receiver->SetMotorState(primitive.Index(), magnitude); + } + } + + return bHandled; +} diff --git a/xbmc/input/joysticks/generic/DriverReceiving.h b/xbmc/input/joysticks/generic/DriverReceiving.h new file mode 100644 index 0000000..758b560 --- /dev/null +++ b/xbmc/input/joysticks/generic/DriverReceiving.h @@ -0,0 +1,46 @@ +/* + * Copyright (C) 2016-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include "input/joysticks/JoystickTypes.h" +#include "input/joysticks/interfaces/IInputReceiver.h" + +#include <map> + +namespace KODI +{ +namespace JOYSTICK +{ +class IDriverReceiver; +class IButtonMap; + +/*! + * \ingroup joystick + * \brief Class to translate input events from higher-level features to driver primitives + * + * A button map is used to translate controller features to driver primitives. + * The button map has been abstracted away behind the IButtonMap interface + * so that it can be provided by an add-on. + */ +class CDriverReceiving : public IInputReceiver +{ +public: + CDriverReceiving(IDriverReceiver* receiver, IButtonMap* buttonMap); + + ~CDriverReceiving() override = default; + + // implementation of IInputReceiver + bool SetRumbleState(const FeatureName& feature, float magnitude) override; + +private: + IDriverReceiver* const m_receiver; + IButtonMap* const m_buttonMap; +}; +} // namespace JOYSTICK +} // namespace KODI diff --git a/xbmc/input/joysticks/generic/FeatureHandling.cpp b/xbmc/input/joysticks/generic/FeatureHandling.cpp new file mode 100644 index 0000000..639ae5b --- /dev/null +++ b/xbmc/input/joysticks/generic/FeatureHandling.cpp @@ -0,0 +1,551 @@ +/* + * 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 "FeatureHandling.h" + +#include "ServiceBroker.h" +#include "games/controllers/Controller.h" +#include "games/controllers/ControllerManager.h" +#include "input/joysticks/DriverPrimitive.h" +#include "input/joysticks/interfaces/IButtonMap.h" +#include "input/joysticks/interfaces/IInputHandler.h" +#include "utils/log.h" + +#include <vector> + +using namespace KODI; +using namespace JOYSTICK; + +#define ANALOG_DIGITAL_THRESHOLD 0.5f +#define DISCRETE_ANALOG_RAMPUP_TIME_MS 1500 +#define DISCRETE_ANALOG_START_VALUE 0.3f + +// --- CJoystickFeature -------------------------------------------------------- + +CJoystickFeature::CJoystickFeature(const FeatureName& name, + IInputHandler* handler, + IButtonMap* buttonMap) + : m_name(name), + m_handler(handler), + m_buttonMap(buttonMap), + m_bEnabled(m_handler->HasFeature(name)) +{ +} + +bool CJoystickFeature::AcceptsInput(bool bActivation) +{ + bool bAcceptsInput = false; + + if (m_bEnabled) + { + if (m_handler->AcceptsInput(m_name)) + bAcceptsInput = true; + } + + return bAcceptsInput; +} + +void CJoystickFeature::ResetMotion() +{ + m_motionStartTimeMs = {}; +} + +void CJoystickFeature::StartMotion() +{ + m_motionStartTimeMs = std::chrono::steady_clock::now(); +} + +bool CJoystickFeature::InMotion() const +{ + return m_motionStartTimeMs.time_since_epoch().count() > 0; +} + +unsigned int CJoystickFeature::MotionTimeMs() const +{ + if (!InMotion()) + return 0; + + auto now = std::chrono::steady_clock::now(); + auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(now - m_motionStartTimeMs); + + return duration.count(); +} + +// --- CScalarFeature ---------------------------------------------------------- + +CScalarFeature::CScalarFeature(const FeatureName& name, + IInputHandler* handler, + IButtonMap* buttonMap) + : CJoystickFeature(name, handler, buttonMap), + m_bDigitalState(false), + m_analogState(0.0f), + m_bActivated(false), + m_bDiscrete(true) +{ + GAME::ControllerPtr controller = + CServiceBroker::GetGameControllerManager().GetController(handler->ControllerID()); + if (controller) + m_inputType = controller->GetInputType(name); +} + +bool CScalarFeature::OnDigitalMotion(const CDriverPrimitive& source, bool bPressed) +{ + // Feature must accept input to be considered handled + bool bHandled = AcceptsInput(bPressed); + + if (m_inputType == INPUT_TYPE::DIGITAL) + bHandled &= OnDigitalMotion(bPressed); + else if (m_inputType == INPUT_TYPE::ANALOG) + bHandled &= OnAnalogMotion(bPressed ? 1.0f : 0.0f); + + return bHandled; +} + +bool CScalarFeature::OnAnalogMotion(const CDriverPrimitive& source, float magnitude) +{ + // Update activated status + if (magnitude > 0.0f) + m_bActivated = true; + + // Update discrete status + if (magnitude != 0.0f && magnitude != 1.0f) + m_bDiscrete = false; + + // Feature must accept input to be considered handled + bool bHandled = AcceptsInput(magnitude > 0.0f); + + if (m_inputType == INPUT_TYPE::DIGITAL) + bHandled &= OnDigitalMotion(magnitude >= ANALOG_DIGITAL_THRESHOLD); + else if (m_inputType == INPUT_TYPE::ANALOG) + bHandled &= OnAnalogMotion(magnitude); + + return bHandled; +} + +void CScalarFeature::ProcessMotions(void) +{ + if (m_inputType == INPUT_TYPE::DIGITAL && m_bDigitalState) + ProcessDigitalMotion(); + else if (m_inputType == INPUT_TYPE::ANALOG) + ProcessAnalogMotion(); +} + +bool CScalarFeature::OnDigitalMotion(bool bPressed) +{ + bool bHandled = false; + + if (m_bDigitalState != bPressed) + { + m_bDigitalState = bPressed; + + // Motion is initiated in ProcessMotions() + ResetMotion(); + + bHandled = m_bInitialPressHandled = m_handler->OnButtonPress(m_name, bPressed); + + if (m_bDigitalState) + CLog::Log(LOGDEBUG, "FEATURE [ {} ] on {} pressed ({})", m_name, m_handler->ControllerID(), + bHandled ? "handled" : "ignored"); + else + CLog::Log(LOGDEBUG, "FEATURE [ {} ] on {} released", m_name, m_handler->ControllerID()); + } + else if (m_bDigitalState) + { + bHandled = m_bInitialPressHandled; + } + + return bHandled; +} + +bool CScalarFeature::OnAnalogMotion(float magnitude) +{ + const bool bActivated = (magnitude != 0.0f); + + // Update analog state + m_analogState = magnitude; + + // Update motion time + if (!bActivated) + ResetMotion(); + else if (!InMotion()) + StartMotion(); + + // Log activation/deactivation + if (m_bDigitalState != bActivated) + { + m_bDigitalState = bActivated; + CLog::Log(LOGDEBUG, "FEATURE [ {} ] on {} {}", m_name, m_handler->ControllerID(), + bActivated ? "activated" : "deactivated"); + } + + return true; +} + +void CScalarFeature::ProcessDigitalMotion() +{ + if (!InMotion()) + { + // Button was just pressed, record start time and exit (button press event + // was already sent this frame) + StartMotion(); + } + else + { + // Button has been pressed more than one event frame + const unsigned int elapsed = MotionTimeMs(); + m_handler->OnButtonHold(m_name, elapsed); + } +} + +void CScalarFeature::ProcessAnalogMotion() +{ + float magnitude = m_analogState; + + // Calculate time elapsed since motion began + unsigned int elapsed = MotionTimeMs(); + + // If analog value is discrete, ramp up magnitude + if (m_bActivated && m_bDiscrete) + { + if (elapsed < DISCRETE_ANALOG_RAMPUP_TIME_MS) + { + magnitude *= static_cast<float>(elapsed) / DISCRETE_ANALOG_RAMPUP_TIME_MS; + if (magnitude < DISCRETE_ANALOG_START_VALUE) + magnitude = DISCRETE_ANALOG_START_VALUE; + } + } + + m_handler->OnButtonMotion(m_name, magnitude, elapsed); +} + +// --- CAxisFeature ------------------------------------------------------------ + +CAxisFeature::CAxisFeature(const FeatureName& name, IInputHandler* handler, IButtonMap* buttonMap) + : CJoystickFeature(name, handler, buttonMap), m_state(0.0f) +{ +} + +bool CAxisFeature::OnDigitalMotion(const CDriverPrimitive& source, bool bPressed) +{ + return OnAnalogMotion(source, bPressed ? 1.0f : 0.0f); +} + +void CAxisFeature::ProcessMotions(void) +{ + const float newState = m_axis.GetPosition(); + + const bool bActivated = (newState != 0.0f); + + if (!AcceptsInput(bActivated)) + return; + + const bool bWasActivated = (m_state != 0.0f); + + if (!bActivated && bWasActivated) + CLog::Log(LOGDEBUG, "Feature [ {} ] on {} deactivated", m_name, m_handler->ControllerID()); + else if (bActivated && !bWasActivated) + { + CLog::Log(LOGDEBUG, "Feature [ {} ] on {} activated {}", m_name, m_handler->ControllerID(), + newState > 0.0f ? "positive" : "negative"); + } + + if (bActivated || bWasActivated) + { + m_state = newState; + + unsigned int motionTimeMs = 0; + + if (bActivated) + { + if (!InMotion()) + StartMotion(); + else + motionTimeMs = MotionTimeMs(); + } + else + ResetMotion(); + + switch (m_buttonMap->GetFeatureType(m_name)) + { + case FEATURE_TYPE::WHEEL: + m_handler->OnWheelMotion(m_name, newState, motionTimeMs); + break; + case FEATURE_TYPE::THROTTLE: + m_handler->OnThrottleMotion(m_name, newState, motionTimeMs); + break; + default: + break; + } + } +} + +// --- CWheel ------------------------------------------------------------------ + +CWheel::CWheel(const FeatureName& name, IInputHandler* handler, IButtonMap* buttonMap) + : CAxisFeature(name, handler, buttonMap) +{ +} + +bool CWheel::OnAnalogMotion(const CDriverPrimitive& source, float magnitude) +{ + WHEEL_DIRECTION direction = WHEEL_DIRECTION::NONE; + + std::vector<WHEEL_DIRECTION> dirs = { + WHEEL_DIRECTION::RIGHT, + WHEEL_DIRECTION::LEFT, + }; + + CDriverPrimitive primitive; + for (auto dir : dirs) + { + if (m_buttonMap->GetWheel(m_name, dir, primitive) && primitive == source) + { + direction = dir; + break; + } + } + + // Feature must accept input to be considered handled + bool bHandled = AcceptsInput(magnitude > 0.0f); + + switch (direction) + { + case WHEEL_DIRECTION::RIGHT: + m_axis.SetPositiveDistance(magnitude); + break; + case WHEEL_DIRECTION::LEFT: + m_axis.SetNegativeDistance(magnitude); + break; + default: + // Just in case, avoid sticking + m_axis.Reset(); + break; + } + + return bHandled; +} + +// --- CThrottle --------------------------------------------------------------- + +CThrottle::CThrottle(const FeatureName& name, IInputHandler* handler, IButtonMap* buttonMap) + : CAxisFeature(name, handler, buttonMap) +{ +} + +bool CThrottle::OnAnalogMotion(const CDriverPrimitive& source, float magnitude) +{ + THROTTLE_DIRECTION direction = THROTTLE_DIRECTION::NONE; + + std::vector<THROTTLE_DIRECTION> dirs = { + THROTTLE_DIRECTION::UP, + THROTTLE_DIRECTION::DOWN, + }; + + CDriverPrimitive primitive; + for (auto dir : dirs) + { + if (m_buttonMap->GetThrottle(m_name, dir, primitive) && primitive == source) + { + direction = dir; + break; + } + } + + // Feature must accept input to be considered handled + bool bHandled = AcceptsInput(magnitude > 0.0f); + + switch (direction) + { + case THROTTLE_DIRECTION::UP: + m_axis.SetPositiveDistance(magnitude); + break; + case THROTTLE_DIRECTION::DOWN: + m_axis.SetNegativeDistance(magnitude); + break; + default: + // Just in case, avoid sticking + m_axis.Reset(); + break; + } + + return bHandled; +} + +// --- CAnalogStick ------------------------------------------------------------ + +CAnalogStick::CAnalogStick(const FeatureName& name, IInputHandler* handler, IButtonMap* buttonMap) + : CJoystickFeature(name, handler, buttonMap), m_vertState(0.0f), m_horizState(0.0f) +{ +} + +bool CAnalogStick::OnDigitalMotion(const CDriverPrimitive& source, bool bPressed) +{ + return OnAnalogMotion(source, bPressed ? 1.0f : 0.0f); +} + +bool CAnalogStick::OnAnalogMotion(const CDriverPrimitive& source, float magnitude) +{ + ANALOG_STICK_DIRECTION direction = ANALOG_STICK_DIRECTION::NONE; + + std::vector<ANALOG_STICK_DIRECTION> dirs = { + ANALOG_STICK_DIRECTION::UP, + ANALOG_STICK_DIRECTION::DOWN, + ANALOG_STICK_DIRECTION::RIGHT, + ANALOG_STICK_DIRECTION::LEFT, + }; + + CDriverPrimitive primitive; + for (auto dir : dirs) + { + if (m_buttonMap->GetAnalogStick(m_name, dir, primitive) && primitive == source) + { + direction = dir; + break; + } + } + + // Feature must accept input to be considered handled + bool bHandled = AcceptsInput(magnitude > 0.0f); + + switch (direction) + { + case ANALOG_STICK_DIRECTION::UP: + m_vertAxis.SetPositiveDistance(magnitude); + break; + case ANALOG_STICK_DIRECTION::DOWN: + m_vertAxis.SetNegativeDistance(magnitude); + break; + case ANALOG_STICK_DIRECTION::RIGHT: + m_horizAxis.SetPositiveDistance(magnitude); + break; + case ANALOG_STICK_DIRECTION::LEFT: + m_horizAxis.SetNegativeDistance(magnitude); + break; + default: + // Just in case, avoid sticking + m_vertAxis.Reset(); + m_horizAxis.Reset(); + break; + } + + return bHandled; +} + +void CAnalogStick::ProcessMotions(void) +{ + const float newVertState = m_vertAxis.GetPosition(); + const float newHorizState = m_horizAxis.GetPosition(); + + const bool bActivated = (newVertState != 0.0f || newHorizState != 0.0f); + + if (!AcceptsInput(bActivated)) + return; + + const bool bWasActivated = (m_vertState != 0.0f || m_horizState != 0.0f); + + if (bActivated ^ bWasActivated) + { + CLog::Log(LOGDEBUG, "Feature [ {} ] on {} {}", m_name, m_handler->ControllerID(), + bActivated ? "activated" : "deactivated"); + } + + if (bActivated || bWasActivated) + { + m_vertState = newVertState; + m_horizState = newHorizState; + + unsigned int motionTimeMs = 0; + + if (bActivated) + { + if (!InMotion()) + StartMotion(); + else + motionTimeMs = MotionTimeMs(); + } + else + { + ResetMotion(); + } + + m_handler->OnAnalogStickMotion(m_name, newHorizState, newVertState, motionTimeMs); + } +} + +// --- CAccelerometer ---------------------------------------------------------- + +CAccelerometer::CAccelerometer(const FeatureName& name, + IInputHandler* handler, + IButtonMap* buttonMap) + : CJoystickFeature(name, handler, buttonMap), + m_xAxisState(0.0f), + m_yAxisState(0.0f), + m_zAxisState(0.0f) +{ +} + +bool CAccelerometer::OnDigitalMotion(const CDriverPrimitive& source, bool bPressed) +{ + return OnAnalogMotion(source, bPressed ? 1.0f : 0.0f); +} + +bool CAccelerometer::OnAnalogMotion(const CDriverPrimitive& source, float magnitude) +{ + // Feature must accept input to be considered handled + bool bHandled = AcceptsInput(true); + + CDriverPrimitive positiveX; + CDriverPrimitive positiveY; + CDriverPrimitive positiveZ; + + m_buttonMap->GetAccelerometer(m_name, positiveX, positiveY, positiveZ); + + if (source == positiveX) + { + m_xAxis.SetPositiveDistance(magnitude); + } + else if (source == positiveY) + { + m_yAxis.SetPositiveDistance(magnitude); + } + else if (source == positiveZ) + { + m_zAxis.SetPositiveDistance(magnitude); + } + else + { + // Just in case, avoid sticking + m_xAxis.Reset(); + m_xAxis.Reset(); + m_yAxis.Reset(); + } + + return bHandled; +} + +void CAccelerometer::ProcessMotions(void) +{ + const float newXAxis = m_xAxis.GetPosition(); + const float newYAxis = m_yAxis.GetPosition(); + const float newZAxis = m_zAxis.GetPosition(); + + const bool bActivated = (newXAxis != 0.0f || newYAxis != 0.0f || newZAxis != 0.0f); + + if (!AcceptsInput(bActivated)) + return; + + const bool bWasActivated = (m_xAxisState != 0.0f || m_yAxisState != 0.0f || m_zAxisState != 0.0f); + + if (bActivated || bWasActivated) + { + m_xAxisState = newXAxis; + m_yAxisState = newYAxis; + m_zAxisState = newZAxis; + m_handler->OnAccelerometerMotion(m_name, newXAxis, newYAxis, newZAxis); + } +} diff --git a/xbmc/input/joysticks/generic/FeatureHandling.h b/xbmc/input/joysticks/generic/FeatureHandling.h new file mode 100644 index 0000000..1a42d5c --- /dev/null +++ b/xbmc/input/joysticks/generic/FeatureHandling.h @@ -0,0 +1,282 @@ +/* + * 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/JoystickTypes.h" + +#include <chrono> +#include <memory> + +namespace KODI +{ +namespace JOYSTICK +{ +class CDriverPrimitive; +class IInputHandler; +class IButtonMap; + +class CJoystickFeature; +using FeaturePtr = std::shared_ptr<CJoystickFeature>; + +/*! + * \ingroup joystick + * \brief Base class for joystick features + * + * See list of feature types in JoystickTypes.h. + */ +class CJoystickFeature +{ +public: + CJoystickFeature(const FeatureName& name, IInputHandler* handler, IButtonMap* buttonMap); + virtual ~CJoystickFeature() = default; + + /*! + * \brief A digital motion has occurred + * + * \param source The source of the motion. Must be digital (button or hat) + * \param bPressed True for press motion, false for release motion + * + * \return true if the motion was handled, false otherwise + */ + virtual bool OnDigitalMotion(const CDriverPrimitive& source, bool bPressed) = 0; + + /*! + * \brief An analog motion has occurred + * + * \param source The source of the motion. Must be a semiaxis + * \param magnitude The magnitude of the press or motion in the interval [0.0, 1.0] + * + * For semiaxes, the magnitude is the force or travel distance in the + * direction of the semiaxis. If the value is in the opposite direction, + * the magnitude is 0.0. + * + * For example, if the analog stick goes left, the negative semiaxis will + * have a value of 1.0 and the positive semiaxis will have a value of 0.0. + */ + virtual bool OnAnalogMotion(const CDriverPrimitive& source, float magnitude) = 0; + + /*! + * \brief Process the motions that have occurred since the last invocation + * + * This allows features with motion on multiple driver primitives to call + * their handler once all driver primitives are accounted for. + */ + virtual void ProcessMotions(void) = 0; + + /*! + * \brief Check if the input handler is accepting input + * + * \param bActivation True if the motion is activating (true or positive), + * false if the motion is deactivating (false or zero) + * + * \return True if input should be sent to the input handler, false otherwise + */ + bool AcceptsInput(bool bActivation); + +protected: + /*! + * \brief Reset motion timer + */ + void ResetMotion(); + + /*! + * \brief Start the motion timer + */ + void StartMotion(); + + /*! + * \brief Check if the feature is in motion + */ + bool InMotion() const; + + /*! + * \brief Get the time for which the feature has been in motion + */ + unsigned int MotionTimeMs() const; + + const FeatureName m_name; + IInputHandler* const m_handler; + IButtonMap* const m_buttonMap; + const bool m_bEnabled; + +private: + std::chrono::time_point<std::chrono::steady_clock> m_motionStartTimeMs; +}; + +class CScalarFeature : public CJoystickFeature +{ +public: + CScalarFeature(const FeatureName& name, IInputHandler* handler, IButtonMap* buttonMap); + ~CScalarFeature() override = default; + + // implementation of CJoystickFeature + bool OnDigitalMotion(const CDriverPrimitive& source, bool bPressed) override; + bool OnAnalogMotion(const CDriverPrimitive& source, float magnitude) override; + void ProcessMotions() override; + +private: + bool OnDigitalMotion(bool bPressed); + bool OnAnalogMotion(float magnitude); + + void ProcessDigitalMotion(); + void ProcessAnalogMotion(); + + // State variables + INPUT_TYPE m_inputType = INPUT_TYPE::UNKNOWN; + bool m_bDigitalState; + bool m_bInitialPressHandled = false; + + // Analog state variables + float m_analogState; // The current magnitude + float m_bActivated; // Set to true when first activated (magnitude > 0.0) + bool m_bDiscrete; // Set to false when a non-discrete axis is detected +}; + +/*! + * \ingroup joystick + * \brief Axis of a feature (analog stick, accelerometer, etc) + * + * Axes are composed of two driver primitives, one for the positive semiaxis + * and one for the negative semiaxis. + * + * This effectively means that an axis is two-dimensional, with each dimension + * either: + * + * - a digital value (0.0 or 1.0) + * - an analog value (continuous in the interval [0.0, 1.0]) + */ +class CFeatureAxis +{ +public: + CFeatureAxis(void) { Reset(); } + + /*! + * \brief Set value of positive axis + */ + void SetPositiveDistance(float distance) { m_positiveDistance = distance; } + + /*! + * \brief Set value of negative axis + */ + void SetNegativeDistance(float distance) { m_negativeDistance = distance; } + + /*! + * \brief Get the final value of this axis. + * + * This axis is two-dimensional, so we need to compress these into a single + * dimension. This is done by subtracting the negative from the positive. + * Some examples: + * + * Positive axis: 1.0 (User presses right or analog stick moves right) + * Negative axis: 0.0 + * ------------------- + * Pos - Neg: 1.0 (Emulated analog stick moves right) + * + * + * Positive axis: 0.0 + * Negative axis: 1.0 (User presses left or analog stick moves left) + * ------------------- + * Pos - Neg: -1.0 (Emulated analog stick moves left) + * + * + * Positive axis: 1.0 (User presses both buttons) + * Negative axis: 1.0 + * ------------------- + * Pos - Neg: 0.0 (Emulated analog stick is centered) + * + */ + float GetPosition(void) const { return m_positiveDistance - m_negativeDistance; } + + /*! + * \brief Reset both positive and negative values to zero + */ + void Reset(void) { m_positiveDistance = m_negativeDistance = 0.0f; } + +protected: + float m_positiveDistance; + float m_negativeDistance; +}; + +class CAxisFeature : public CJoystickFeature +{ +public: + CAxisFeature(const FeatureName& name, IInputHandler* handler, IButtonMap* buttonMap); + ~CAxisFeature() override = default; + + // partial implementation of CJoystickFeature + bool OnDigitalMotion(const CDriverPrimitive& source, bool bPressed) override; + void ProcessMotions() override; + +protected: + CFeatureAxis m_axis; + + float m_state; +}; + +class CWheel : public CAxisFeature +{ +public: + CWheel(const FeatureName& name, IInputHandler* handler, IButtonMap* buttonMap); + ~CWheel() override = default; + + // partial implementation of CJoystickFeature + bool OnAnalogMotion(const CDriverPrimitive& source, float magnitude) override; +}; + +class CThrottle : public CAxisFeature +{ +public: + CThrottle(const FeatureName& name, IInputHandler* handler, IButtonMap* buttonMap); + ~CThrottle() override = default; + + // partial implementation of CJoystickFeature + bool OnAnalogMotion(const CDriverPrimitive& source, float magnitude) override; +}; + +class CAnalogStick : public CJoystickFeature +{ +public: + CAnalogStick(const FeatureName& name, IInputHandler* handler, IButtonMap* buttonMap); + ~CAnalogStick() override = default; + + // implementation of CJoystickFeature + bool OnDigitalMotion(const CDriverPrimitive& source, bool bPressed) override; + bool OnAnalogMotion(const CDriverPrimitive& source, float magnitude) override; + void ProcessMotions() override; + +protected: + CFeatureAxis m_vertAxis; + CFeatureAxis m_horizAxis; + + float m_vertState; + float m_horizState; +}; + +class CAccelerometer : public CJoystickFeature +{ +public: + CAccelerometer(const FeatureName& name, IInputHandler* handler, IButtonMap* buttonMap); + ~CAccelerometer() override = default; + + // implementation of CJoystickFeature + bool OnDigitalMotion(const CDriverPrimitive& source, bool bPressed) override; + bool OnAnalogMotion(const CDriverPrimitive& source, float magnitude) override; + void ProcessMotions() override; + +protected: + CFeatureAxis m_xAxis; + CFeatureAxis m_yAxis; + CFeatureAxis m_zAxis; + + float m_xAxisState; + float m_yAxisState; + float m_zAxisState; +}; +} // namespace JOYSTICK +} // namespace KODI diff --git a/xbmc/input/joysticks/generic/InputHandling.cpp b/xbmc/input/joysticks/generic/InputHandling.cpp new file mode 100644 index 0000000..f6cae6d --- /dev/null +++ b/xbmc/input/joysticks/generic/InputHandling.cpp @@ -0,0 +1,179 @@ +/* + * 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 "InputHandling.h" + +#include "input/joysticks/DriverPrimitive.h" +#include "input/joysticks/JoystickUtils.h" +#include "input/joysticks/dialogs/GUIDialogNewJoystick.h" +#include "input/joysticks/interfaces/IButtonMap.h" +#include "input/joysticks/interfaces/IInputHandler.h" +#include "utils/log.h" + +#include <array> +#include <cmath> +#include <tuple> + +using namespace KODI; +using namespace JOYSTICK; + +CGUIDialogNewJoystick* const CInputHandling::m_dialog = new CGUIDialogNewJoystick; + +CInputHandling::CInputHandling(IInputHandler* handler, IButtonMap* buttonMap) + : m_handler(handler), m_buttonMap(buttonMap) +{ +} + +CInputHandling::~CInputHandling(void) = default; + +bool CInputHandling::OnButtonMotion(unsigned int buttonIndex, bool bPressed) +{ + return OnDigitalMotion(CDriverPrimitive(PRIMITIVE_TYPE::BUTTON, buttonIndex), bPressed); +} + +bool CInputHandling::OnHatMotion(unsigned int hatIndex, HAT_STATE state) +{ + bool bHandled = false; + + bHandled |= + OnDigitalMotion(CDriverPrimitive(hatIndex, HAT_DIRECTION::UP), state & HAT_DIRECTION::UP); + bHandled |= OnDigitalMotion(CDriverPrimitive(hatIndex, HAT_DIRECTION::RIGHT), + state & HAT_DIRECTION::RIGHT); + bHandled |= + OnDigitalMotion(CDriverPrimitive(hatIndex, HAT_DIRECTION::DOWN), state & HAT_DIRECTION::DOWN); + bHandled |= + OnDigitalMotion(CDriverPrimitive(hatIndex, HAT_DIRECTION::LEFT), state & HAT_DIRECTION::LEFT); + + return bHandled; +} + +bool CInputHandling::OnAxisMotion(unsigned int axisIndex, + float position, + int center, + unsigned int range) +{ + bool bHandled = false; + + if (center != 0) + { + float translatedPostion = std::min((position - center) / range, 1.0f); + + // Calculate the direction the trigger travels from the center point + SEMIAXIS_DIRECTION dir; + if (center > 0) + dir = SEMIAXIS_DIRECTION::NEGATIVE; + else + dir = SEMIAXIS_DIRECTION::POSITIVE; + + CDriverPrimitive offsetSemiaxis(axisIndex, center, dir, range); + + bHandled = OnAnalogMotion(offsetSemiaxis, translatedPostion); + } + else + { + CDriverPrimitive positiveSemiaxis(axisIndex, 0, SEMIAXIS_DIRECTION::POSITIVE, 1); + CDriverPrimitive negativeSemiaxis(axisIndex, 0, SEMIAXIS_DIRECTION::NEGATIVE, 1); + + bHandled |= OnAnalogMotion(positiveSemiaxis, position > 0.0f ? position : 0.0f); + bHandled |= OnAnalogMotion(negativeSemiaxis, position < 0.0f ? -position : 0.0f); + } + + return bHandled; +} + +void CInputHandling::OnInputFrame(void) +{ + // Handle driver input + for (auto& it : m_features) + it.second->ProcessMotions(); + + // Handle higher-level controller input + m_handler->OnInputFrame(); +} + +bool CInputHandling::OnDigitalMotion(const CDriverPrimitive& source, bool bPressed) +{ + bool bHandled = false; + + FeatureName featureName; + if (m_buttonMap->GetFeature(source, featureName)) + { + auto it = m_features.find(featureName); + if (it == m_features.end()) + { + FeaturePtr feature(CreateFeature(featureName)); + if (feature) + std::tie(it, std::ignore) = m_features.insert({featureName, std::move(feature)}); + } + + if (it != m_features.end()) + bHandled = it->second->OnDigitalMotion(source, bPressed); + } + else if (bPressed) + { + // If button didn't resolve to a feature, check if the button map is empty + // and ask the user if they would like to start mapping the controller + if (m_buttonMap->IsEmpty()) + { + CLog::Log(LOGDEBUG, "Empty button map detected for {}", m_buttonMap->ControllerID()); + m_dialog->ShowAsync(); + } + } + + return bHandled; +} + +bool CInputHandling::OnAnalogMotion(const CDriverPrimitive& source, float magnitude) +{ + bool bHandled = false; + + FeatureName featureName; + if (m_buttonMap->GetFeature(source, featureName)) + { + auto it = m_features.find(featureName); + if (it == m_features.end()) + { + FeaturePtr feature(CreateFeature(featureName)); + if (feature) + std::tie(it, std::ignore) = m_features.insert({featureName, std::move(feature)}); + } + + if (it != m_features.end()) + bHandled = it->second->OnAnalogMotion(source, magnitude); + } + + return bHandled; +} + +CJoystickFeature* CInputHandling::CreateFeature(const FeatureName& featureName) +{ + CJoystickFeature* feature = nullptr; + + switch (m_buttonMap->GetFeatureType(featureName)) + { + case FEATURE_TYPE::SCALAR: + { + feature = new CScalarFeature(featureName, m_handler, m_buttonMap); + break; + } + case FEATURE_TYPE::ANALOG_STICK: + { + feature = new CAnalogStick(featureName, m_handler, m_buttonMap); + break; + } + case FEATURE_TYPE::ACCELEROMETER: + { + feature = new CAccelerometer(featureName, m_handler, m_buttonMap); + break; + } + default: + break; + } + + return feature; +} diff --git a/xbmc/input/joysticks/generic/InputHandling.h b/xbmc/input/joysticks/generic/InputHandling.h new file mode 100644 index 0000000..772d9d1 --- /dev/null +++ b/xbmc/input/joysticks/generic/InputHandling.h @@ -0,0 +1,69 @@ +/* + * 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 "FeatureHandling.h" +#include "input/joysticks/JoystickTypes.h" +#include "input/joysticks/interfaces/IDriverHandler.h" + +#include <map> + +namespace KODI +{ +namespace JOYSTICK +{ +class CDriverPrimitive; +class CGUIDialogNewJoystick; +class IInputHandler; +class IButtonMap; + +/*! + * \ingroup joystick + * \brief Class to translate input from the driver into higher-level features + * + * Raw driver input arrives for three elements: buttons, hats and axes. When + * driver input is handled by this class, it translates the raw driver + * elements into physical joystick features, such as buttons, analog sticks, + * etc. + * + * A button map is used to translate driver primitives to controller features. + * The button map has been abstracted away behind the IButtonMap + * interface so that it can be provided by an add-on. + */ +class CInputHandling : public IDriverHandler +{ +public: + CInputHandling(IInputHandler* handler, IButtonMap* buttonMap); + + ~CInputHandling() override; + + // implementation of IDriverHandler + bool OnButtonMotion(unsigned int buttonIndex, bool bPressed) override; + bool OnHatMotion(unsigned int hatIndex, HAT_STATE state) override; + bool OnAxisMotion(unsigned int axisIndex, + float position, + int center, + unsigned int range) override; + void OnInputFrame() override; + +private: + bool OnDigitalMotion(const CDriverPrimitive& source, bool bPressed); + bool OnAnalogMotion(const CDriverPrimitive& source, float magnitude); + + CJoystickFeature* CreateFeature(const FeatureName& featureName); + + IInputHandler* const m_handler; + IButtonMap* const m_buttonMap; + + std::map<FeatureName, FeaturePtr> m_features; + + static CGUIDialogNewJoystick* const m_dialog; +}; +} // namespace JOYSTICK +} // namespace KODI diff --git a/xbmc/input/joysticks/interfaces/IButtonMap.h b/xbmc/input/joysticks/interfaces/IButtonMap.h new file mode 100644 index 0000000..0b4b7d5 --- /dev/null +++ b/xbmc/input/joysticks/interfaces/IButtonMap.h @@ -0,0 +1,343 @@ +/* + * 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/DriverPrimitive.h" +#include "input/joysticks/JoystickTypes.h" + +#include <string> +#include <vector> + +namespace KODI +{ +namespace JOYSTICK +{ +/*! + * \ingroup joystick + * \brief Button map interface to translate between the driver's raw + * button/hat/axis elements and physical joystick features. + * + * \sa IButtonMapper + */ +class IButtonMap +{ +public: + virtual ~IButtonMap() = default; + + /*! + * \brief The add-on ID of the game controller associated with this button map + * + * The controller ID provided by the implementation serves as the context + * for the feature names below. + * + * \return The ID of this button map's game controller add-on + */ + virtual std::string ControllerID(void) const = 0; + + /*! + * \brief The Location of the peripheral associated with this button map + * + * \return The peripheral's location + */ + virtual std::string Location(void) const = 0; + + /*! + * \brief Load the button map into memory + * + * \return True if button map is ready to start translating buttons, false otherwise + */ + virtual bool Load(void) = 0; + + /*! + * \brief Reset the button map to its defaults, or clear button map if no defaults + */ + virtual void Reset(void) = 0; + + /*! + * \brief Check if the button map is empty + * + * \return True if the button map is empty, false if it has features + */ + virtual bool IsEmpty(void) const = 0; + + /*! + * \brief Get the ID of the controller profile that best represents the + * appearance of the peripheral + * + * \return The controller ID, or empty if the appearance is unknown + */ + virtual std::string GetAppearance() const = 0; + + /*! + * \brief Set the ID of the controller that best represents the appearance + * of the peripheral + * + * \param controllerId The controller ID, or empty to unset the appearance + * + * \return True if the appearance was set, false on error + */ + virtual bool SetAppearance(const std::string& controllerId) const = 0; + + /*! + * \brief Get the feature associated with a driver primitive + * + * Multiple primitives can be mapped to the same feature. For example, + * analog sticks use one primitive for each direction. + * + * \param primitive The driver primitive + * \param feature The name of the resolved joystick feature, or + * invalid if false is returned + * + * \return True if the driver primitive is associated with a feature, false otherwise + */ + virtual bool GetFeature(const CDriverPrimitive& primitive, FeatureName& feature) = 0; + + /*! + * \brief Get the type of the feature for the given name + * + * \param feature The feature to look up + * + * \return The feature's type + */ + virtual FEATURE_TYPE GetFeatureType(const FeatureName& feature) = 0; + + /*! + * \brief Get the driver primitive for a scalar feature + * + * When a feature can be represented by a single driver primitive, it is + * called a scalar feature. + * + * - This includes buttons and triggers, because they can be mapped to a + * single button/hat/semiaxis + * + * - This does not include analog sticks, because they require two axes + * and four driver primitives (one for each semiaxis) + * + * \param feature Must be a scalar feature (a feature that only + * requires a single driver primitive) + * \param primitive The resolved driver primitive + * + * \return True if the feature resolved to a driver primitive, false if the + * feature didn't resolve or isn't a scalar feature + */ + virtual bool GetScalar(const FeatureName& feature, CDriverPrimitive& primitive) = 0; + + /*! + * \brief Add or update a scalar feature + * + * \param feature Must be a scalar feature + * \param primitive The feature's driver primitive + * + * \return True if the feature was updated, false if the feature is + * unchanged or failure occurs + */ + virtual void AddScalar(const FeatureName& feature, const CDriverPrimitive& primitive) = 0; + + /*! + * \brief Get an analog stick direction from the button map + * + * \param feature Must be an analog stick or this will return false + * \param direction The direction whose primitive is to be retrieved + * \param[out] primitive The primitive mapped to the specified direction + * + * \return True if the feature and direction resolved to a driver primitive + */ + virtual bool GetAnalogStick(const FeatureName& feature, + ANALOG_STICK_DIRECTION direction, + CDriverPrimitive& primitive) = 0; + + /*! + * \brief Add or update an analog stick direction + * + * \param feature Must be an analog stick or this will return false + * \param direction The direction being mapped + * \param primitive The driver primitive for the specified analog stick and direction + * + * \return True if the analog stick was updated, false otherwise + */ + virtual void AddAnalogStick(const FeatureName& feature, + ANALOG_STICK_DIRECTION direction, + const CDriverPrimitive& primitive) = 0; + + /*! + * \brief Get a relative pointer direction from the button map + * + * \param feature Must be a relative pointer stick or this will return false + * \param direction The direction whose primitive is to be retrieved + * \param[out] primitive The primitive mapped to the specified direction + * + * \return True if the feature and direction resolved to a driver primitive + */ + virtual bool GetRelativePointer(const FeatureName& feature, + RELATIVE_POINTER_DIRECTION direction, + CDriverPrimitive& primitive) = 0; + + /*! + * \brief Add or update a relative pointer direction + * + * \param feature Must be a relative pointer or this will return false + * \param direction The direction being mapped + * \param primitive The driver primitive for the specified analog stick and direction + * + * \return True if the analog stick was updated, false otherwise + */ + virtual void AddRelativePointer(const FeatureName& feature, + RELATIVE_POINTER_DIRECTION direction, + const CDriverPrimitive& primitive) = 0; + + /*! + * \brief Get an accelerometer from the button map + * + * \param feature Must be an accelerometer or this will return false + * \param positiveX The semiaxis mapped to the positive X direction (possibly unknown) + * \param positiveY The semiaxis mapped to the positive Y direction (possibly unknown) + * \param positiveZ The semiaxis mapped to the positive Z direction (possibly unknown) + * + * \return True if the feature resolved to an accelerometer with at least 1 known axis + */ + virtual bool GetAccelerometer(const FeatureName& feature, + CDriverPrimitive& positiveX, + CDriverPrimitive& positiveY, + CDriverPrimitive& positiveZ) = 0; + + /*! + * \brief Get or update an accelerometer + * + * \param feature Must be an accelerometer or this will return false + * \param positiveX The semiaxis corresponding to the positive X direction + * \param positiveY The semiaxis corresponding to the positive Y direction + * \param positiveZ The semiaxis corresponding to the positive Z direction + * + * The driver primitives must be mapped to a semiaxis or this function will fail. + * + * \return True if the accelerometer was updated, false if unchanged or failure occurred + */ + virtual void AddAccelerometer(const FeatureName& feature, + const CDriverPrimitive& positiveX, + const CDriverPrimitive& positiveY, + const CDriverPrimitive& positiveZ) = 0; + + /*! + * \brief Get a wheel direction from the button map + * + * \param feature Must be a wheel or this will return false + * \param direction The direction whose primitive is to be retrieved + * \param[out] primitive The primitive mapped to the specified direction + * + * \return True if the feature and direction resolved to a driver primitive + */ + virtual bool GetWheel(const FeatureName& feature, + WHEEL_DIRECTION direction, + CDriverPrimitive& primitive) = 0; + + /*! + * \brief Add or update a wheel direction + * + * \param feature Must be a wheel or this will return false + * \param direction The direction being mapped + * \param primitive The driver primitive for the specified analog stick and direction + * + * \return True if the analog stick was updated, false otherwise + */ + virtual void AddWheel(const FeatureName& feature, + WHEEL_DIRECTION direction, + const CDriverPrimitive& primitive) = 0; + + /*! + * \brief Get a throttle direction from the button map + * + * \param feature Must be a throttle or this will return false + * \param direction The direction whose primitive is to be retrieved + * \param[out] primitive The primitive mapped to the specified direction + * + * \return True if the feature and direction resolved to a driver primitive + */ + virtual bool GetThrottle(const FeatureName& feature, + THROTTLE_DIRECTION direction, + CDriverPrimitive& primitive) = 0; + + /*! + * \brief Add or update a throttle direction + * + * \param feature Must be a throttle or this will return false + * \param direction The direction being mapped + * \param primitive The driver primitive for the specified analog stick and direction + * + * \return True if the analog stick was updated, false otherwise + */ + virtual void AddThrottle(const FeatureName& feature, + THROTTLE_DIRECTION direction, + const CDriverPrimitive& primitive) = 0; + + /*! + * \brief Get the driver primitive for a keyboard key + * + * \param feature Must be a key + * \param primitive The resolved driver primitive + * + * \return True if the feature resolved to a driver primitive, false if the + * feature didn't resolve or isn't a scalar feature + */ + virtual bool GetKey(const FeatureName& feature, CDriverPrimitive& primitive) = 0; + + /*! + * \brief Add or update a key + * + * \param feature Must be a key + * \param primitive The feature's driver primitive + * + * \return True if the feature was updated, false if the feature is + * unchanged or failure occurs + */ + virtual void AddKey(const FeatureName& feature, const CDriverPrimitive& primitive) = 0; + + /*! + * \brief Set a list of driver primitives to be ignored + * + * This is necessary to prevent features from interfering with the button + * mapping process. This includes accelerometers, as well as PS4 triggers + * which send both a button press and an analog value. + * + * \param primitives The driver primitives to be ignored + */ + virtual void SetIgnoredPrimitives(const std::vector<CDriverPrimitive>& primitives) = 0; + + /*! + * \brief Check if a primitive is in the list of primitives to be ignored + * + * \param primitive The primitive to check + * + * \return True if the primitive should be ignored in the mapping process + */ + virtual bool IsIgnored(const CDriverPrimitive& primitive) = 0; + + /*! + * \brief Get the properties of an axis + * + * \param axisIndex The index of the axis to check + * \param center[out] The center, if known + * \param range[out] The range, if known + * + * \return True if the properties are known, false otherwise + */ + virtual bool GetAxisProperties(unsigned int axisIndex, int& center, unsigned int& range) = 0; + + /*! + * \brief Save the button map + */ + virtual void SaveButtonMap() = 0; + + /*! + * \brief Revert changes to the button map since the last time it was loaded + * or committed to disk + */ + virtual void RevertButtonMap() = 0; +}; +} // namespace JOYSTICK +} // namespace KODI diff --git a/xbmc/input/joysticks/interfaces/IButtonMapCallback.h b/xbmc/input/joysticks/interfaces/IButtonMapCallback.h new file mode 100644 index 0000000..40744f8 --- /dev/null +++ b/xbmc/input/joysticks/interfaces/IButtonMapCallback.h @@ -0,0 +1,47 @@ +/* + * Copyright (C) 2016-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +namespace KODI +{ +namespace JOYSTICK +{ +/*! + * \brief Interface for handling button maps + */ +class IButtonMapCallback +{ +public: + virtual ~IButtonMapCallback() = default; + + /*! + * \brief Save the button map + */ + virtual void SaveButtonMap() = 0; + + /*! + * \brief Clear the list of ignored driver primitives + * + * Called if the user begins capturing primitives to be ignored, and + * no primitives are captured before the dialog is accepted by the user. + * + * In this case, the button mapper won't have been given access to the + * button map, so a callback is needed to indicate that no primitives were + * captured and the user accepted this. + */ + virtual void ResetIgnoredPrimitives() = 0; + + /*! + * \brief Revert changes to the button map since the last time it was loaded + * or committed to disk + */ + virtual void RevertButtonMap() = 0; +}; +} // namespace JOYSTICK +} // namespace KODI diff --git a/xbmc/input/joysticks/interfaces/IButtonMapper.h b/xbmc/input/joysticks/interfaces/IButtonMapper.h new file mode 100644 index 0000000..d0784df --- /dev/null +++ b/xbmc/input/joysticks/interfaces/IButtonMapper.h @@ -0,0 +1,124 @@ +/* + * 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/JoystickTypes.h" + +#include <map> +#include <string> + +class IKeymap; + +namespace KODI +{ +namespace JOYSTICK +{ +class CDriverPrimitive; +class IButtonMap; +class IButtonMapCallback; + +/*! + * \ingroup joystick + * \brief Button mapper interface to assign the driver's raw button/hat/axis + * elements to physical joystick features using a provided button map. + * + * \sa IButtonMap + */ +class IButtonMapper +{ +public: + IButtonMapper() = default; + + virtual ~IButtonMapper() = default; + + /*! + * \brief The add-on ID of the game controller associated with this button mapper + * + * \return The ID of the add-on extending kodi.game.controller + */ + virtual std::string ControllerID(void) const = 0; + + /*! + * \brief Return true if the button mapper wants a cooldown between button + * mapping commands + * + * \return True to only send button mapping commands that occur after a small + * timeout from the previous command. + */ + virtual bool NeedsCooldown(void) const = 0; + + /*! + * \brief Return true if the button mapper accepts primitives of the given type + * + * \param type The primitive type + * + * \return True if the button mapper can map the primitive type, false otherwise + */ + virtual bool AcceptsPrimitive(PRIMITIVE_TYPE type) const = 0; + + /*! + * \brief Handle button/hat press or axis threshold + * + * \param buttonMap The button map being manipulated + * \param keymap An interface capable of translating features to Kodi actions + * \param primitive The driver primitive + * + * Called in the same thread as \ref IButtonMapper::OnFrame. + * + * \return True if driver primitive was mapped to a feature + */ + virtual bool MapPrimitive(IButtonMap* buttonMap, + IKeymap* keyMap, + const CDriverPrimitive& primitive) = 0; + + /*! + * \brief Called once per event frame to notify the implementation of motion status + * + * \param buttonMap The button map passed to MapPrimitive() (shall not be modified) + * \param bMotion True if a previously-mapped axis is still in motion + * + * This allows the implementer to wait for an axis to be centered before + * allowing it to be used as Kodi input. + * + * If mapping finishes on an axis, then the axis will still be pressed and + * sending input every frame when the mapping ends. For example, when the + * right analog stick is the last feature to be mapped, it is still pressed + * when mapping ends and immediately sends Volume Down actions. + * + * The fix is to allow implementers to wait until all axes are motionless + * before detaching themselves. + * + * Called in the same thread as \ref IButtonMapper::MapPrimitive. + */ + virtual void OnEventFrame(const IButtonMap* buttonMap, bool bMotion) = 0; + + /*! + * \brief Called when an axis has been detected after mapping began + * + * \param axisIndex The index of the axis being discovered + * + * Some joystick drivers don't report an initial value for analog axes. + * + * Called in the same thread as \ref IButtonMapper::MapPrimitive. + */ + virtual void OnLateAxis(const IButtonMap* buttonMap, unsigned int axisIndex) = 0; + + // Button map callback interface + void SetButtonMapCallback(const std::string& deviceLocation, IButtonMapCallback* callback) + { + m_callbacks[deviceLocation] = callback; + } + void ResetButtonMapCallbacks(void) { m_callbacks.clear(); } + std::map<std::string, IButtonMapCallback*>& ButtonMapCallbacks(void) { return m_callbacks; } + +private: + std::map<std::string, IButtonMapCallback*> m_callbacks; // Device location -> callback +}; +} // namespace JOYSTICK +} // namespace KODI diff --git a/xbmc/input/joysticks/interfaces/IButtonSequence.h b/xbmc/input/joysticks/interfaces/IButtonSequence.h new file mode 100644 index 0000000..5c642e6 --- /dev/null +++ b/xbmc/input/joysticks/interfaces/IButtonSequence.h @@ -0,0 +1,31 @@ +/* + * Copyright (C) 2016-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include "input/joysticks/JoystickTypes.h" + +namespace KODI +{ +namespace JOYSTICK +{ +class IButtonSequence +{ +public: + virtual ~IButtonSequence() = default; + + virtual bool OnButtonPress(const FeatureName& feature) = 0; + + /*! + * \brief Returns true if a sequence is being captured to prevent input + * from falling through to the application + */ + virtual bool IsCapturing() = 0; +}; +} // namespace JOYSTICK +} // namespace KODI diff --git a/xbmc/input/joysticks/interfaces/IDriverHandler.h b/xbmc/input/joysticks/interfaces/IDriverHandler.h new file mode 100644 index 0000000..48e4da5 --- /dev/null +++ b/xbmc/input/joysticks/interfaces/IDriverHandler.h @@ -0,0 +1,77 @@ +/* + * Copyright (C) 2014-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include "input/joysticks/JoystickTypes.h" + +namespace KODI +{ +namespace JOYSTICK +{ +/*! + * \brief Interface defining methods to handle joystick events for raw driver + * elements (buttons, hats, axes) + */ +class IDriverHandler +{ +public: + virtual ~IDriverHandler() = default; + + /*! + * \brief Handle button motion + * + * \param buttonIndex The index of the button as reported by the driver + * \param bPressed true for press motion, false for release motion + * + * \return True if a press was handled, false otherwise + */ + virtual bool OnButtonMotion(unsigned int buttonIndex, bool bPressed) = 0; + + /*! + * \brief Handle hat motion + * + * \param hatIndex The index of the hat as reported by the driver + * \param state The direction the hat is now being pressed + * + * \return True if the new direction was handled, false otherwise + */ + virtual bool OnHatMotion(unsigned int hatIndex, HAT_STATE state) = 0; + + /*! + * \brief Handle axis motion + * + * If a joystick feature requires multiple axes (analog sticks, accelerometers), + * they can be buffered for later processing. + * + * \param axisIndex The index of the axis as reported by the driver + * \param position The position of the axis in the closed interval [-1.0, 1.0] + * \param center The center point of the axis (either -1, 0 or 1) + * \param range The maximum distance the axis can move (either 1 or 2) + * + * \return True if the motion was handled, false otherwise + */ + virtual bool OnAxisMotion(unsigned int axisIndex, + float position, + int center, + unsigned int range) = 0; + + /*! + * \brief Handle buffered input motion for features that require multiple axes + * + * OnInputFrame() is called at the end of the frame when all axis motions + * have been reported. This has several uses, including: + * + * - Combining multiple axes into a single analog stick or accelerometer event + * - Imitating an analog feature with a digital button so that events can be + * dispatched every frame. + */ + virtual void OnInputFrame(void) = 0; +}; +} // namespace JOYSTICK +} // namespace KODI diff --git a/xbmc/input/joysticks/interfaces/IDriverReceiver.h b/xbmc/input/joysticks/interfaces/IDriverReceiver.h new file mode 100644 index 0000000..2a4ff6c --- /dev/null +++ b/xbmc/input/joysticks/interfaces/IDriverReceiver.h @@ -0,0 +1,35 @@ +/* + * Copyright (C) 2016-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +namespace KODI +{ +namespace JOYSTICK +{ +/*! + * \ingroup joystick + * \brief Interface for sending input events to joystick drivers + */ +class IDriverReceiver +{ +public: + virtual ~IDriverReceiver() = default; + + /*! + * \brief Set the value of a rumble motor + * + * \param motorIndex The driver index of the motor to rumble + * \param magnitude The motor's new magnitude of vibration in the closed interval [0, 1] + * + * \return True if the event was handled otherwise false + */ + virtual bool SetMotorState(unsigned int motorIndex, float magnitude) = 0; +}; +} // namespace JOYSTICK +} // namespace KODI diff --git a/xbmc/input/joysticks/interfaces/IInputHandler.h b/xbmc/input/joysticks/interfaces/IInputHandler.h new file mode 100644 index 0000000..2ddbf5c --- /dev/null +++ b/xbmc/input/joysticks/interfaces/IInputHandler.h @@ -0,0 +1,169 @@ +/* + * 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/JoystickTypes.h" + +#include <string> + +namespace KODI +{ +namespace JOYSTICK +{ +class IInputReceiver; + +/*! + * \ingroup joystick + * \brief Interface for handling input events for game controllers + */ +class IInputHandler +{ +public: + virtual ~IInputHandler() = default; + + /*! + * \brief The add-on ID of the game controller associated with this input handler + * + * \return The ID of the add-on extending kodi.game.controller + */ + virtual std::string ControllerID(void) const = 0; + + /*! + * \brief Return true if the input handler accepts the given feature + * + * \param feature A feature belonging to the controller specified by ControllerID() + * + * \return True if the feature is used for input, false otherwise + */ + virtual bool HasFeature(const FeatureName& feature) const = 0; + + /*! + * \brief Return true if the input handler is currently accepting input for the + * given feature + * + * \param feature A feature belonging to the controller specified by ControllerID() + * + * \return True if the feature is currently accepting input, false otherwise + * + * This does not prevent the input events from being called, but can return + * false to indicate that input wasn't handled for the specified feature. + */ + virtual bool AcceptsInput(const FeatureName& feature) const = 0; + + /*! + * \brief A digital button has been pressed or released + * + * \param feature The feature being pressed + * \param bPressed True if pressed, false if released + * + * \return True if the event was handled otherwise false + */ + virtual bool OnButtonPress(const FeatureName& feature, bool bPressed) = 0; + + /*! + * \brief A digital button has been pressed for more than one event frame + * + * \param feature The feature being held + * \param holdTimeMs The time elapsed since the initial press (ms) + * + * If OnButtonPress() returns true for the initial press, then this callback + * is invoked on subsequent frames until the button is released. + */ + virtual void OnButtonHold(const FeatureName& feature, unsigned int holdTimeMs) = 0; + + /*! + * \brief An analog button (trigger or a pressure-sensitive button) has changed state + * + * \param feature The feature changing state + * \param magnitude The button pressure or trigger travel distance in the + * closed interval [0, 1] + * \param motionTimeMs The time elapsed since the magnitude was 0 + * + * \return True if the event was handled otherwise false + */ + virtual bool OnButtonMotion(const FeatureName& feature, + float magnitude, + unsigned int motionTimeMs) = 0; + + /*! + * \brief An analog stick has moved + * + * \param feature The analog stick being moved + * \param x The x coordinate in the closed interval [-1, 1] + * \param y The y coordinate in the closed interval [-1, 1] + * \param motionTimeMs The time elapsed since this analog stick was centered, + * or 0 if the analog stick is centered + * + * \return True if the event was handled otherwise false + */ + virtual bool OnAnalogStickMotion(const FeatureName& feature, + float x, + float y, + unsigned int motionTimeMs) = 0; + + /*! + * \brief An accelerometer's state has changed + * + * \param feature The accelerometer being accelerated + * \param x The x coordinate in the closed interval [-1, 1] + * \param y The y coordinate in the closed interval [-1, 1] + * \param z The z coordinate in the closed interval [-1, 1] + * + * \return True if the event was handled otherwise false + */ + virtual bool OnAccelerometerMotion(const FeatureName& feature, float x, float y, float z) + { + return false; + } + + /*! + * \brief A wheel has changed state + * + * Left is negative position, right is positive position + * + * \param feature The wheel changing state + * \param position The position in the closed interval [-1, 1] + * \param motionTimeMs The time elapsed since the position was 0 + * + * \return True if the event was handled otherwise false + */ + virtual bool OnWheelMotion(const FeatureName& feature, + float position, + unsigned int motionTimeMs) = 0; + + /*! + * \brief A throttle has changed state + * + * Up is positive position, down is negative position. + * + * \param feature The wheel changing state + * \param position The position in the closed interval [-1, 1] + * \param motionTimeMs The time elapsed since the position was 0 + * + * \return True if the event was handled otherwise false + */ + virtual bool OnThrottleMotion(const FeatureName& feature, + float position, + unsigned int motionTimeMs) = 0; + + /*! + * \brief Called at the end of the frame that provided input + */ + virtual void OnInputFrame() = 0; + + // Input receiver interface + void SetInputReceiver(IInputReceiver* receiver) { m_receiver = receiver; } + void ResetInputReceiver(void) { m_receiver = nullptr; } + IInputReceiver* InputReceiver(void) { return m_receiver; } + +private: + IInputReceiver* m_receiver = nullptr; +}; +} // namespace JOYSTICK +} // namespace KODI diff --git a/xbmc/input/joysticks/interfaces/IInputProvider.h b/xbmc/input/joysticks/interfaces/IInputProvider.h new file mode 100644 index 0000000..09a0366 --- /dev/null +++ b/xbmc/input/joysticks/interfaces/IInputProvider.h @@ -0,0 +1,43 @@ +/* + * Copyright (C) 2017-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +namespace KODI +{ +namespace JOYSTICK +{ +class IInputHandler; + +/*! + * \ingroup joystick + * \brief Interface for classes that can provide input + */ +class IInputProvider +{ +public: + virtual ~IInputProvider() = default; + + /*! + * \brief Register a handler for the provided input + * + * \param handler The handler to receive input provided by this class + * \param bPromiscuous If true, receives all input (including handled input) + * in the background + */ + virtual void RegisterInputHandler(IInputHandler* handler, bool bPromiscuous) = 0; + + /*! + * \brief Unregister a handler + * + * \param handler The handler that was receiving input + */ + virtual void UnregisterInputHandler(IInputHandler* handler) = 0; +}; +} // namespace JOYSTICK +} // namespace KODI diff --git a/xbmc/input/joysticks/interfaces/IInputReceiver.h b/xbmc/input/joysticks/interfaces/IInputReceiver.h new file mode 100644 index 0000000..400da3f --- /dev/null +++ b/xbmc/input/joysticks/interfaces/IInputReceiver.h @@ -0,0 +1,37 @@ +/* + * 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/JoystickTypes.h" + +namespace KODI +{ +namespace JOYSTICK +{ +/*! + * \ingroup joystick + * \brief Interface for sending input events to game controllers + */ +class IInputReceiver +{ +public: + virtual ~IInputReceiver() = default; + + /*! + * \brief Set the value of a rumble motor + * + * \param feature The name of the motor to rumble + * \param magnitude The motor's new magnitude of vibration in the closed interval [0, 1] + * + * \return True if the event was handled otherwise false + */ + virtual bool SetRumbleState(const FeatureName& feature, float magnitude) = 0; +}; +} // namespace JOYSTICK +} // namespace KODI diff --git a/xbmc/input/joysticks/interfaces/IKeyHandler.h b/xbmc/input/joysticks/interfaces/IKeyHandler.h new file mode 100644 index 0000000..30f49c5 --- /dev/null +++ b/xbmc/input/joysticks/interfaces/IKeyHandler.h @@ -0,0 +1,56 @@ +/* + * 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 + +namespace KODI +{ +namespace JOYSTICK +{ +/*! + * \ingroup joystick + * \brief Interface for handling keymap keys + * + * Keys can be mapped to analog actions (e.g. "AnalogSeekForward") or digital + * actions (e.g. "Up"). + */ +class IKeyHandler +{ +public: + virtual ~IKeyHandler() = default; + + /*! + * \brief Return true if the key is "pressed" (has a magnitude greater + * than 0.5) + * + * \return True if the key is "pressed", false otherwise + */ + virtual bool IsPressed() const = 0; + + /*! + * \brief A key mapped to a digital feature has been pressed or released + * + * \param bPressed true if the key's button/axis is activated, false if deactivated + * \param holdTimeMs The held time in ms for pressed buttons, or 0 for released + * + * \return True if the key is mapped to an action, false otherwise + */ + virtual bool OnDigitalMotion(bool bPressed, unsigned int holdTimeMs) = 0; + + /*! + * \brief Callback for keys mapped to analog features + * + * \param magnitude The amount of the analog action + * \param motionTimeMs The time since the magnitude was 0 + * + * \return True if the key is mapped to an action, false otherwise + */ + virtual bool OnAnalogMotion(float magnitude, unsigned int motionTimeMs) = 0; +}; +} // namespace JOYSTICK +} // namespace KODI diff --git a/xbmc/input/joysticks/interfaces/IKeymapHandler.h b/xbmc/input/joysticks/interfaces/IKeymapHandler.h new file mode 100644 index 0000000..f0af427 --- /dev/null +++ b/xbmc/input/joysticks/interfaces/IKeymapHandler.h @@ -0,0 +1,52 @@ +/* + * Copyright (C) 2017-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include <set> +#include <string> + +namespace KODI +{ +namespace JOYSTICK +{ +/*! + * \ingroup joystick + * \brief Interface for a class working with a keymap + */ +class IKeymapHandler +{ +public: + virtual ~IKeymapHandler() = default; + + /*! + * \brief Get the pressed state of the given keys + * + * \param keyNames The key names + * + * \return True if all keys are pressed or no keys are given, false otherwise + */ + virtual bool HotkeysPressed(const std::set<std::string>& keyNames) const = 0; + + /*! + * \brief Get the key name of the last button pressed + * + * \return The key name of the last-pressed button, or empty if no button + * is pressed + */ + virtual std::string GetLastPressed() const = 0; + + /*! + * \brief Called when a key has emitted an action after bring pressed + * + * \param keyName the key name that emitted the action + */ + virtual void OnPress(const std::string& keyName) = 0; +}; +} // namespace JOYSTICK +} // namespace KODI diff --git a/xbmc/input/joysticks/keymaps/CMakeLists.txt b/xbmc/input/joysticks/keymaps/CMakeLists.txt new file mode 100644 index 0000000..c854b36 --- /dev/null +++ b/xbmc/input/joysticks/keymaps/CMakeLists.txt @@ -0,0 +1,11 @@ +set(SOURCES KeyHandler.cpp + KeymapHandler.cpp + KeymapHandling.cpp +) + +set(HEADERS KeyHandler.h + KeymapHandler.h + KeymapHandling.h +) + +core_add_library(input_joystick_keymaps) diff --git a/xbmc/input/joysticks/keymaps/KeyHandler.cpp b/xbmc/input/joysticks/keymaps/KeyHandler.cpp new file mode 100644 index 0000000..cd0f30a --- /dev/null +++ b/xbmc/input/joysticks/keymaps/KeyHandler.cpp @@ -0,0 +1,290 @@ +/* + * Copyright (C) 2017-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "KeyHandler.h" + +#include "input/IKeymap.h" +#include "input/actions/ActionIDs.h" +#include "input/actions/ActionTranslator.h" +#include "input/joysticks/JoystickUtils.h" +#include "input/joysticks/interfaces/IKeymapHandler.h" +#include "interfaces/IActionListener.h" + +#include <algorithm> +#include <assert.h> + +using namespace KODI; +using namespace JOYSTICK; + +#define DIGITAL_ANALOG_THRESHOLD 0.5f + +#define HOLD_TIMEOUT_MS 500 +#define REPEAT_TIMEOUT_MS 50 + +CKeyHandler::CKeyHandler(const std::string& keyName, + IActionListener* actionHandler, + const IKeymap* keymap, + IKeymapHandler* keymapHandler) + : m_keyName(keyName), + m_actionHandler(actionHandler), + m_keymap(keymap), + m_keymapHandler(keymapHandler) +{ + assert(m_actionHandler != nullptr); + assert(m_keymap != nullptr); + assert(m_keymapHandler != nullptr); + + Reset(); +} + +void CKeyHandler::Reset() +{ + m_bHeld = false; + m_magnitude = 0.0f; + m_holdStartTimeMs = 0; + m_lastHoldTimeMs = 0; + m_bActionSent = false; + m_lastActionMs = 0; + m_activeWindowId = -1; + m_lastAction = CAction(); +} + +bool CKeyHandler::OnDigitalMotion(bool bPressed, unsigned int holdTimeMs) +{ + return OnAnalogMotion(bPressed ? 1.0f : 0.0f, holdTimeMs); +} + +bool CKeyHandler::OnAnalogMotion(float magnitude, unsigned int motionTimeMs) +{ + // Don't send deactivation event more than once + if (m_magnitude == 0.0f && magnitude == 0.0f) + return false; + + // Get actions for the key + const auto& actionGroup = m_keymap->GetActions(m_keyName); + const int windowId = actionGroup.windowId; + const auto& actions = actionGroup.actions; + + // Calculate press state + const bool bPressed = IsPressed(magnitude); + const bool bJustPressed = bPressed && !m_bHeld; + + if (bJustPressed) + { + // Reset key if just pressed + Reset(); + + // Record hold start time if just pressed + m_holdStartTimeMs = motionTimeMs; + + // Record window ID + if (windowId >= 0) + m_activeWindowId = windowId; + } + + // Calculate holdtime relative to when magnitude crossed the threshold + unsigned int holdTimeMs = 0; + if (bPressed) + holdTimeMs = motionTimeMs - m_holdStartTimeMs; + + // Give priority to actions with hotkeys + std::vector<const KeymapAction*> actionsWithHotkeys; + + for (const auto& action : actions) + { + if (!action.hotkeys.empty()) + actionsWithHotkeys.emplace_back(&action); + } + + CAction dispatchAction = + ProcessActions(std::move(actionsWithHotkeys), windowId, magnitude, holdTimeMs); + + // If that failed, try again with all actions + if (dispatchAction.GetID() == ACTION_NONE) + { + std::vector<const KeymapAction*> allActions; + + allActions.reserve(actions.size()); + for (const auto& action : actions) + allActions.emplace_back(&action); + + dispatchAction = ProcessActions(std::move(allActions), windowId, magnitude, holdTimeMs); + } + + // If specific action was sent last frame but not this one, send a release event + if (dispatchAction.GetID() != m_lastAction.GetID()) + { + if (CActionTranslator::IsAnalog(m_lastAction.GetID()) && m_lastAction.GetAmount() > 0.0f) + { + m_lastAction.ClearAmount(); + m_actionHandler->OnAction(m_lastAction); + } + } + + // Dispatch action + bool bHandled = false; + if (dispatchAction.GetID() != ACTION_NONE) + { + m_actionHandler->OnAction(dispatchAction); + bHandled = true; + } + + m_bHeld = bPressed; + m_magnitude = magnitude; + m_lastHoldTimeMs = holdTimeMs; + m_lastAction = dispatchAction; + + return bHandled; +} + +CAction CKeyHandler::ProcessActions(std::vector<const KeymapAction*> actions, + int windowId, + float magnitude, + unsigned int holdTimeMs) +{ + CAction dispatchAction; + + // Filter out actions without pressed hotkeys + actions.erase(std::remove_if(actions.begin(), actions.end(), + [this](const KeymapAction* action) { + return !m_keymapHandler->HotkeysPressed(action->hotkeys); + }), + actions.end()); + + if (actions.empty()) + return false; + + // Actions are sorted by holdtime, so the final action is the one with the + // greatest holdtime + const KeymapAction& finalAction = **actions.rbegin(); + const unsigned int maxHoldTimeMs = finalAction.holdTimeMs; + + const bool bHasDelay = (maxHoldTimeMs > 0); + if (!bHasDelay) + { + dispatchAction = ProcessAction(finalAction, windowId, magnitude, holdTimeMs); + } + else + { + // If holdtime has exceeded the last action, execute it now + if (holdTimeMs >= finalAction.holdTimeMs) + { + // Force holdtime to zero for the initial press + if (!m_bActionSent) + holdTimeMs = 0; + else + holdTimeMs -= finalAction.holdTimeMs; + + dispatchAction = ProcessAction(finalAction, windowId, magnitude, holdTimeMs); + } + else + { + // Calculate press state + const bool bPressed = IsPressed(magnitude); + const bool bJustReleased = m_bHeld && !bPressed; + + // If button was just released, send a release action + if (bJustReleased) + dispatchAction = ProcessRelease(actions, windowId); + } + } + + return dispatchAction; +} + +CAction CKeyHandler::ProcessRelease(std::vector<const KeymapAction*> actions, int windowId) +{ + CAction dispatchAction; + + // Use previous holdtime from before button release + const unsigned int holdTimeMs = m_lastHoldTimeMs; + + // Send an action on release if one occurs before the holdtime + for (auto it = actions.begin(); it != actions.end();) + { + const KeymapAction& action = **it; + + unsigned int thisHoldTime = (*it)->holdTimeMs; + + ++it; + if (it == actions.end()) + break; + + unsigned int nextHoldTime = (*it)->holdTimeMs; + + if (thisHoldTime <= holdTimeMs && holdTimeMs < nextHoldTime) + { + dispatchAction = ProcessAction(action, windowId, 1.0f, 0); + break; + } + } + + return dispatchAction; +} + +CAction CKeyHandler::ProcessAction(const KeymapAction& action, + int windowId, + float magnitude, + unsigned int holdTimeMs) +{ + CAction dispatchAction; + + bool bSendAction = false; + + if (windowId != m_activeWindowId) + { + // Don't send actions if the window has changed since being pressed + } + else if (CActionTranslator::IsAnalog(action.actionId)) + { + bSendAction = true; + } + else if (IsPressed(magnitude)) + { + // Dispatch action if button was pressed this frame + if (holdTimeMs == 0) + bSendAction = true; + else + bSendAction = SendRepeatAction(holdTimeMs); + } + + if (bSendAction) + { + const CAction guiAction(action.actionId, magnitude, 0.0f, action.actionString, holdTimeMs); + m_keymapHandler->OnPress(m_keyName); + m_bActionSent = true; + m_lastActionMs = holdTimeMs; + dispatchAction = guiAction; + } + + return dispatchAction; +} + +bool CKeyHandler::SendRepeatAction(unsigned int holdTimeMs) +{ + bool bSendRepeat = true; + + // Don't send a repeat action if the last key has changed + if (m_keymapHandler->GetLastPressed() != m_keyName) + bSendRepeat = false; + + // Ensure initial timeout has elapsed + else if (holdTimeMs < HOLD_TIMEOUT_MS) + bSendRepeat = false; + + // Ensure repeat timeout has elapsed + else if (holdTimeMs < m_lastActionMs + REPEAT_TIMEOUT_MS) + bSendRepeat = false; + + return bSendRepeat; +} + +bool CKeyHandler::IsPressed(float magnitude) +{ + return magnitude >= DIGITAL_ANALOG_THRESHOLD; +} diff --git a/xbmc/input/joysticks/keymaps/KeyHandler.h b/xbmc/input/joysticks/keymaps/KeyHandler.h new file mode 100644 index 0000000..3b5a46c --- /dev/null +++ b/xbmc/input/joysticks/keymaps/KeyHandler.h @@ -0,0 +1,114 @@ +/* + * Copyright (C) 2017-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include "input/actions/Action.h" +#include "input/joysticks/JoystickTypes.h" +#include "input/joysticks/interfaces/IKeyHandler.h" + +#include <map> +#include <string> +#include <vector> + +class CAction; +class IActionListener; +class IKeymap; + +namespace KODI +{ +namespace JOYSTICK +{ +class IKeymapHandler; + +/*! + * \ingroup joystick + * \brief + */ +class CKeyHandler : public IKeyHandler +{ +public: + CKeyHandler(const std::string& keyName, + IActionListener* actionHandler, + const IKeymap* keymap, + IKeymapHandler* keymapHandler); + + ~CKeyHandler() override = default; + + // implementation of IKeyHandler + bool IsPressed() const override { return m_bHeld; } + bool OnDigitalMotion(bool bPressed, unsigned int holdTimeMs) override; + bool OnAnalogMotion(float magnitude, unsigned int motionTimeMs) override; + +private: + void Reset(); + + /*! + * \brief Process actions to see if an action should be dispatched + * + * \param actions All actions from the keymap defined for the current window + * \param windowId The current window ID + * \param magnitude The magnitude or distance of the feature being handled + * \param holdTimeMs The time which the feature has been past the hold threshold + * + * \return The action to dispatch, or action with ID ACTION_NONE if no action should be dispatched + */ + CAction ProcessActions(std::vector<const KeymapAction*> actions, + int windowId, + float magnitude, + unsigned int holdTimeMs); + + /*! + * \brief Process actions after release event to see if an action should be dispatched + * + * \param actions All actions from the keymap defined for the current window + * \param windowId The current window ID + * + * \return The action to dispatch, or action with ID ACTION_NONE if no action should be dispatched + */ + CAction ProcessRelease(std::vector<const KeymapAction*> actions, int windowId); + + /*! + * \brief Process an action to see if it should be dispatched + * + * \param action The action chosen to be dispatched + * \param windowId The current window ID + * \param magnitude The magnitude or distance of the feature being handled + * \param holdTimeMs The time which the feature has been past the hold threshold + * + * \return The action to dispatch, or action with ID ACTION_NONE if no action should be dispatched + */ + CAction ProcessAction(const KeymapAction& action, + int windowId, + float magnitude, + unsigned int holdTimeMs); + + // Check criteria for sending a repeat action + bool SendRepeatAction(unsigned int holdTimeMs); + + // Helper function + static bool IsPressed(float magnitude); + + // Construction parameters + const std::string m_keyName; + IActionListener* const m_actionHandler; + const IKeymap* const m_keymap; + IKeymapHandler* const m_keymapHandler; + + // State variables + bool m_bHeld; + float m_magnitude; + unsigned int m_holdStartTimeMs; + unsigned int m_lastHoldTimeMs; + bool m_bActionSent; + unsigned int m_lastActionMs; + int m_activeWindowId = -1; // Window that activated the key + CAction m_lastAction; +}; +} // namespace JOYSTICK +} // namespace KODI diff --git a/xbmc/input/joysticks/keymaps/KeymapHandler.cpp b/xbmc/input/joysticks/keymaps/KeymapHandler.cpp new file mode 100644 index 0000000..24e2a0b --- /dev/null +++ b/xbmc/input/joysticks/keymaps/KeymapHandler.cpp @@ -0,0 +1,278 @@ +/* + * Copyright (C) 2017-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "KeymapHandler.h" + +#include "KeyHandler.h" +#include "games/controllers/Controller.h" +#include "input/IKeymap.h" +#include "input/IKeymapEnvironment.h" +#include "input/InputTranslator.h" +#include "input/joysticks/JoystickEasterEgg.h" +#include "input/joysticks/JoystickTranslator.h" +#include "input/joysticks/JoystickUtils.h" +#include "input/joysticks/interfaces/IKeyHandler.h" + +#include <algorithm> +#include <assert.h> +#include <cmath> +#include <utility> + +using namespace KODI; +using namespace JOYSTICK; + +CKeymapHandler::CKeymapHandler(IActionListener* actionHandler, const IKeymap* keymap) + : m_actionHandler(actionHandler), m_keymap(keymap) +{ + assert(m_actionHandler != nullptr); + assert(m_keymap != nullptr); + + if (m_keymap->Environment()->UseEasterEgg()) + m_easterEgg.reset(new CJoystickEasterEgg(ControllerID())); +} + +bool CKeymapHandler::HotkeysPressed(const std::set<std::string>& keyNames) const +{ + bool bHotkeysPressed = true; + + for (const auto& hotkey : keyNames) + { + auto it = m_keyHandlers.find(hotkey); + if (it == m_keyHandlers.end() || !it->second->IsPressed()) + { + bHotkeysPressed = false; + break; + } + } + + return bHotkeysPressed; +} + +std::string CKeymapHandler::ControllerID() const +{ + return m_keymap->ControllerID(); +} + +bool CKeymapHandler::AcceptsInput(const FeatureName& feature) const +{ + if (HasAction(CJoystickUtils::MakeKeyName(feature))) + return true; + + for (auto dir : CJoystickUtils::GetAnalogStickDirections()) + { + if (HasAction(CJoystickUtils::MakeKeyName(feature, dir))) + return true; + } + + return false; +} + +bool CKeymapHandler::OnButtonPress(const FeatureName& feature, bool bPressed) +{ + if (bPressed && m_easterEgg && m_easterEgg->OnButtonPress(feature)) + return true; + + const std::string keyName = CJoystickUtils::MakeKeyName(feature); + + IKeyHandler* handler = GetKeyHandler(keyName); + return handler->OnDigitalMotion(bPressed, 0); +} + +void CKeymapHandler::OnButtonHold(const FeatureName& feature, unsigned int holdTimeMs) +{ + if (m_easterEgg && m_easterEgg->IsCapturing()) + return; + + const std::string keyName = CJoystickUtils::MakeKeyName(feature); + + IKeyHandler* handler = GetKeyHandler(keyName); + handler->OnDigitalMotion(true, holdTimeMs); +} + +bool CKeymapHandler::OnButtonMotion(const FeatureName& feature, + float magnitude, + unsigned int motionTimeMs) +{ + const std::string keyName = CJoystickUtils::MakeKeyName(feature); + + IKeyHandler* handler = GetKeyHandler(keyName); + return handler->OnAnalogMotion(magnitude, motionTimeMs); +} + +bool CKeymapHandler::OnAnalogStickMotion(const FeatureName& feature, + float x, + float y, + unsigned int motionTimeMs) +{ + using namespace INPUT; + + bool bHandled = false; + + // Calculate the direction of the stick's position + const ANALOG_STICK_DIRECTION analogStickDir = CInputTranslator::VectorToCardinalDirection(x, y); + + // Calculate the magnitude projected onto that direction + const float magnitude = std::max(std::fabs(x), std::fabs(y)); + + // Deactivate directions in which the stick is not pointing first + for (auto dir : CJoystickUtils::GetAnalogStickDirections()) + { + if (dir != analogStickDir) + DeactivateDirection(feature, dir); + } + + // Now activate direction the analog stick is pointing + if (analogStickDir != ANALOG_STICK_DIRECTION::NONE) + bHandled = ActivateDirection(feature, magnitude, analogStickDir, motionTimeMs); + + return bHandled; +} + +bool CKeymapHandler::OnWheelMotion(const FeatureName& feature, + float position, + unsigned int motionTimeMs) +{ + bool bHandled = false; + + // Calculate the direction of the wheel's position + const WHEEL_DIRECTION direction = CJoystickTranslator::PositionToWheelDirection(position); + + // Calculate the magnitude projected onto that direction + const float magnitude = std::fabs(position); + + // Deactivate directions in which the wheel is not pointing first + for (auto dir : CJoystickUtils::GetWheelDirections()) + { + if (dir != direction) + DeactivateDirection(feature, dir); + } + + // Now activate direction in which the wheel is positioned + if (direction != WHEEL_DIRECTION::NONE) + bHandled = ActivateDirection(feature, magnitude, direction, motionTimeMs); + + return bHandled; +} + +bool CKeymapHandler::OnThrottleMotion(const FeatureName& feature, + float position, + unsigned int motionTimeMs) +{ + bool bHandled = false; + + // Calculate the direction of the throttle's position + const THROTTLE_DIRECTION direction = CJoystickTranslator::PositionToThrottleDirection(position); + + // Calculate the magnitude projected onto that direction + const float magnitude = std::fabs(position); + + // Deactivate directions in which the throttle is not pointing first + for (auto dir : CJoystickUtils::GetThrottleDirections()) + { + if (dir != direction) + DeactivateDirection(feature, dir); + } + + // Now activate direction in which the throttle is positioned + if (direction != THROTTLE_DIRECTION::NONE) + bHandled = ActivateDirection(feature, magnitude, direction, motionTimeMs); + + return bHandled; +} + +bool CKeymapHandler::OnAccelerometerMotion(const FeatureName& feature, float x, float y, float z) +{ + return false; //! @todo implement +} + +bool CKeymapHandler::ActivateDirection(const FeatureName& feature, + float magnitude, + ANALOG_STICK_DIRECTION dir, + unsigned int motionTimeMs) +{ + const std::string keyName = CJoystickUtils::MakeKeyName(feature, dir); + + IKeyHandler* handler = GetKeyHandler(keyName); + return handler->OnAnalogMotion(magnitude, motionTimeMs); +} + +void CKeymapHandler::DeactivateDirection(const FeatureName& feature, ANALOG_STICK_DIRECTION dir) +{ + const std::string keyName = CJoystickUtils::MakeKeyName(feature, dir); + + IKeyHandler* handler = GetKeyHandler(keyName); + handler->OnAnalogMotion(0.0f, 0); +} + +bool CKeymapHandler::ActivateDirection(const FeatureName& feature, + float magnitude, + WHEEL_DIRECTION dir, + unsigned int motionTimeMs) +{ + const std::string keyName = CJoystickUtils::MakeKeyName(feature, dir); + + IKeyHandler* handler = GetKeyHandler(keyName); + return handler->OnAnalogMotion(magnitude, motionTimeMs); +} + +void CKeymapHandler::DeactivateDirection(const FeatureName& feature, WHEEL_DIRECTION dir) +{ + const std::string keyName = CJoystickUtils::MakeKeyName(feature, dir); + + IKeyHandler* handler = GetKeyHandler(keyName); + handler->OnAnalogMotion(0.0f, 0); +} + +bool CKeymapHandler::ActivateDirection(const FeatureName& feature, + float magnitude, + THROTTLE_DIRECTION dir, + unsigned int motionTimeMs) +{ + const std::string keyName = CJoystickUtils::MakeKeyName(feature, dir); + + IKeyHandler* handler = GetKeyHandler(keyName); + return handler->OnAnalogMotion(magnitude, motionTimeMs); +} + +void CKeymapHandler::DeactivateDirection(const FeatureName& feature, THROTTLE_DIRECTION dir) +{ + const std::string keyName = CJoystickUtils::MakeKeyName(feature, dir); + + IKeyHandler* handler = GetKeyHandler(keyName); + handler->OnAnalogMotion(0.0f, 0); +} + +IKeyHandler* CKeymapHandler::GetKeyHandler(const std::string& keyName) +{ + auto it = m_keyHandlers.find(keyName); + if (it == m_keyHandlers.end()) + { + std::unique_ptr<IKeyHandler> handler(new CKeyHandler(keyName, m_actionHandler, m_keymap, this)); + m_keyHandlers.insert(std::make_pair(keyName, std::move(handler))); + it = m_keyHandlers.find(keyName); + } + + return it->second.get(); +} + +bool CKeymapHandler::HasAction(const std::string& keyName) const +{ + bool bHasAction = false; + + const auto& actions = m_keymap->GetActions(keyName).actions; + for (const auto& action : actions) + { + if (HotkeysPressed(action.hotkeys)) + { + bHasAction = true; + break; + } + } + + return bHasAction; +} diff --git a/xbmc/input/joysticks/keymaps/KeymapHandler.h b/xbmc/input/joysticks/keymaps/KeymapHandler.h new file mode 100644 index 0000000..a2b1d4f --- /dev/null +++ b/xbmc/input/joysticks/keymaps/KeymapHandler.h @@ -0,0 +1,108 @@ +/* + * Copyright (C) 2017-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include "input/joysticks/JoystickTypes.h" +#include "input/joysticks/interfaces/IButtonSequence.h" +#include "input/joysticks/interfaces/IInputHandler.h" +#include "input/joysticks/interfaces/IKeymapHandler.h" + +#include <map> +#include <memory> +#include <string> + +class IActionListener; +class IKeymap; + +namespace KODI +{ +namespace JOYSTICK +{ +class IKeyHandler; + +/*! + * \ingroup joystick + * \brief + */ +class CKeymapHandler : public IKeymapHandler, public IInputHandler +{ +public: + CKeymapHandler(IActionListener* actionHandler, const IKeymap* keymap); + + ~CKeymapHandler() override = default; + + // implementation of IKeymapHandler + bool HotkeysPressed(const std::set<std::string>& keyNames) const override; + std::string GetLastPressed() const override { return m_lastPressed; } + void OnPress(const std::string& keyName) override { m_lastPressed = keyName; } + + // implementation of IInputHandler + std::string ControllerID() const override; + bool HasFeature(const FeatureName& feature) const override { return true; } + bool AcceptsInput(const FeatureName& feature) const override; + bool OnButtonPress(const FeatureName& feature, bool bPressed) override; + void OnButtonHold(const FeatureName& feature, unsigned int holdTimeMs) override; + bool OnButtonMotion(const FeatureName& feature, + float magnitude, + unsigned int motionTimeMs) override; + bool OnAnalogStickMotion(const FeatureName& feature, + float x, + float y, + unsigned int motionTimeMs) override; + bool OnAccelerometerMotion(const FeatureName& feature, float x, float y, float z) override; + bool OnWheelMotion(const FeatureName& feature, + float position, + unsigned int motionTimeMs) override; + bool OnThrottleMotion(const FeatureName& feature, + float position, + unsigned int motionTimeMs) override; + void OnInputFrame() override {} + +protected: + // Keep track of cheat code presses + std::unique_ptr<IButtonSequence> m_easterEgg; + +private: + // Analog stick helper functions + bool ActivateDirection(const FeatureName& feature, + float magnitude, + ANALOG_STICK_DIRECTION dir, + unsigned int motionTimeMs); + void DeactivateDirection(const FeatureName& feature, ANALOG_STICK_DIRECTION dir); + + // Wheel helper functions + bool ActivateDirection(const FeatureName& feature, + float magnitude, + WHEEL_DIRECTION dir, + unsigned int motionTimeMs); + void DeactivateDirection(const FeatureName& feature, WHEEL_DIRECTION dir); + + // Throttle helper functions + bool ActivateDirection(const FeatureName& feature, + float magnitude, + THROTTLE_DIRECTION dir, + unsigned int motionTimeMs); + void DeactivateDirection(const FeatureName& feature, THROTTLE_DIRECTION dir); + + // Helper functions + IKeyHandler* GetKeyHandler(const std::string& keyName); + bool HasAction(const std::string& keyName) const; + + // Construction parameters + IActionListener* const m_actionHandler; + const IKeymap* const m_keymap; + + // Handlers for individual keys + std::map<std::string, std::unique_ptr<IKeyHandler>> m_keyHandlers; // Key name -> handler + + // Last pressed key + std::string m_lastPressed; +}; +} // namespace JOYSTICK +} // namespace KODI diff --git a/xbmc/input/joysticks/keymaps/KeymapHandling.cpp b/xbmc/input/joysticks/keymaps/KeymapHandling.cpp new file mode 100644 index 0000000..b87ea68 --- /dev/null +++ b/xbmc/input/joysticks/keymaps/KeymapHandling.cpp @@ -0,0 +1,104 @@ +/* + * Copyright (C) 2017-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#include "KeymapHandling.h" + +#include "KeymapHandler.h" +#include "ServiceBroker.h" +#include "input/ButtonTranslator.h" +#include "input/InputManager.h" +#include "input/Keymap.h" +#include "input/joysticks/interfaces/IInputHandler.h" +#include "input/joysticks/interfaces/IInputProvider.h" + +#include <algorithm> +#include <utility> + +using namespace KODI; +using namespace JOYSTICK; + +CKeymapHandling::CKeymapHandling(IInputProvider* inputProvider, + bool pPromiscuous, + const IKeymapEnvironment* environment) + : m_inputProvider(inputProvider), m_pPromiscuous(pPromiscuous), m_environment(environment) +{ + LoadKeymaps(); + CServiceBroker::GetInputManager().RegisterObserver(this); +} + +CKeymapHandling::~CKeymapHandling() +{ + CServiceBroker::GetInputManager().UnregisterObserver(this); + UnloadKeymaps(); +} + +IInputReceiver* CKeymapHandling::GetInputReceiver(const std::string& controllerId) const +{ + auto it = std::find_if(m_inputHandlers.begin(), m_inputHandlers.end(), + [&controllerId](const std::unique_ptr<IInputHandler>& inputHandler) { + return inputHandler->ControllerID() == controllerId; + }); + + if (it != m_inputHandlers.end()) + return (*it)->InputReceiver(); + + return nullptr; +} + +IKeymap* CKeymapHandling::GetKeymap(const std::string& controllerId) const +{ + auto it = std::find_if(m_keymaps.begin(), m_keymaps.end(), + [&controllerId](const std::unique_ptr<IKeymap>& keymap) { + return keymap->ControllerID() == controllerId; + }); + + if (it != m_keymaps.end()) + return it->get(); + + return nullptr; +} + +void CKeymapHandling::Notify(const Observable& obs, const ObservableMessage msg) +{ + if (msg == ObservableMessageButtonMapsChanged) + LoadKeymaps(); +} + +void CKeymapHandling::LoadKeymaps() +{ + UnloadKeymaps(); + + auto& inputManager = CServiceBroker::GetInputManager(); + + for (auto& windowKeymap : inputManager.GetJoystickKeymaps()) + { + // Create keymap + std::unique_ptr<IKeymap> keymap(new CKeymap(std::move(windowKeymap), m_environment)); + + // Create keymap handler + std::unique_ptr<IInputHandler> inputHandler(new CKeymapHandler(&inputManager, keymap.get())); + + // Register the handler with the input provider + m_inputProvider->RegisterInputHandler(inputHandler.get(), m_pPromiscuous); + + // Save the keymap and handler + m_keymaps.emplace_back(std::move(keymap)); + m_inputHandlers.emplace_back(std::move(inputHandler)); + } +} + +void CKeymapHandling::UnloadKeymaps() +{ + if (m_inputProvider != nullptr) + { + for (auto it = m_inputHandlers.rbegin(); it != m_inputHandlers.rend(); ++it) + m_inputProvider->UnregisterInputHandler(it->get()); + } + m_inputHandlers.clear(); + m_keymaps.clear(); +} diff --git a/xbmc/input/joysticks/keymaps/KeymapHandling.h b/xbmc/input/joysticks/keymaps/KeymapHandling.h new file mode 100644 index 0000000..fdc64b7 --- /dev/null +++ b/xbmc/input/joysticks/keymaps/KeymapHandling.h @@ -0,0 +1,76 @@ +/* + * Copyright (C) 2017-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include "utils/Observer.h" + +#include <memory> +#include <string> +#include <vector> + +class IKeymap; +class IKeymapEnvironment; + +namespace KODI +{ +namespace JOYSTICK +{ +class IInputHandler; +class IInputProvider; +class IInputReceiver; + +/*! + * \ingroup joystick + * \brief + */ +class CKeymapHandling : public Observer +{ +public: + CKeymapHandling(IInputProvider* inputProvider, + bool pPromiscuous, + const IKeymapEnvironment* environment); + + ~CKeymapHandling() override; + + /*! + * \brief Unregister the input provider + * + * Call this if the input provider is invalidated, such as if a user + * disconnects a controller. This prevents accessing the invalidated + * input provider when keymaps are unloaded upon destruction. + */ + void UnregisterInputProvider() { m_inputProvider = nullptr; } + + /*! + * \brief + */ + IInputReceiver* GetInputReceiver(const std::string& controllerId) const; + + /*! + * \brief + */ + IKeymap* GetKeymap(const std::string& controllerId) const; + + // implementation of Observer + void Notify(const Observable& obs, const ObservableMessage msg) override; + +private: + void LoadKeymaps(); + void UnloadKeymaps(); + + // Construction parameter + IInputProvider* m_inputProvider; + const bool m_pPromiscuous; + const IKeymapEnvironment* const m_environment; + + std::vector<std::unique_ptr<IKeymap>> m_keymaps; + std::vector<std::unique_ptr<IInputHandler>> m_inputHandlers; +}; +} // namespace JOYSTICK +} // namespace KODI |