xbmc/peripherals/PeripheralTypes.h

   1 /*
   2  *  Copyright (C) 2005-2024 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 #pragma once
  10
  11 #include <algorithm>
  12 #include <map>
  13 #include <memory>
  14 #include <stdio.h>
  15 #include <string>
  16 #include <vector>
  17 #ifdef TARGET_WINDOWS
  18 #include "PlatformDefs.h"
  19 #endif
  20 #include "utils/StringUtils.h"
  21
  22 class CSetting;
  23
  24 namespace PERIPHERALS
  25 {
  26 /// \ingroup peripherals
  27 /// \{
  28
  29 /*!
  30  * \brief Indicates a joystick has no preference for port number
  31  */
  32 constexpr auto JOYSTICK_NO_PORT_REQUESTED = -1;
  33
  34 enum PeripheralBusType
  35 {
  36   PERIPHERAL_BUS_UNKNOWN = 0,
  37   PERIPHERAL_BUS_USB,
  38   PERIPHERAL_BUS_PCI,
  39   PERIPHERAL_BUS_CEC,
  40   PERIPHERAL_BUS_ADDON,
  41 #ifdef TARGET_ANDROID
  42   PERIPHERAL_BUS_ANDROID,
  43 #endif
  44 #if defined(TARGET_DARWIN)
  45   PERIPHERAL_BUS_GCCONTROLLER,
  46 #endif
  47   PERIPHERAL_BUS_APPLICATION,
  48 };
  49
  50 enum PeripheralFeature
  51 {
  52   FEATURE_UNKNOWN = 0,
  53   FEATURE_HID,
  54   FEATURE_NIC,
  55   FEATURE_DISK,
  56   FEATURE_NYXBOARD,
  57   FEATURE_CEC,
  58   FEATURE_BLUETOOTH,
  59   FEATURE_TUNER,
  60   FEATURE_IMON,
  61   FEATURE_JOYSTICK,
  62   FEATURE_RUMBLE,
  63   FEATURE_POWER_OFF,
  64   FEATURE_KEYBOARD,
  65   FEATURE_MOUSE,
  66 };
  67
  68 enum PeripheralType
  69 {
  70   PERIPHERAL_UNKNOWN = 0,
  71   PERIPHERAL_HID,
  72   PERIPHERAL_NIC,
  73   PERIPHERAL_DISK,
  74   PERIPHERAL_NYXBOARD,
  75   PERIPHERAL_CEC,
  76   PERIPHERAL_BLUETOOTH,
  77   PERIPHERAL_TUNER,
  78   PERIPHERAL_IMON,
  79   PERIPHERAL_JOYSTICK,
  80   PERIPHERAL_KEYBOARD,
  81   PERIPHERAL_MOUSE,
  82 };
  83
  84 class CPeripheral;
  85 using PeripheralPtr = std::shared_ptr<CPeripheral>;
  86 using PeripheralVector = std::vector<PeripheralPtr>;
  87
  88 class CPeripheralAddon;
  89 using PeripheralAddonPtr = std::shared_ptr<CPeripheralAddon>;
  90 using PeripheralAddonVector = std::vector<PeripheralAddonPtr>;
  91
  92 class CEventPollHandle;
  93 using EventPollHandlePtr = std::unique_ptr<CEventPollHandle>;
  94
  95 class CEventLockHandle;
  96 using EventLockHandlePtr = std::unique_ptr<CEventLockHandle>;
  97
  98 struct PeripheralID
  99 {
 100   int m_iVendorId;
 101   int m_iProductId;
 102 };
 103
 104 struct PeripheralDeviceSetting
 105 {
 106   std::shared_ptr<CSetting> m_setting;
 107   int m_order;
 108 };
 109
 110 struct PeripheralDeviceMapping
 111 {
 112   std::vector<PeripheralID> m_PeripheralID;
 113   PeripheralBusType m_busType;
 114   PeripheralType m_class;
 115   std::string m_strDeviceName;
 116   PeripheralType m_mappedTo;
 117   std::map<std::string, PeripheralDeviceSetting> m_settings;
 118 };
 119
 120 class PeripheralTypeTranslator
 121 {
 122 public:
 123   static const char* TypeToString(const PeripheralType type)
 124   {
 125     switch (type)
 126     {
 127       case PERIPHERAL_BLUETOOTH:
 128         return "bluetooth";
 129       case PERIPHERAL_CEC:
 130         return "cec";
 131       case PERIPHERAL_DISK:
 132         return "disk";
 133       case PERIPHERAL_HID:
 134         return "hid";
 135       case PERIPHERAL_NIC:
 136         return "nic";
 137       case PERIPHERAL_NYXBOARD:
 138         return "nyxboard";
 139       case PERIPHERAL_TUNER:
 140         return "tuner";
 141       case PERIPHERAL_IMON:
 142         return "imon";
 143       case PERIPHERAL_JOYSTICK:
 144         return "joystick";
 145       case PERIPHERAL_KEYBOARD:
 146         return "keyboard";
 147       case PERIPHERAL_MOUSE:
 148         return "mouse";
 149       default:
 150         return "unknown";
 151     }
 152   };
 153
 154   static PeripheralType GetTypeFromString(const std::string& strType)
 155   {
 156     std::string strTypeLowerCase(strType);
 157     StringUtils::ToLower(strTypeLowerCase);
 158
 159     if (strTypeLowerCase == "bluetooth")
 160       return PERIPHERAL_BLUETOOTH;
 161     else if (strTypeLowerCase == "cec")
 162       return PERIPHERAL_CEC;
 163     else if (strTypeLowerCase == "disk")
 164       return PERIPHERAL_DISK;
 165     else if (strTypeLowerCase == "hid")
 166       return PERIPHERAL_HID;
 167     else if (strTypeLowerCase == "nic")
 168       return PERIPHERAL_NIC;
 169     else if (strTypeLowerCase == "nyxboard")
 170       return PERIPHERAL_NYXBOARD;
 171     else if (strTypeLowerCase == "tuner")
 172       return PERIPHERAL_TUNER;
 173     else if (strTypeLowerCase == "imon")
 174       return PERIPHERAL_IMON;
 175     else if (strTypeLowerCase == "joystick")
 176       return PERIPHERAL_JOYSTICK;
 177     else if (strTypeLowerCase == "keyboard")
 178       return PERIPHERAL_KEYBOARD;
 179     else if (strTypeLowerCase == "mouse")
 180       return PERIPHERAL_MOUSE;
 181
 182     return PERIPHERAL_UNKNOWN;
 183   };
 184
 185   static const char* BusTypeToString(const PeripheralBusType type)
 186   {
 187     switch (type)
 188     {
 189       case PERIPHERAL_BUS_USB:
 190         return "usb";
 191       case PERIPHERAL_BUS_PCI:
 192         return "pci";
 193       case PERIPHERAL_BUS_CEC:
 194         return "cec";
 195       case PERIPHERAL_BUS_ADDON:
 196         return "addon";
 197 #ifdef TARGET_ANDROID
 198       case PERIPHERAL_BUS_ANDROID:
 199         return "android";
 200 #endif
 201 #if defined(TARGET_DARWIN)
 202       case PERIPHERAL_BUS_GCCONTROLLER:
 203         return "darwin_gccontroller";
 204 #endif
 205       case PERIPHERAL_BUS_APPLICATION:
 206         return "application";
 207       default:
 208         return "unknown";
 209     }
 210   };
 211
 212   static PeripheralBusType GetBusTypeFromString(const std::string& strType)
 213   {
 214     std::string strTypeLowerCase(strType);
 215     StringUtils::ToLower(strTypeLowerCase);
 216
 217     if (strTypeLowerCase == "usb")
 218       return PERIPHERAL_BUS_USB;
 219     else if (strTypeLowerCase == "pci")
 220       return PERIPHERAL_BUS_PCI;
 221     else if (strTypeLowerCase == "cec")
 222       return PERIPHERAL_BUS_CEC;
 223     else if (strTypeLowerCase == "addon")
 224       return PERIPHERAL_BUS_ADDON;
 225 #ifdef TARGET_ANDROID
 226     else if (strTypeLowerCase == "android")
 227       return PERIPHERAL_BUS_ANDROID;
 228 #endif
 229 #if defined(TARGET_DARWIN)
 230     else if (strTypeLowerCase == "darwin_gccontroller")
 231       return PERIPHERAL_BUS_GCCONTROLLER;
 232 #endif
 233     else if (strTypeLowerCase == "application")
 234       return PERIPHERAL_BUS_APPLICATION;
 235
 236     return PERIPHERAL_BUS_UNKNOWN;
 237   };
 238
 239   static const char* FeatureToString(const PeripheralFeature type)
 240   {
 241     switch (type)
 242     {
 243       case FEATURE_HID:
 244         return "HID";
 245       case FEATURE_NIC:
 246         return "NIC";
 247       case FEATURE_DISK:
 248         return "disk";
 249       case FEATURE_NYXBOARD:
 250         return "nyxboard";
 251       case FEATURE_CEC:
 252         return "CEC";
 253       case FEATURE_BLUETOOTH:
 254         return "bluetooth";
 255       case FEATURE_TUNER:
 256         return "tuner";
 257       case FEATURE_IMON:
 258         return "imon";
 259       case FEATURE_JOYSTICK:
 260         return "joystick";
 261       case FEATURE_RUMBLE:
 262         return "rumble";
 263       case FEATURE_POWER_OFF:
 264         return "poweroff";
 265       case FEATURE_KEYBOARD:
 266         return "keyboard";
 267       case FEATURE_MOUSE:
 268         return "mouse";
 269       case FEATURE_UNKNOWN:
 270       default:
 271         return "unknown";
 272     }
 273   };
 274
 275   static PeripheralFeature GetFeatureTypeFromString(const std::string& strType)
 276   {
 277     std::string strTypeLowerCase(strType);
 278     StringUtils::ToLower(strTypeLowerCase);
 279
 280     if (strTypeLowerCase == "hid")
 281       return FEATURE_HID;
 282     else if (strTypeLowerCase == "cec")
 283       return FEATURE_CEC;
 284     else if (strTypeLowerCase == "disk")
 285       return FEATURE_DISK;
 286     else if (strTypeLowerCase == "nyxboard")
 287       return FEATURE_NYXBOARD;
 288     else if (strTypeLowerCase == "bluetooth")
 289       return FEATURE_BLUETOOTH;
 290     else if (strTypeLowerCase == "tuner")
 291       return FEATURE_TUNER;
 292     else if (strTypeLowerCase == "imon")
 293       return FEATURE_IMON;
 294     else if (strTypeLowerCase == "joystick")
 295       return FEATURE_JOYSTICK;
 296     else if (strTypeLowerCase == "rumble")
 297       return FEATURE_RUMBLE;
 298     else if (strTypeLowerCase == "poweroff")
 299       return FEATURE_POWER_OFF;
 300     else if (strTypeLowerCase == "keyboard")
 301       return FEATURE_KEYBOARD;
 302     else if (strTypeLowerCase == "mouse")
 303       return FEATURE_MOUSE;
 304
 305     return FEATURE_UNKNOWN;
 306   };
 307
 308   static int HexStringToInt(const char* strHex)
 309   {
 310     int iVal;
 311     sscanf(strHex, "%x", &iVal);
 312     return iVal;
 313   };
 314
 315   static void FormatHexString(int iVal, std::string& strHexString)
 316   {
 317     if (iVal < 0)
 318       iVal = 0;
 319     if (iVal > 65536)
 320       iVal = 65536;
 321
 322     strHexString = StringUtils::Format("{:04X}", iVal);
 323   };
 324 };
 325
 326 class PeripheralScanResult
 327 {
 328 public:
 329   explicit PeripheralScanResult(const PeripheralBusType busType)
 330     : m_busType(busType), m_mappedBusType(busType)
 331   {
 332   }
 333
 334   PeripheralScanResult(void) = default;
 335
 336   bool operator==(const PeripheralScanResult& right) const
 337   {
 338     return m_iVendorId == right.m_iVendorId && m_iProductId == right.m_iProductId &&
 339            m_type == right.m_type && m_busType == right.m_busType &&
 340            StringUtils::EqualsNoCase(m_strLocation, right.m_strLocation);
 341   }
 342
 343   bool operator!=(const PeripheralScanResult& right) const { return !(*this == right); }
 344
 345   PeripheralType m_type = PERIPHERAL_UNKNOWN;
 346   std::string m_strLocation;
 347   int m_iVendorId = 0;
 348   int m_iProductId = 0;
 349   PeripheralType m_mappedType = PERIPHERAL_UNKNOWN;
 350   std::string m_strDeviceName;
 351   PeripheralBusType m_busType = PERIPHERAL_BUS_UNKNOWN;
 352   PeripheralBusType m_mappedBusType = PERIPHERAL_BUS_UNKNOWN;
 353   unsigned int m_iSequence = 0; // when more than one adapter of the same type is found
 354 };
 355
 356 struct PeripheralScanResults
 357 {
 358   bool GetDeviceOnLocation(const std::string& strLocation, PeripheralScanResult* result) const
 359   {
 360     for (const auto& it : m_results)
 361     {
 362       if (it.m_strLocation == strLocation)
 363       {
 364         *result = it;
 365         return true;
 366       }
 367     }
 368     return false;
 369   }
 370
 371   bool ContainsResult(const PeripheralScanResult& result) const
 372   {
 373     return std::find(m_results.begin(), m_results.end(), result) != m_results.end();
 374   }
 375
 376   std::vector<PeripheralScanResult> m_results;
 377 };
 378
 379 /// \}
 380 } // namespace PERIPHERALS