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 TARGET_WINDOWS
  25 #include "PlatformDefs.h"
  26 #endif
  27 #include "utils/StdString.h"
  28 #include "utils/StringUtils.h"
  29
  30 class CSetting;
  31
  32 namespace PERIPHERALS
  33 {
  34   enum PeripheralBusType
  35   {
  36     PERIPHERAL_BUS_UNKNOWN = 0,
  37     PERIPHERAL_BUS_USB,
  38     PERIPHERAL_BUS_PCI,
  39     PERIPHERAL_BUS_RPI,
  40     PERIPHERAL_BUS_CEC
  41   };
  42
  43   enum PeripheralFeature
  44   {
  45     FEATURE_UNKNOWN = 0,
  46     FEATURE_HID,
  47     FEATURE_NIC,
  48     FEATURE_DISK,
  49     FEATURE_NYXBOARD,
  50     FEATURE_CEC,
  51     FEATURE_BLUETOOTH,
  52     FEATURE_TUNER,
  53     FEATURE_IMON
  54   };
  55
  56   enum PeripheralType
  57   {
  58     PERIPHERAL_UNKNOWN = 0,
  59     PERIPHERAL_HID,
  60     PERIPHERAL_NIC,
  61     PERIPHERAL_DISK,
  62     PERIPHERAL_NYXBOARD,
  63     PERIPHERAL_CEC,
  64     PERIPHERAL_BLUETOOTH,
  65     PERIPHERAL_TUNER,
  66     PERIPHERAL_IMON
  67   };
  68
  69   struct PeripheralID
  70   {
  71     int m_iVendorId;
  72     int m_iProductId;
  73   };
  74
  75   struct PeripheralDeviceSetting
  76   {
  77     CSetting* m_setting;
  78     int       m_order;
  79   };
  80
  81   struct PeripheralDeviceMapping
  82   {
  83     std::vector<PeripheralID>                     m_PeripheralID;
  84     PeripheralBusType                             m_busType;
  85     PeripheralType                                m_class;
  86     CStdString                                    m_strDeviceName;
  87     PeripheralType                                m_mappedTo;
  88     std::map<CStdString, PeripheralDeviceSetting> m_settings;
  89   };
  90
  91   class PeripheralTypeTranslator
  92   {
  93   public:
  94     static const char *TypeToString(const PeripheralType type)
  95     {
  96       switch (type)
  97       {
  98       case PERIPHERAL_BLUETOOTH:
  99         return "bluetooth";
 100       case PERIPHERAL_CEC:
 101         return "cec";
 102       case PERIPHERAL_DISK:
 103         return "disk";
 104       case PERIPHERAL_HID:
 105         return "hid";
 106       case PERIPHERAL_NIC:
 107         return "nic";
 108       case PERIPHERAL_NYXBOARD:
 109         return "nyxboard";
 110       case PERIPHERAL_TUNER:
 111         return "tuner";
 112       case PERIPHERAL_IMON:
 113         return "imon";
 114       default:
 115         return "unknown";
 116       }
 117     };
 118
 119     static PeripheralType GetTypeFromString(const CStdString &strType)
 120     {
 121       CStdString strTypeLowerCase(strType);
 122       StringUtils::ToLower(strTypeLowerCase);
 123
 124       if (strTypeLowerCase.Equals("bluetooth"))
 125         return PERIPHERAL_BLUETOOTH;
 126       else if (strTypeLowerCase.Equals("cec"))
 127         return PERIPHERAL_CEC;
 128       else if (strTypeLowerCase.Equals("disk"))
 129           return PERIPHERAL_DISK;
 130       else if (strTypeLowerCase.Equals("hid"))
 131         return PERIPHERAL_HID;
 132       else if (strTypeLowerCase.Equals("nic"))
 133         return PERIPHERAL_NIC;
 134       else if (strTypeLowerCase.Equals("nyxboard"))
 135         return PERIPHERAL_NYXBOARD;
 136       else if (strTypeLowerCase.Equals("tuner"))
 137         return PERIPHERAL_TUNER;
 138       else if (strTypeLowerCase.Equals("imon"))
 139         return PERIPHERAL_IMON;
 140
 141       return PERIPHERAL_UNKNOWN;
 142     };
 143
 144     static const char *BusTypeToString(const PeripheralBusType type)
 145     {
 146       switch(type)
 147       {
 148       case PERIPHERAL_BUS_USB:
 149         return "usb";
 150       case PERIPHERAL_BUS_PCI:
 151         return "pci";
 152       case PERIPHERAL_BUS_RPI:
 153         return "rpi";
 154       case PERIPHERAL_BUS_CEC:
 155         return "cec";
 156       default:
 157         return "unknown";
 158       }
 159     };
 160
 161     static PeripheralBusType GetBusTypeFromString(const CStdString &strType)
 162     {
 163       CStdString strTypeLowerCase(strType);
 164       StringUtils::ToLower(strTypeLowerCase);
 165
 166       if (strTypeLowerCase.Equals("usb"))
 167         return PERIPHERAL_BUS_USB;
 168       else if (strTypeLowerCase.Equals("pci"))
 169         return PERIPHERAL_BUS_PCI;
 170       else if (strTypeLowerCase.Equals("rpi"))
 171         return PERIPHERAL_BUS_RPI;
 172       else if (strTypeLowerCase.Equals("cec"))
 173         return PERIPHERAL_BUS_CEC;
 174
 175       return PERIPHERAL_BUS_UNKNOWN;
 176     };
 177
 178     static int HexStringToInt(const char *strHex)
 179     {
 180       int iVal;
 181       sscanf(strHex, "%x", &iVal);
 182       return iVal;
 183     };
 184
 185     static void FormatHexString(int iVal, CStdString &strHexString)
 186     {
 187       if (iVal < 0)
 188         iVal = 0;
 189       if (iVal > 65536)
 190         iVal = 65536;
 191
 192       strHexString = StringUtils::Format("%04X", iVal);
 193     };
 194   };
 195
 196   class PeripheralScanResult
 197   {
 198   public:
 199     PeripheralScanResult(const PeripheralBusType busType) :
 200       m_type(PERIPHERAL_UNKNOWN),
 201       m_iVendorId(0),
 202       m_iProductId(0),
 203       m_mappedType(PERIPHERAL_UNKNOWN),
 204       m_busType(busType),
 205       m_mappedBusType(busType),
 206       m_iSequence(0) {}
 207
 208     PeripheralScanResult(void) :
 209       m_type(PERIPHERAL_UNKNOWN),
 210       m_iVendorId(0),
 211       m_iProductId(0),
 212       m_mappedType(PERIPHERAL_UNKNOWN),
 213       m_busType(PERIPHERAL_BUS_UNKNOWN),
 214       m_mappedBusType(PERIPHERAL_BUS_UNKNOWN),
 215       m_iSequence(0) {}
 216
 217     bool operator ==(const PeripheralScanResult& right) const
 218     {
 219       return m_iVendorId  == right.m_iVendorId &&
 220              m_iProductId == right.m_iProductId &&
 221              m_type       == right.m_type &&
 222              m_busType    == right.m_busType &&
 223              m_strLocation.Equals(right.m_strLocation);
 224     }
 225
 226     bool operator !=(const PeripheralScanResult& right) const
 227     {
 228       return !(*this == right);
 229     }
 230
 231     PeripheralType    m_type;
 232     CStdString        m_strLocation;
 233     int               m_iVendorId;
 234     int               m_iProductId;
 235     PeripheralType    m_mappedType;
 236     CStdString        m_strDeviceName;
 237     PeripheralBusType m_busType;
 238     PeripheralBusType m_mappedBusType;
 239     unsigned int      m_iSequence; // when more than one adapter of the same type is found
 240   };
 241
 242   struct PeripheralScanResults
 243   {
 244     bool GetDeviceOnLocation(const CStdString& strLocation, PeripheralScanResult* result) const
 245     {
 246       for (std::vector<PeripheralScanResult>::const_iterator it = m_results.begin(); it != m_results.end(); it++)
 247       {
 248         if ((*it).m_strLocation == strLocation)
 249         {
 250           *result = *it;
 251           return true;
 252         }
 253       }
 254       return false;
 255     }
 256
 257     bool ContainsResult(const PeripheralScanResult& result) const
 258     {
 259       return std::find(m_results.begin(), m_results.end(), result) != m_results.end();
 260     }
 261
 262     std::vector<PeripheralScanResult> m_results;
 263   };
 264 }