better generic HID differentiation; smash udev working

include/inputdev/CDeviceBase.hpp

@@ -27,14 +27,14 @@ public:
     virtual void deviceError(const char* error) {fprintf(stderr, "%s\n", error);}
     
     /* Low-Level API */
-    bool sendInterruptTransfer(uint8_t pipe, const uint8_t* data, size_t length);
-    size_t receiveInterruptTransfer(uint8_t pipe, uint8_t* data, size_t length);
+    bool sendUSBInterruptTransfer(uint8_t pipe, const uint8_t* data, size_t length);
+    size_t receiveUSBInterruptTransfer(uint8_t pipe, uint8_t* data, size_t length);
     virtual void initialCycle() {}
     virtual void transferCycle() {}
     virtual void finalCycle() {}
 
     /* High-Level API */
-    bool sendReport(const uint8_t* data, size_t length);
+    bool sendHIDReport(const uint8_t* data, size_t length);
     virtual size_t receiveReport(uint8_t* data, size_t length) {return 0;}
     
 };

include/inputdev/CDeviceFinder.hpp

@@ -44,7 +44,7 @@ private:
             return true;
         return false;
     }
-    inline void _insertToken(CDeviceToken&& token)
+    inline bool _insertToken(CDeviceToken&& token)
     {
         if (SDeviceSignature::DeviceMatchToken(token, m_types)) {
             m_tokensLock.lock();
@@ -52,7 +52,9 @@ private:
             m_tokens.insert(std::make_pair(token.getDevicePath(), std::move(token)));
             m_tokensLock.unlock();
             deviceConnected(inseredTok.first->second);
+            return true;
         }
+        return false;
     }
     inline void _removeToken(const std::string& path)
     {

include/inputdev/CDeviceToken.hpp

@@ -10,6 +10,17 @@ namespace boo
 
 class CDeviceToken
 {
+public:
+    enum TDeviceType
+    {
+        DEVTYPE_NONE       = 0,
+        DEVTYPE_USB        = 1,
+        DEVTYPE_BLUETOOTH  = 2,
+        DEVTYPE_GENERICHID = 3
+    };
+
+private:
+    TDeviceType m_devType;
     unsigned m_vendorId;
     unsigned m_productId;
     std::string m_vendorName;
@@ -28,10 +39,11 @@ class CDeviceToken
     }
 
 public:
+
     CDeviceToken(const CDeviceToken&) = delete;
     CDeviceToken(CDeviceToken&&) = default;
-    inline CDeviceToken(unsigned vid, unsigned pid, const char* vname, const char* pname, const char* path)
-    : m_vendorId(vid), m_productId(pid), m_devPath(path), m_connectedDev(NULL)
+    inline CDeviceToken(enum TDeviceType devType, unsigned vid, unsigned pid, const char* vname, const char* pname, const char* path)
+    : m_devType(devType), m_vendorId(vid), m_productId(pid), m_devPath(path), m_connectedDev(NULL)
     {
         if (vname)
             m_vendorName = vname;
@@ -39,6 +51,7 @@ public:
             m_productName = pname;
     }
     
+    inline TDeviceType getDeviceType() const {return m_devType;}
     inline unsigned getVendorId() const {return m_vendorId;}
     inline unsigned getProductId() const {return m_productId;}
     inline const std::string& getVendorName() const {return m_vendorName;}

include/inputdev/CDolphinSmashAdapter.hpp

@@ -52,7 +52,6 @@ class CDolphinSmashAdapter final : public CDeviceBase
     uint8_t m_knownControllers;
     uint8_t m_rumbleRequest;
     uint8_t m_rumbleState;
-    bool m_didHandshake;
     void deviceDisconnected();
     void initialCycle();
     void transferCycle();

include/inputdev/CGenericPad.hpp

@@ -1,9 +1,20 @@
 #ifndef CGENERICPAD_HPP
 #define CGENERICPAD_HPP
 
+#include "CDeviceBase.hpp"
+
 namespace boo
 {
 
+class CGenericPad final : public CDeviceBase
+{
+public:
+    CGenericPad(CDeviceToken* token);
+    ~CGenericPad();
+
+    void deviceDisconnected();
+};
+
 }
 
 #endif // CGENERICPAD_HPP

include/inputdev/SDeviceSignature.hpp

@@ -16,17 +16,16 @@ struct SDeviceSignature
     typedef std::function<CDeviceBase*(CDeviceToken*)> TFactoryLambda;
     const char* m_name;
     unsigned m_vid, m_pid;
-    bool m_lowLevel;
     TFactoryLambda m_factory;
     SDeviceSignature() : m_name(NULL) {} /* Sentinel constructor */
-    SDeviceSignature(const char* name, unsigned vid, unsigned pid, bool lowLevel, TFactoryLambda&& factory)
-        : m_name(name), m_vid(vid), m_pid(pid), m_lowLevel(lowLevel), m_factory(factory) {}
+    SDeviceSignature(const char* name, unsigned vid, unsigned pid, TFactoryLambda&& factory)
+        : m_name(name), m_vid(vid), m_pid(pid), m_factory(factory) {}
     static bool DeviceMatchToken(const CDeviceToken& token, const TDeviceSignatureSet& sigSet);
     static CDeviceBase* DeviceNew(CDeviceToken& token);
 };
 
-#define DEVICE_SIG(name, vid, pid, lowLevel) \
-    SDeviceSignature(#name, vid, pid, lowLevel, [](CDeviceToken* tok) -> CDeviceBase* {return new name(tok);})
+#define DEVICE_SIG(name, vid, pid) \
+    SDeviceSignature(#name, vid, pid, [](CDeviceToken* tok) -> CDeviceBase* {return new name(tok);})
 #define DEVICE_SIG_SENTINEL() SDeviceSignature()
 
 extern const SDeviceSignature BOO_DEVICE_SIGS[];