vrpn_HumanInterface.h

// vrpn_HumanInterface.h: Generic USB HID driver I/O interface.
//    This implementation uses the cross-platform HIDAPI library
//    from http://www.signal11.us/oss/hidapi/ to handle the cross-
//    platform HID device interface.  The older version had a different
//    implementation for each platform; it has been discontinued as
//    of version 7.29.
 
/* For looking at the types of inforamtion that a device can send, we can use
   the following (from a post at microchip.com/forums)
 
 mcuee@Ubuntu804:~$ lsusb
 Bus 002 Device 010: ID 04f2:0760 Chicony Electronics Co., Ltd
 Bus 002 Device 007: ID ffff:0005
 Bus 002 Device 005: ID 046d:c054 Logitech, Inc.
 Bus 002 Device 004: ID 14c0:0008
 Bus 002 Device 003: ID 1947:0033
 Bus 002 Device 002: ID 058f:9360 Alcor Micro Corp. 8-in-1 Media Card Reader
 Bus 002 Device 001: ID 0000:0000
 Bus 001 Device 001: ID 0000:0000
 mcuee@Ubuntu804:~$ sudo libhid-detach-device 04f2:0760
 Trying to detach HID with IDs 04f2:0760... done.
 mcuee@Ubuntu804:~$ sudo lsusb -vvv | more
 
 Bus 002 Device 010: ID 04f2:0760 Chicony Electronics Co., Ltd
 Device Descriptor:
   bLength                18
   bDescriptorType         1
*/
 
#ifndef VRPN_HUMANINTERFACE_H
#define VRPN_HUMANINTERFACE_H
 
#include <stddef.h> // for size_t
#include <wchar.h> // for wcscmp
 
#include "vrpn_Configure.h" // for VRPN_API, VRPN_USE_HID, etc
#include "vrpn_Types.h" // for vrpn_uint16, vrpn_uint8
#include "vrpn_OwningPtr.h"
 
struct vrpn_HIDDEVINFO {
    vrpn_uint16 vendor;     // USB Vendor ID
    vrpn_uint16 product;    // USB Product ID
 wchar_t *serial_number; // USB device serial number
 wchar_t *manufacturer_string;
 wchar_t *product_string;
 int interface_number;
 const char *path;
};
 
// General interface for device enumeration:
// vrpn_HidInterface will connect to the first device your class accepts.
// The reset() method will be called before starting a new enumueration, in
// case you want to connect to the second or third device found that matches
// some criterion.  There are some example HID acceptors at the end of
// this file.
class VRPN_API vrpn_HidAcceptor {
public:
 virtual ~vrpn_HidAcceptor() {}
 virtual bool accept(const vrpn_HIDDEVINFO &device) = 0;
 virtual void reset() {}
};
 
#if defined(VRPN_USE_HID)
 
// Forward declarations for hid_device
struct hid_device_;
typedef struct hid_device_ hid_device;
 
// Main VRPN API for HID devices
class VRPN_API vrpn_HidInterface {
public:
 vrpn_HidInterface(
 vrpn_HidAcceptor *acceptor,
        vrpn_uint16 vendor = 0,
        vrpn_uint16 product = 0,
        hid_device *device = NULL);
 
 vrpn_HidInterface(
 vrpn_HidAcceptor *acceptor,
        hid_device *device);
 
 vrpn_HidInterface(
 const char *device_path,
 vrpn_HidAcceptor *acceptor,
        vrpn_uint16 vendor = 0,
        vrpn_uint16 product = 0);
 
 virtual ~vrpn_HidInterface();
 
 virtual bool connected() const;
 
 virtual void update();
 
 virtual bool reconnect();
 
    vrpn_uint16 vendor() const;
 
    vrpn_uint16 product() const;
 
 int interface_number() const;
 
protected:
 virtual void on_data_received(size_t bytes, vrpn_uint8 *buffer) = 0;
 
 void send_data(size_t bytes, const vrpn_uint8 *buffer);
 
 void send_feature_report(size_t bytes, const vrpn_uint8 *buffer);
 
 int get_feature_report(size_t bytes, vrpn_uint8 *buffer);
 
 vrpn_HidAcceptor *m_acceptor;
 
 bool m_working;
    vrpn_uint16 m_vendor;
    vrpn_uint16 m_product;
 int m_interface;
 
 // These are passed in the constructor and kept for use by the
 // reconnect() method.  Strictly speaking, they are redundant
 // because you can put an acceptor that only matches the given
 // vendor and product ID.  However, at least one HID device on at
 // least one server times out when repeatedly polled for its
 // info during hid_enumerate() if we don't check for the correct
 // vendor and product ID and ignore it, so we made this an optional
 // setting in the constructor.
    vrpn_uint16 m_vendor_sought;  
    vrpn_uint16 m_product_sought; 
 
private:
 // finishing setup of a device, either passed in or recently opened.
 bool finish_setup();
 // Report an error message, which will be augmented with a HIDAPI error
 // message if one is available and desired
 void print_error(const char *function, const char *msg,
 bool askHIDAPI = true) const;
 // Performs just the HIDAPI portion of print_error.
 void print_hidapi_error(const char *function) const;
    hid_device *m_device; 
};
 
#endif // VRPN_USE_HID
 
// Some sample acceptors
 
class VRPN_API vrpn_HidAlwaysAcceptor : public vrpn_HidAcceptor {
public:
 bool accept(const vrpn_HIDDEVINFO &) { return true; }
};
 
class VRPN_API vrpn_HidProductAcceptor : public vrpn_HidAcceptor {
public:
 vrpn_HidProductAcceptor(vrpn_uint16 vendorId, vrpn_uint16 productId)
        : product(productId)
        , vendor(vendorId)
    {
    }
 bool accept(const vrpn_HIDDEVINFO &device)
    {
 return (device.vendor == vendor) && (device.product == product);
    }
 
private:
    vrpn_uint16 product, vendor;
};
 
class VRPN_API vrpn_HidSerialNumberAcceptor : public vrpn_HidAcceptor {
public:
 vrpn_HidSerialNumberAcceptor(const wchar_t *serial)
        : devNum(serial)
    {
    }
 bool accept(const vrpn_HIDDEVINFO &device)
    {
 return !wcscmp(devNum, device.serial_number);
    }
 
private:
 const wchar_t *devNum;
};
 
class VRPN_API vrpn_HidInterfaceNumberAcceptor : public vrpn_HidAcceptor {
public:
 vrpn_HidInterfaceNumberAcceptor(int iface)
        : _iface(iface)
    {
    }
 bool accept(const vrpn_HIDDEVINFO &device)
    {
 return _iface == device.interface_number;
    }
 
private:
 const int _iface;
};
 
class VRPN_API vrpn_HidNthMatchAcceptor : public vrpn_HidAcceptor {
public:
 vrpn_HidNthMatchAcceptor(size_t index, vrpn_HidAcceptor *acceptor)
        : target(index)
        , found(0)
        , delegate(acceptor)
    {
    }
 
 virtual ~vrpn_HidNthMatchAcceptor() {}
 
 bool accept(const vrpn_HIDDEVINFO &device)
    {
 return delegate->accept(device) && (found++ == target);
    }
 void reset()
    {
        found = 0;
        delegate->reset();
    }
 
private:
 size_t target, found;
 vrpn::OwningPtr<vrpn_HidAcceptor> delegate;
};
 
class VRPN_API vrpn_HidBooleanAndAcceptor : public vrpn_HidAcceptor {
public:
 vrpn_HidBooleanAndAcceptor(vrpn_HidAcceptor *p, vrpn_HidAcceptor *q)
        : first(p)
        , second(q)
    {
    }
 
 virtual ~vrpn_HidBooleanAndAcceptor() {}
 
 bool accept(const vrpn_HIDDEVINFO &device)
    {
 bool p = first->accept(device);
 bool q = second->accept(device);
 return p && q;
    }
 
 void reset()
    {
        first->reset();
        second->reset();
    }
 
private:
 vrpn::OwningPtr<vrpn_HidAcceptor> first;
 vrpn::OwningPtr<vrpn_HidAcceptor> second;
};
 
class VRPN_API vrpn_HidBooleanOrAcceptor : public vrpn_HidAcceptor {
public:
 vrpn_HidBooleanOrAcceptor(vrpn_HidAcceptor *p, vrpn_HidAcceptor *q)
        : first(p)
        , second(q)
    {
    }
 
 virtual ~vrpn_HidBooleanOrAcceptor() {}
 
 bool accept(const vrpn_HIDDEVINFO &device)
    {
 bool p = first->accept(device);
 bool q = second->accept(device);
 return p || q;
    }
 
 void reset()
    {
        first->reset();
        second->reset();
    }
 
private:
 vrpn::OwningPtr<vrpn_HidAcceptor> first;
 vrpn::OwningPtr<vrpn_HidAcceptor> second;
};
 
 
#endif // VRPN_HUMANINTERFACE_H