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*;

using HidDeviceRef = ResourceRef<HidDevice>;

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;

struct HidDevice : ResourceBase<HidDeviceRaw>
{
  using ResourceBase::ResourceBase;

  constexpr explicit HidDevice(HidDeviceRaw resource) noexcept
    : ResourceBase(resource)
  {
  }

  constexpr HidDevice(const HidDevice& other) = delete;

  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);

  HidDevice(StringParam path);

  ~HidDevice() { SDL_hid_close(get()); }

  constexpr HidDevice& operator=(HidDevice&& other) noexcept
  {
    swap(*this, other);
    return *this;
  }

  HidDevice& operator=(const HidDevice& other) = delete;

  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);
};

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::HidDevice(unsigned short vendor_id,
                            unsigned short product_id,
                            const wchar_t* serial_number)
  : HidDevice(CheckError(SDL_hid_open(vendor_id, product_id, serial_number)))
{
}
 
inline HidDevice::HidDevice(StringParam path)
  : HidDevice(CheckError(SDL_hid_open_path(path)))
{
}

inline HidDevice hid_open_path(StringParam path)
{
  return HidDevice(std::move(path));
}
 
#if SDL_VERSION_ATLEAST(3, 4, 0)

inline PropertiesRef hid_get_properties(HidDeviceRef dev)
{
  return CheckError(SDL_hid_get_properties(dev));
}
 
inline PropertiesRef HidDevice::hid_get_properties()
{
  return SDL::hid_get_properties(get());
}

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(HidDeviceRef 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(get(), std::move(data));
}

inline int hid_read_timeout(HidDeviceRef dev,
                            TargetBytes data,
                            Milliseconds timeout)
{
  return SDL_hid_read_timeout(
    dev, data.data_as<Uint8>(), data.size_bytes(), narrowS32(timeout.count()));
}
 
inline int HidDevice::read_timeout(TargetBytes data, Milliseconds timeout)
{
  return SDL::hid_read_timeout(get(), std::move(data), timeout);
}

inline int hid_read(HidDeviceRef 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(get(), std::move(data));
}

inline void hid_set_nonblocking(HidDeviceRef dev, bool nonblock)
{
  CheckErrorIfNot(SDL_hid_set_nonblocking(dev, nonblock), 0);
}
 
inline void HidDevice::set_nonblocking(bool nonblock)
{
  SDL::hid_set_nonblocking(get(), nonblock);
}

inline int hid_send_feature_report(HidDeviceRef 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(get(), std::move(data));
}

inline int hid_get_feature_report(HidDeviceRef 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(get(), std::move(data));
}

inline int hid_get_input_report(HidDeviceRef 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(get(), 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(HidDeviceRef 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(get(), string, maxlen);
}

inline void hid_get_product_string(HidDeviceRef 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(get(), string, maxlen);
}

inline void hid_get_serial_number_string(HidDeviceRef 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(get(), string, maxlen);
}

inline void hid_get_indexed_string(HidDeviceRef 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(get(), string_index, string, maxlen);
}

inline hid_device_info* hid_get_device_info(HidDeviceRef dev)
{
  return CheckError(SDL_hid_get_device_info(dev));
}
 
inline hid_device_info* HidDevice::get_device_info()
{
  return SDL::hid_get_device_info(get());
}

inline int hid_get_report_descriptor(HidDeviceRef 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(get(), std::move(buf));
}

inline void hid_ble_scan(bool active) { SDL_hid_ble_scan(active); }

 
} // namespace SDL
 
#endif /* SDL3PP_HIDAPI_H_ */