code.vuplus.com Git - vuplus_xbmc/blob - xbmc/peripherals/PeripheralTypes.h

   1 #pragma once
   2 /*
   3  *      Copyright (C) 2005-2013 Team XBMC
   4  *      http://xbmc.org
   5  *
   6  *  This Program is free software; you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License as published by
   8  *  the Free Software Foundation; either version 2, or (at your option)
   9  *  any later version.
  10  *
  11  *  This Program is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with XBMC; see the file COPYING.  If not, see
  18  *  <http://www.gnu.org/licenses/>.
  19  *
  20  */
  21
  22 #include <map>
  23 #include <stdio.h>
  24 #ifdef _WIN32
  25 #include "PlatformDefs.h"
  26 #endif
  27 #include "utils/StdString.h"
  28
  29 class CSetting;
  30
  31 namespace PERIPHERALS
  32 {
  33   enum PeripheralBusType
  34   {
  35     PERIPHERAL_BUS_UNKNOWN = 0,
  36     PERIPHERAL_BUS_USB,
  37     PERIPHERAL_BUS_PCI,
  38     PERIPHERAL_BUS_RPI
  39   };
  40
  41   enum PeripheralFeature
  42   {
  43     FEATURE_UNKNOWN = 0,
  44     FEATURE_HID,
  45     FEATURE_NIC,
  46     FEATURE_DISK,
  47     FEATURE_NYXBOARD,
  48     FEATURE_CEC,
  49     FEATURE_BLUETOOTH,
  50     FEATURE_TUNER,
  51     FEATURE_IMON
  52   };
  53
  54   enum PeripheralType
  55   {
  56     PERIPHERAL_UNKNOWN = 0,
  57     PERIPHERAL_HID,
  58     PERIPHERAL_NIC,
  59     PERIPHERAL_DISK,
  60     PERIPHERAL_NYXBOARD,
  61     PERIPHERAL_CEC,
  62     PERIPHERAL_BLUETOOTH,
  63     PERIPHERAL_TUNER,
  64     PERIPHERAL_IMON
  65   };
  66
  67   struct PeripheralID
  68   {
  69     int m_iVendorId;
  70     int m_iProductId;
  71   };
  72
  73   struct PeripheralDeviceMapping
  74   {
  75     std::vector<PeripheralID>        m_PeripheralID;
  76     PeripheralBusType                m_busType;
  77     PeripheralType                   m_class;
  78     CStdString                       m_strDeviceName;
  79     PeripheralType                   m_mappedTo;
  80     std::map<CStdString, CSetting *> m_settings;
  81   };
  82
  83   class PeripheralTypeTranslator
  84   {
  85   public:
  86     static const char *TypeToString(const PeripheralType type)
  87     {
  88       switch (type)
  89       {
  90       case PERIPHERAL_BLUETOOTH:
  91         return "bluetooth";
  92       case PERIPHERAL_CEC:
  93         return "cec";
  94       case PERIPHERAL_DISK:
  95         return "disk";
  96       case PERIPHERAL_HID:
  97         return "hid";
  98       case PERIPHERAL_NIC:
  99         return "nic";
 100       case PERIPHERAL_NYXBOARD:
 101         return "nyxboard";
 102       case PERIPHERAL_TUNER:
 103         return "tuner";
 104       case PERIPHERAL_IMON:
 105         return "imon";
 106       default:
 107         return "unknown";
 108       }
 109     };
 110
 111     static PeripheralType GetTypeFromString(const CStdString &strType)
 112     {
 113       CStdString strTypeLowerCase(strType);
 114       strTypeLowerCase.ToLower();
 115
 116       if (strTypeLowerCase.Equals("bluetooth"))
 117         return PERIPHERAL_BLUETOOTH;
 118       else if (strTypeLowerCase.Equals("cec"))
 119         return PERIPHERAL_CEC;
 120       else if (strTypeLowerCase.Equals("disk"))
 121           return PERIPHERAL_DISK;
 122       else if (strTypeLowerCase.Equals("hid"))
 123         return PERIPHERAL_HID;
 124       else if (strTypeLowerCase.Equals("nic"))
 125         return PERIPHERAL_NIC;
 126       else if (strTypeLowerCase.Equals("nyxboard"))
 127         return PERIPHERAL_NYXBOARD;
 128       else if (strTypeLowerCase.Equals("tuner"))
 129         return PERIPHERAL_TUNER;
 130       else if (strTypeLowerCase.Equals("imon"))
 131         return PERIPHERAL_IMON;
 132
 133       return PERIPHERAL_UNKNOWN;
 134     };
 135
 136     static const char *BusTypeToString(const PeripheralBusType type)
 137     {
 138       switch(type)
 139       {
 140       case PERIPHERAL_BUS_USB:
 141         return "usb";
 142       case PERIPHERAL_BUS_PCI:
 143         return "pci";
 144       case PERIPHERAL_BUS_RPI:
 145         return "rpi";
 146       default:
 147         return "unknown";
 148       }
 149     };
 150
 151     static PeripheralBusType GetBusTypeFromString(const CStdString &strType)
 152     {
 153       CStdString strTypeLowerCase(strType);
 154       strTypeLowerCase.ToLower();
 155
 156       if (strTypeLowerCase.Equals("usb"))
 157         return PERIPHERAL_BUS_USB;
 158       else if (strTypeLowerCase.Equals("pci"))
 159         return PERIPHERAL_BUS_PCI;
 160       else if (strTypeLowerCase.Equals("rpi"))
 161         return PERIPHERAL_BUS_RPI;
 162
 163       return PERIPHERAL_BUS_UNKNOWN;
 164     };
 165
 166     static int HexStringToInt(const char *strHex)
 167     {
 168       int iVal;
 169       sscanf(strHex, "%x", &iVal);
 170       return iVal;
 171     };
 172
 173     static void FormatHexString(int iVal, CStdString &strHexString)
 174     {
 175       if (iVal < 0)
 176         iVal = 0;
 177       if (iVal > 65536)
 178         iVal = 65536;
 179
 180       strHexString.Format("%04X", iVal);
 181     };
 182   };
 183 }