xbmc/input/JoystickMapper.cpp

   1 /*
   2  *  Copyright (C) 2017-2018 Team Kodi
   3  *  This file is part of Kodi - https://kodi.tv
   4  *
   5  *  SPDX-License-Identifier: GPL-2.0-or-later
   6  *  See LICENSES/README.md for more information.
   7  */
   8
   9 #include "JoystickMapper.h"
  10
  11 #include "input/WindowKeymap.h"
  12 #include "input/actions/ActionIDs.h"
  13 #include "input/actions/ActionTranslator.h"
  14 #include "input/joysticks/JoystickTranslator.h"
  15 #include "input/joysticks/JoystickUtils.h"
  16 #include "utils/StringUtils.h"
  17 #include "utils/XBMCTinyXML.h"
  18
  19 #include <algorithm>
  20 #include <sstream>
  21 #include <utility>
  22
  23 using namespace KODI;
  24
  25 #define JOYSTICK_XML_NODE_PROFILE "profile"
  26 #define JOYSTICK_XML_ATTR_DIRECTION "direction"
  27 #define JOYSTICK_XML_ATTR_HOLDTIME "holdtime"
  28 #define JOYSTICK_XML_ATTR_HOTKEY "hotkey"
  29
  30 void CJoystickMapper::MapActions(int windowID, const TiXmlNode* pDevice)
  31 {
  32   std::string controllerId;
  33   DeserializeJoystickNode(pDevice, controllerId);
  34   if (controllerId.empty())
  35     return;
  36
  37   // Update Controller IDs
  38   if (std::find(m_controllerIds.begin(), m_controllerIds.end(), controllerId) ==
  39       m_controllerIds.end())
  40     m_controllerIds.emplace_back(controllerId);
  41
  42   // Create/overwrite keymap
  43   auto& keymap = m_joystickKeymaps[controllerId];
  44   if (!keymap)
  45     keymap.reset(new CWindowKeymap(controllerId));
  46
  47   const TiXmlElement* pButton = pDevice->FirstChildElement();
  48   while (pButton != nullptr)
  49   {
  50     std::string feature;
  51     JOYSTICK::ANALOG_STICK_DIRECTION dir;
  52     unsigned int holdtimeMs;
  53     std::set<std::string> hotkeys;
  54     std::string actionString;
  55     if (DeserializeButton(pButton, feature, dir, holdtimeMs, hotkeys, actionString))
  56     {
  57       // Update keymap
  58       unsigned int actionId = ACTION_NONE;
  59       if (CActionTranslator::TranslateString(actionString, actionId))
  60       {
  61         JOYSTICK::KeymapAction action = {
  62             actionId,
  63             std::move(actionString),
  64             holdtimeMs,
  65             std::move(hotkeys),
  66         };
  67         keymap->MapAction(windowID, JOYSTICK::CJoystickUtils::MakeKeyName(feature, dir),
  68                           std::move(action));
  69       }
  70     }
  71     pButton = pButton->NextSiblingElement();
  72   }
  73 }
  74
  75 void CJoystickMapper::Clear()
  76 {
  77   m_joystickKeymaps.clear();
  78   m_controllerIds.clear();
  79 }
  80
  81 std::vector<std::shared_ptr<const IWindowKeymap>> CJoystickMapper::GetJoystickKeymaps() const
  82 {
  83   std::vector<std::shared_ptr<const IWindowKeymap>> keymaps;
  84
  85   for (const auto& controllerId : m_controllerIds)
  86   {
  87     auto it = m_joystickKeymaps.find(controllerId);
  88     if (it != m_joystickKeymaps.end())
  89       keymaps.emplace_back(it->second);
  90   }
  91
  92   return keymaps;
  93 }
  94
  95 void CJoystickMapper::DeserializeJoystickNode(const TiXmlNode* pDevice, std::string& controllerId)
  96 {
  97   const TiXmlElement* deviceElem = pDevice->ToElement();
  98   if (deviceElem != nullptr)
  99     deviceElem->QueryValueAttribute(JOYSTICK_XML_NODE_PROFILE, &controllerId);
 100 }
 101
 102 bool CJoystickMapper::DeserializeButton(const TiXmlElement* pButton,
 103                                         std::string& feature,
 104                                         JOYSTICK::ANALOG_STICK_DIRECTION& dir,
 105                                         unsigned int& holdtimeMs,
 106                                         std::set<std::string>& hotkeys,
 107                                         std::string& actionStr)
 108 {
 109   const char* szButton = pButton->Value();
 110   if (szButton != nullptr)
 111   {
 112     const char* szAction = nullptr;
 113
 114     const TiXmlNode* actionNode = pButton->FirstChild();
 115     if (actionNode != nullptr)
 116       szAction = actionNode->Value();
 117
 118     if (szAction != nullptr)
 119     {
 120       feature = szButton;
 121       StringUtils::ToLower(feature);
 122       actionStr = szAction;
 123     }
 124   }
 125
 126   if (!feature.empty() && !actionStr.empty())
 127   {
 128     // Handle direction
 129     dir = JOYSTICK::ANALOG_STICK_DIRECTION::NONE;
 130     const char* szDirection = pButton->Attribute(JOYSTICK_XML_ATTR_DIRECTION);
 131     if (szDirection != nullptr)
 132       dir = JOYSTICK::CJoystickTranslator::TranslateAnalogStickDirection(szDirection);
 133
 134     // Process holdtime parameter
 135     holdtimeMs = 0;
 136     std::string strHoldTime;
 137     if (pButton->QueryValueAttribute(JOYSTICK_XML_ATTR_HOLDTIME, &strHoldTime) == TIXML_SUCCESS)
 138     {
 139       std::istringstream ss(strHoldTime);
 140       ss >> holdtimeMs;
 141     }
 142
 143     // Process hotkeys
 144     hotkeys.clear();
 145     std::string strHotkeys;
 146     if (pButton->QueryValueAttribute(JOYSTICK_XML_ATTR_HOTKEY, &strHotkeys) == TIXML_SUCCESS)
 147     {
 148       std::vector<std::string> vecHotkeys = StringUtils::Split(strHotkeys, ",");
 149       for (auto& hotkey : vecHotkeys)
 150         hotkeys.insert(std::move(hotkey));
 151     }
 152
 153     return true;
 154   }
 155
 156   return false;
 157 }