Major refactor for better modularity

2025-12-09 05:27:58 +00:00 · 2015-08-18 09:40:26 -10:00
parent 3007714b5a
commit e56b8539bf
62 changed files with 275 additions and 791 deletions
--- a/lib/inputdev/DeviceBase.cpp
+++ b/lib/inputdev/DeviceBase.cpp
@@ -5,17 +5,17 @@
 namespace boo
 {

-CDeviceBase::CDeviceBase(CDeviceToken* token)
+DeviceBase::DeviceBase(DeviceToken* token)
 : m_token(token), m_hidDev(NULL)
 {
 }

-CDeviceBase::~CDeviceBase()
+DeviceBase::~DeviceBase()
 {
    delete m_hidDev;
 }

-void CDeviceBase::_deviceDisconnected()
+void DeviceBase::_deviceDisconnected()
 {
    deviceDisconnected();
    m_token = NULL;
@@ -27,27 +27,27 @@ void CDeviceBase::_deviceDisconnected()
    }
 }

-void CDeviceBase::closeDevice()
+void DeviceBase::closeDevice()
 {
    if (m_token)
        m_token->_deviceClose();
 }

-bool CDeviceBase::sendUSBInterruptTransfer(const uint8_t* data, size_t length)
+bool DeviceBase::sendUSBInterruptTransfer(const uint8_t* data, size_t length)
 {
    if (m_hidDev)
        return m_hidDev->_sendUSBInterruptTransfer(data, length);
    return false;
 }

-size_t CDeviceBase::receiveUSBInterruptTransfer(uint8_t* data, size_t length)
+size_t DeviceBase::receiveUSBInterruptTransfer(uint8_t* data, size_t length)
 {
    if (m_hidDev)
        return m_hidDev->_receiveUSBInterruptTransfer(data, length);
    return false;
 }

-bool CDeviceBase::sendHIDReport(const uint8_t* data, size_t length)
+bool DeviceBase::sendHIDReport(const uint8_t* data, size_t length)
 {
    if (m_hidDev)
        return m_hidDev->_sendHIDReport(data, length);
--- a/lib/inputdev/DeviceSignature.cpp
+++ b/lib/inputdev/DeviceSignature.cpp
@@ -6,14 +6,14 @@
 namespace boo
 {

-extern const SDeviceSignature BOO_DEVICE_SIGS[];
+extern const DeviceSignature BOO_DEVICE_SIGS[];


-bool SDeviceSignature::DeviceMatchToken(const CDeviceToken& token, const TDeviceSignatureSet& sigSet)
+bool DeviceSignature::DeviceMatchToken(const DeviceToken& token, const TDeviceSignatureSet& sigSet)
 {
-    if (token.getDeviceType() == CDeviceToken::DEVTYPE_GENERICHID)
+    if (token.getDeviceType() == DeviceToken::DEVTYPE_GENERICHID)
        return true;
-    for (const SDeviceSignature* sig : sigSet)
+    for (const DeviceSignature* sig : sigSet)
    {
        if (sig->m_vid == token.getVendorId() && sig->m_pid == token.getProductId())
            return true;
@@ -21,15 +21,15 @@ bool SDeviceSignature::DeviceMatchToken(const CDeviceToken& token, const TDevice
    return false;
 }

-IHIDDevice* IHIDDeviceNew(CDeviceToken& token, CDeviceBase& devImp);
-CDeviceBase* SDeviceSignature::DeviceNew(CDeviceToken& token)
+IHIDDevice* IHIDDeviceNew(DeviceToken& token, DeviceBase& devImp);
+DeviceBase* DeviceSignature::DeviceNew(DeviceToken& token)
 {
-    CDeviceBase* retval = NULL;
+    DeviceBase* retval = NULL;

    /* Early-return for generic HID devices */
-    if (token.getDeviceType() == CDeviceToken::DEVTYPE_GENERICHID)
+    if (token.getDeviceType() == DeviceToken::DEVTYPE_GENERICHID)
    {
-        retval = new CGenericPad(&token);
+        retval = new GenericPad(&token);
        if (!retval)
            return NULL;

@@ -44,8 +44,8 @@ CDeviceBase* SDeviceSignature::DeviceNew(CDeviceToken& token)
    }

    /* Otherwise perform signature-matching to find the appropriate device-factory */
-    const SDeviceSignature* foundSig = NULL;
-    const SDeviceSignature* sigIter = BOO_DEVICE_SIGS;
+    const DeviceSignature* foundSig = NULL;
+    const DeviceSignature* sigIter = BOO_DEVICE_SIGS;
    unsigned targetVid = token.getVendorId();
    unsigned targetPid = token.getProductId();
    while (sigIter->m_name)
--- a/lib/inputdev/DolphinSmashAdapter.cpp
+++ b/lib/inputdev/DolphinSmashAdapter.cpp
@@ -9,8 +9,8 @@ namespace boo
 * Reference: https://github.com/ToadKing/wii-u-gc-adapter/blob/master/wii-u-gc-adapter.c
 */

-CDolphinSmashAdapter::CDolphinSmashAdapter(CDeviceToken* token)
-: CDeviceBase(token),
+DolphinSmashAdapter::DolphinSmashAdapter(DeviceToken* token)
+: DeviceBase(token),
  m_callback(NULL),
  m_knownControllers(0),
  m_rumbleRequest(0),
@@ -18,7 +18,7 @@ CDolphinSmashAdapter::CDolphinSmashAdapter(CDeviceToken* token)
 {
 }

-CDolphinSmashAdapter::~CDolphinSmashAdapter()
+DolphinSmashAdapter::~DolphinSmashAdapter()
 {
 }

@@ -36,9 +36,9 @@ static inline EDolphinControllerType parseType(unsigned char status)
 }

 static inline EDolphinControllerType
-parseState(SDolphinControllerState* stateOut, uint8_t* payload, bool& rumble)
+parseState(DolphinControllerState* stateOut, uint8_t* payload, bool& rumble)
 {
-    memset(stateOut, 0, sizeof(SDolphinControllerState));
+    memset(stateOut, 0, sizeof(DolphinControllerState));
    unsigned char status = payload[0];
    EDolphinControllerType type = parseType(status);
    
@@ -56,13 +56,13 @@ parseState(SDolphinControllerState* stateOut, uint8_t* payload, bool& rumble)
    return type;
 }

-void CDolphinSmashAdapter::initialCycle()
+void DolphinSmashAdapter::initialCycle()
 {
    uint8_t handshakePayload[] = {0x13};
    sendUSBInterruptTransfer(handshakePayload, sizeof(handshakePayload));
 }

-void CDolphinSmashAdapter::transferCycle()
+void DolphinSmashAdapter::transferCycle()
 {
    uint8_t payload[37];
    size_t recvSz = receiveUSBInterruptTransfer(payload, sizeof(payload));
@@ -78,7 +78,7 @@ void CDolphinSmashAdapter::transferCycle()
    uint8_t rumbleMask = 0;
    for (int i=0 ; i<4 ; i++, controller += 9)
    {
-        SDolphinControllerState state;
+        DolphinControllerState state;
        bool rumble = false;
        EDolphinControllerType type = parseState(&state, controller, rumble);
        if (type && !(m_knownControllers & 1<<i))
@@ -113,13 +113,13 @@ void CDolphinSmashAdapter::transferCycle()
    }
 }

-void CDolphinSmashAdapter::finalCycle()
+void DolphinSmashAdapter::finalCycle()
 {
    uint8_t rumbleMessage[5] = {0x11, 0, 0, 0, 0};
    sendUSBInterruptTransfer(rumbleMessage, sizeof(rumbleMessage));
 }

-void CDolphinSmashAdapter::deviceDisconnected()
+void DolphinSmashAdapter::deviceDisconnected()
 {
    
 }
--- a/lib/inputdev/GenericPad.cpp
+++ b/lib/inputdev/GenericPad.cpp
@@ -4,18 +4,18 @@
 namespace boo
 {

-CGenericPad::CGenericPad(CDeviceToken* token)
- : CDeviceBase(token)
+GenericPad::GenericPad(DeviceToken* token)
+ : DeviceBase(token)
 {

 }

-CGenericPad::~CGenericPad()
+GenericPad::~GenericPad()
 {

 }

-void CGenericPad::deviceDisconnected()
+void GenericPad::deviceDisconnected()
 {

 }
--- a/lib/inputdev/HIDDeviceUdev.cpp
+++ b/lib/inputdev/HIDDeviceUdev.cpp
@@ -24,10 +24,10 @@ udev* GetUdev();
 * Reference: http://tali.admingilde.org/linux-docbook/usb/ch07s06.html
 */

-class CHIDDeviceUdev final : public IHIDDevice
+class HIDDeviceUdev final : public IHIDDevice
 {
-    CDeviceToken& m_token;
-    CDeviceBase& m_devImp;
+    DeviceToken& m_token;
+    DeviceBase& m_devImp;

    int m_devFd = 0;
    unsigned m_usbIntfInPipe = 0;
@@ -74,7 +74,7 @@ class CHIDDeviceUdev final : public IHIDDevice
        return 0;
    }
    
-    static void _threadProcUSBLL(CHIDDeviceUdev* device)
+    static void _threadProcUSBLL(HIDDeviceUdev* device)
    {
        unsigned i;
        char errStr[256];
@@ -149,7 +149,7 @@ class CHIDDeviceUdev final : public IHIDDevice
        
    }

-    static void _threadProcBTLL(CHIDDeviceUdev* device)
+    static void _threadProcBTLL(HIDDeviceUdev* device)
    {
        std::unique_lock<std::mutex> lk(device->m_initMutex);
        udev_device* udevDev = udev_device_new_from_syspath(GetUdev(), device->m_devPath.c_str());
@@ -168,7 +168,7 @@ class CHIDDeviceUdev final : public IHIDDevice
        udev_device_unref(udevDev);
    }
    
-    static void _threadProcHID(CHIDDeviceUdev* device)
+    static void _threadProcHID(HIDDeviceUdev* device)
    {
        std::unique_lock<std::mutex> lk(device->m_initMutex);
        udev_device* udevDev = udev_device_new_from_syspath(GetUdev(), device->m_devPath.c_str());
@@ -201,19 +201,19 @@ class CHIDDeviceUdev final : public IHIDDevice
    
 public:
    
-    CHIDDeviceUdev(CDeviceToken& token, CDeviceBase& devImp)
+    HIDDeviceUdev(DeviceToken& token, DeviceBase& devImp)
    : m_token(token),
      m_devImp(devImp),
      m_devPath(token.getDevicePath())
    {
        devImp.m_hidDev = this;
        std::unique_lock<std::mutex> lk(m_initMutex);
-        CDeviceToken::TDeviceType dType = token.getDeviceType();
-        if (dType == CDeviceToken::DEVTYPE_USB)
+        DeviceToken::TDeviceType dType = token.getDeviceType();
+        if (dType == DeviceToken::DEVTYPE_USB)
            m_thread = new std::thread(_threadProcUSBLL, this);
-        else if (dType == CDeviceToken::DEVTYPE_BLUETOOTH)
+        else if (dType == DeviceToken::DEVTYPE_BLUETOOTH)
            m_thread = new std::thread(_threadProcBTLL, this);
-        else if (dType == CDeviceToken::DEVTYPE_GENERICHID)
+        else if (dType == DeviceToken::DEVTYPE_GENERICHID)
            m_thread = new std::thread(_threadProcHID, this);
        else
        {
@@ -223,7 +223,7 @@ public:
        m_initCond.wait(lk);
    }
    
-    ~CHIDDeviceUdev()
+    ~HIDDeviceUdev()
    {
        m_runningTransferLoop = false;
        m_thread->join();
@@ -233,9 +233,9 @@ public:

 };

-IHIDDevice* IHIDDeviceNew(CDeviceToken& token, CDeviceBase& devImp)
+IHIDDevice* IHIDDeviceNew(DeviceToken& token, DeviceBase& devImp)
 {
-    return new CHIDDeviceUdev(token, devImp);
+    return new HIDDeviceUdev(token, devImp);
 }

 }
--- a/lib/inputdev/HIDListenerUdev.cpp
+++ b/lib/inputdev/HIDListenerUdev.cpp
@@ -2,11 +2,8 @@
 #include "inputdev/DeviceFinder.hpp"
 #include <libudev.h>
 #include <string.h>
-<<<<<<< HEAD:lib/inputdev/HIDListenerUdev.cpp
 #include <stdio.h>
-=======
 #include <signal.h>
->>>>>>> 6ce2472b27211a40e1d78f424f09cf26ba5e3281:src/inputdev/CHIDListenerUdev.cpp
 #include <thread>

 namespace boo
@@ -20,16 +17,16 @@ udev* GetUdev()
    return UDEV_INST;
 }

-class CHIDListenerUdev final : public IHIDListener
+class HIDListenerUdev final : public IHIDListener
 {
-    CDeviceFinder& m_finder;
+    DeviceFinder& m_finder;
    
    udev_monitor* m_udevMon;
    std::thread* m_udevThread;
    bool m_udevRunning;
    bool m_scanningEnabled;
    
-    static void deviceConnected(CHIDListenerUdev* listener,
+    static void deviceConnected(HIDListenerUdev* listener,
                                udev_device* device)
    {
        if (!listener->m_scanningEnabled)
@@ -37,11 +34,11 @@ class CHIDListenerUdev final : public IHIDListener

        /* Filter to USB/BT */
        const char* dt = udev_device_get_devtype(device);
-        CDeviceToken::TDeviceType type;
+        DeviceToken::TDeviceType type;
        if (!strcmp(dt, "usb_device"))
-            type = CDeviceToken::DEVTYPE_USB;
+            type = DeviceToken::DEVTYPE_USB;
        else if (!strcmp(dt, "bluetooth_device"))
-            type = CDeviceToken::DEVTYPE_BLUETOOTH;
+            type = DeviceToken::DEVTYPE_BLUETOOTH;
        else
            return;

@@ -81,13 +78,13 @@ class CHIDListenerUdev final : public IHIDListener
        if (producte)
            product = udev_list_entry_get_value(producte);

-        if (!listener->m_finder._insertToken(CDeviceToken(type, vid, pid, manuf, product, devPath)))
+        if (!listener->m_finder._insertToken(DeviceToken(type, vid, pid, manuf, product, devPath)))
        {
            /* Matched-insertion failed; see if generic HID interface is available */
            udev_list_entry* devInterfaces = NULL;
-            if (type == CDeviceToken::DEVTYPE_USB)
+            if (type == DeviceToken::DEVTYPE_USB)
                devInterfaces = udev_list_entry_get_by_name(attrs, "ID_USB_INTERFACES");
-            else if (type == CDeviceToken::DEVTYPE_BLUETOOTH)
+            else if (type == DeviceToken::DEVTYPE_BLUETOOTH)
                devInterfaces = udev_list_entry_get_by_name(attrs, "ID_BLUETOOTH_INTERFACES");
            if (devInterfaces)
            {
@@ -104,7 +101,7 @@ class CHIDListenerUdev final : public IHIDListener
                    {
                        const char* hidPath = udev_list_entry_get_name(hidEnt);
                        if (!listener->m_finder._hasToken(hidPath))
-                            listener->m_finder._insertToken(CDeviceToken(CDeviceToken::DEVTYPE_GENERICHID,
+                            listener->m_finder._insertToken(DeviceToken(DeviceToken::DEVTYPE_GENERICHID,
                                                                         vid, pid, manuf, product, hidPath));
                    }
                    udev_enumerate_unref(hidEnum);
@@ -113,14 +110,14 @@ class CHIDListenerUdev final : public IHIDListener
        }
    }
    
-    static void deviceDisconnected(CHIDListenerUdev* listener,
+    static void deviceDisconnected(HIDListenerUdev* listener,
                                   udev_device* device)
    {
        const char* devPath = udev_device_get_syspath(device);
        listener->m_finder._removeToken(devPath);
    }

-    static void _udevProc(CHIDListenerUdev* listener)
+    static void _udevProc(HIDListenerUdev* listener)
    {
        udev_monitor_enable_receiving(listener->m_udevMon);
        int fd = udev_monitor_get_fd(listener->m_udevMon);
@@ -144,7 +141,7 @@ class CHIDListenerUdev final : public IHIDListener
    }

 public:
-    CHIDListenerUdev(CDeviceFinder& finder)
+    HIDListenerUdev(DeviceFinder& finder)
    : m_finder(finder)
    {
        
@@ -170,7 +167,7 @@ public:
        
    }
    
-    ~CHIDListenerUdev()
+    ~HIDListenerUdev()
    {
        m_udevRunning = false;
        pthread_kill(m_udevThread->native_handle(), SIGINT);
@@ -216,9 +213,9 @@ public:
    
 };

-IHIDListener* IHIDListenerNew(CDeviceFinder& finder)
+IHIDListener* IHIDListenerNew(DeviceFinder& finder)
 {
-    return new CHIDListenerUdev(finder);
+    return new HIDListenerUdev(finder);
 }

 }
--- a/lib/inputdev/IHIDDevice.hpp
+++ b/lib/inputdev/IHIDDevice.hpp
@@ -8,7 +8,7 @@ namespace boo

 class IHIDDevice
 {
-    friend class CDeviceBase;
+    friend class DeviceBase;
    virtual void _deviceDisconnected()=0;
    virtual bool _sendUSBInterruptTransfer(const uint8_t* data, size_t length)=0;
    virtual size_t _receiveUSBInterruptTransfer(uint8_t* data, size_t length)=0;