SDL3pp_hidapi.h

#ifndef SDL3PP_HIDAPI_H_
#define SDL3PP_HIDAPI_H_
 
#include <SDL3/SDL_hidapi.h>
#include "SDL3pp_error.h"
#include "SDL3pp_properties.h"
#include "SDL3pp_stdinc.h"
 
namespace SDL {
 
// Forward decl
struct HidDevice;
 
using HidDeviceRaw = SDL_hid_device*;
 
// Forward decl
struct HidDeviceRef;
 
struct HidDeviceParam
{
  HidDeviceRaw value; 
 
  constexpr HidDeviceParam(HidDeviceRaw value)
    : value(value)
  {
  }
 
  constexpr HidDeviceParam(std::nullptr_t = nullptr)
    : value(nullptr)
  {
  }
 
  constexpr explicit operator bool() const { return !!value; }
 
  constexpr auto operator<=>(const HidDeviceParam& other) const = default;
 
  constexpr operator HidDeviceRaw() const { return value; }
};
 
using hid_bus_type = SDL_hid_bus_type;
 
constexpr hid_bus_type HID_API_BUS_UNKNOWN =
  SDL_HID_API_BUS_UNKNOWN; 
 
constexpr hid_bus_type HID_API_BUS_USB = SDL_HID_API_BUS_USB;
 
constexpr hid_bus_type HID_API_BUS_BLUETOOTH = SDL_HID_API_BUS_BLUETOOTH;
 
constexpr hid_bus_type HID_API_BUS_I2C = SDL_HID_API_BUS_I2C;
 
constexpr hid_bus_type HID_API_BUS_SPI = SDL_HID_API_BUS_SPI;
 
using hid_device_info = SDL_hid_device_info;
 
class HidDevice
{
  HidDeviceRaw m_resource = nullptr;
 
public:
  constexpr HidDevice(std::nullptr_t = nullptr) noexcept
    : m_resource(0)
  {
  }
 
  constexpr explicit HidDevice(const HidDeviceRaw resource) noexcept
    : m_resource(resource)
  {
  }
 
protected:
  constexpr HidDevice(const HidDevice& other) noexcept = default;
 
public:
  constexpr HidDevice(HidDevice&& other) noexcept
    : HidDevice(other.release())
  {
  }
 
  constexpr HidDevice(const HidDeviceRef& other) = delete;
 
  constexpr HidDevice(HidDeviceRef&& other) = delete;
 
  HidDevice(unsigned short vendor_id,
            unsigned short product_id,
            const wchar_t* serial_number)
    : m_resource(CheckError(SDL_hid_open(vendor_id, product_id, serial_number)))
  {
  }
 
  HidDevice(StringParam path)
    : m_resource(CheckError(SDL_hid_open_path(path)))
  {
  }
 
  ~HidDevice() { SDL_hid_close(m_resource); }
 
  constexpr HidDevice& operator=(HidDevice&& other) noexcept
  {
    std::swap(m_resource, other.m_resource);
    return *this;
  }
 
protected:
  constexpr HidDevice& operator=(const HidDevice& other) noexcept = default;
 
public:
  constexpr HidDeviceRaw get() const noexcept { return m_resource; }
 
  constexpr HidDeviceRaw release() noexcept
  {
    auto r = m_resource;
    m_resource = nullptr;
    return r;
  }
 
  constexpr auto operator<=>(const HidDevice& other) const noexcept = default;
 
  constexpr explicit operator bool() const noexcept { return !!m_resource; }
 
  constexpr operator HidDeviceParam() const noexcept { return {m_resource}; }
 
  void close();
 
#if SDL_VERSION_ATLEAST(3, 4, 0)
 
  PropertiesRef hid_get_properties();
 
#endif // SDL_VERSION_ATLEAST(3, 4, 0)
 
  int write(SourceBytes data);
 
  int read_timeout(TargetBytes data, Milliseconds timeout);
 
  int read(TargetBytes data);
 
  void set_nonblocking(bool nonblock);
 
  int send_feature_report(SourceBytes data);
 
  int get_feature_report(TargetBytes data);
 
  int get_input_report(TargetBytes data);
 
  void get_manufacturer_string(wchar_t* string, size_t maxlen);
 
  void get_product_string(wchar_t* string, size_t maxlen);
 
  void get_serial_number_string(wchar_t* string, size_t maxlen);
 
  void get_indexed_string(int string_index, wchar_t* string, size_t maxlen);
 
  hid_device_info* get_device_info();
 
  int get_report_descriptor(TargetBytes buf);
};
 
struct HidDeviceRef : HidDevice
{
  using HidDevice::HidDevice;
 
  HidDeviceRef(HidDeviceParam resource) noexcept
    : HidDevice(resource.value)
  {
  }
 
  HidDeviceRef(HidDeviceRaw resource) noexcept
    : HidDevice(resource)
  {
  }
 
  constexpr HidDeviceRef(const HidDeviceRef& other) noexcept = default;
 
  ~HidDeviceRef() { release(); }
};
 
inline void hid_init() { CheckErrorIfNot(SDL_hid_init(), 0); }
 
inline void hid_exit() { CheckErrorIfNot(SDL_hid_exit(), 0); }
 
inline Uint32 hid_device_change_count()
{
  return SDL_hid_device_change_count();
}
 
inline hid_device_info* hid_enumerate(unsigned short vendor_id,
                                      unsigned short product_id)
{
  return CheckError(SDL_hid_enumerate(vendor_id, product_id));
}
 
inline void hid_free_enumeration(hid_device_info* devs)
{
  SDL_hid_free_enumeration(devs);
}
 
inline HidDevice hid_open(unsigned short vendor_id,
                          unsigned short product_id,
                          const wchar_t* serial_number)
{
  return HidDevice(vendor_id, product_id, serial_number);
}
 
inline HidDevice hid_open_path(StringParam path)
{
  return HidDevice(std::move(path));
}
 
#if SDL_VERSION_ATLEAST(3, 4, 0)
 
inline PropertiesRef hid_get_properties(HidDeviceParam dev)
{
  return CheckError(SDL_hid_get_properties(dev));
}
 
inline PropertiesRef HidDevice::hid_get_properties()
{
  return SDL::hid_get_properties(m_resource);
}
 
namespace prop::Hidapi {
 
constexpr auto LIBUSB_DEVICE_HANDLE_POINTER =
  SDL_PROP_HIDAPI_LIBUSB_DEVICE_HANDLE_POINTER;
 
} // namespace prop::Hidapi
 
#endif // SDL_VERSION_ATLEAST(3, 4, 0)
 
inline int hid_write(HidDeviceParam dev, SourceBytes data)
{
  return SDL_hid_write(dev, data.data_as<Uint8>(), data.size_bytes());
}
 
inline int HidDevice::write(SourceBytes data)
{
  return SDL::hid_write(m_resource, std::move(data));
}
 
inline int hid_read_timeout(HidDeviceParam dev,
                            TargetBytes data,
                            Milliseconds timeout)
{
  return SDL_hid_read_timeout(
    dev, data.data_as<Uint8>(), data.size_bytes(), timeout.count());
}
 
inline int HidDevice::read_timeout(TargetBytes data, Milliseconds timeout)
{
  return SDL::hid_read_timeout(m_resource, std::move(data), timeout);
}
 
inline int hid_read(HidDeviceParam dev, TargetBytes data)
{
  return SDL_hid_read(dev, data.data_as<Uint8>(), data.size_bytes());
}
 
inline int HidDevice::read(TargetBytes data)
{
  return SDL::hid_read(m_resource, std::move(data));
}
 
inline void hid_set_nonblocking(HidDeviceParam dev, bool nonblock)
{
  CheckErrorIfNot(SDL_hid_set_nonblocking(dev, nonblock), 0);
}
 
inline void HidDevice::set_nonblocking(bool nonblock)
{
  SDL::hid_set_nonblocking(m_resource, nonblock);
}
 
inline int hid_send_feature_report(HidDeviceParam dev, SourceBytes data)
{
  return SDL_hid_send_feature_report(
    dev, data.data_as<Uint8>(), data.size_bytes());
}
 
inline int HidDevice::send_feature_report(SourceBytes data)
{
  return SDL::hid_send_feature_report(m_resource, std::move(data));
}
 
inline int hid_get_feature_report(HidDeviceParam dev, TargetBytes data)
{
  return SDL_hid_get_feature_report(
    dev, data.data_as<Uint8>(), data.size_bytes());
}
 
inline int HidDevice::get_feature_report(TargetBytes data)
{
  return SDL::hid_get_feature_report(m_resource, std::move(data));
}
 
inline int hid_get_input_report(HidDeviceParam dev, TargetBytes data)
{
  return SDL_hid_get_input_report(
    dev, data.data_as<Uint8>(), data.size_bytes());
}
 
inline int HidDevice::get_input_report(TargetBytes data)
{
  return SDL::hid_get_input_report(m_resource, std::move(data));
}
 
inline void hid_close(HidDeviceRaw dev)
{
  CheckErrorIfNot(SDL_hid_close(dev), 0);
}
 
inline void HidDevice::close() { hid_close(release()); }
 
inline void hid_get_manufacturer_string(HidDeviceParam dev,
                                        wchar_t* string,
                                        size_t maxlen)
{
  CheckErrorIfNot(SDL_hid_get_manufacturer_string(dev, string, maxlen), 0);
}
 
inline void HidDevice::get_manufacturer_string(wchar_t* string, size_t maxlen)
{
  SDL::hid_get_manufacturer_string(m_resource, string, maxlen);
}
 
inline void hid_get_product_string(HidDeviceParam dev,
                                   wchar_t* string,
                                   size_t maxlen)
{
  CheckErrorIfNot(SDL_hid_get_product_string(dev, string, maxlen), 0);
}
 
inline void HidDevice::get_product_string(wchar_t* string, size_t maxlen)
{
  SDL::hid_get_product_string(m_resource, string, maxlen);
}
 
inline void hid_get_serial_number_string(HidDeviceParam dev,
                                         wchar_t* string,
                                         size_t maxlen)
{
  CheckErrorIfNot(SDL_hid_get_serial_number_string(dev, string, maxlen), 0);
}
 
inline void HidDevice::get_serial_number_string(wchar_t* string, size_t maxlen)
{
  SDL::hid_get_serial_number_string(m_resource, string, maxlen);
}
 
inline void hid_get_indexed_string(HidDeviceParam dev,
                                   int string_index,
                                   wchar_t* string,
                                   size_t maxlen)
{
  CheckErrorIfNot(SDL_hid_get_indexed_string(dev, string_index, string, maxlen),
                  0);
}
 
inline void HidDevice::get_indexed_string(int string_index,
                                          wchar_t* string,
                                          size_t maxlen)
{
  SDL::hid_get_indexed_string(m_resource, string_index, string, maxlen);
}
 
inline hid_device_info* hid_get_device_info(HidDeviceParam dev)
{
  return CheckError(SDL_hid_get_device_info(dev));
}
 
inline hid_device_info* HidDevice::get_device_info()
{
  return SDL::hid_get_device_info(m_resource);
}
 
inline int hid_get_report_descriptor(HidDeviceParam dev, TargetBytes buf)
{
  return SDL_hid_get_report_descriptor(
    dev, buf.data_as<Uint8>(), buf.size_bytes());
}
 
inline int HidDevice::get_report_descriptor(TargetBytes buf)
{
  return SDL::hid_get_report_descriptor(m_resource, std::move(buf));
}
 
inline void hid_ble_scan(bool active) { SDL_hid_ble_scan(active); }
 
 
} // namespace SDL
 
#endif /* SDL3PP_HIDAPI_H_ */