|
|
|
#include <hid/DeviceMonitor.h>
|
|
|
|
#include <hidpp/SimpleDispatcher.h>
|
|
|
|
#include <hidpp/Device.h>
|
|
|
|
#include <hidpp10/Error.h>
|
|
|
|
#include <hidpp10/IReceiver.h>
|
|
|
|
#include <hidpp20/Error.h>
|
|
|
|
#include <cstring>
|
|
|
|
#include <unistd.h>
|
|
|
|
#include <thread>
|
|
|
|
#include <fstream>
|
|
|
|
#include <sstream>
|
|
|
|
|
|
|
|
#include "DeviceFinder.h"
|
|
|
|
#include "util.h"
|
|
|
|
#include "Device.h"
|
|
|
|
|
|
|
|
void DeviceFinder::addDevice(const char *path)
|
|
|
|
{
|
|
|
|
std::string string_path(path);
|
|
|
|
// Asynchronously scan device
|
|
|
|
std::thread{[=]()
|
|
|
|
{
|
|
|
|
const int max_tries = 10;
|
|
|
|
const int try_delay = 250000;
|
|
|
|
|
|
|
|
//Check if device is an HID++ device and handle it accordingly
|
|
|
|
try
|
|
|
|
{
|
|
|
|
HIDPP::SimpleDispatcher dispatcher(string_path.c_str());
|
|
|
|
bool has_receiver_index = false;
|
|
|
|
for(HIDPP::DeviceIndex index: {
|
|
|
|
HIDPP::DefaultDevice, HIDPP::CordedDevice,
|
|
|
|
HIDPP::WirelessDevice1, HIDPP::WirelessDevice2,
|
|
|
|
HIDPP::WirelessDevice3, HIDPP::WirelessDevice4,
|
|
|
|
HIDPP::WirelessDevice5, HIDPP::WirelessDevice6})
|
|
|
|
{
|
|
|
|
if(!has_receiver_index && index == HIDPP::WirelessDevice1)
|
|
|
|
break;
|
|
|
|
for(int i = 0; i < max_tries; i++)
|
|
|
|
{
|
|
|
|
try
|
|
|
|
{
|
|
|
|
HIDPP::Device d(&dispatcher, index);
|
|
|
|
auto version = d.protocolVersion();
|
|
|
|
uint major, minor;
|
|
|
|
std::tie(major, minor) = version;
|
|
|
|
if(index == HIDPP::DefaultDevice && version == std::make_tuple(1, 0))
|
|
|
|
has_receiver_index = true;
|
|
|
|
if(major > 1) // HID++ 2.0 devices only
|
|
|
|
{
|
|
|
|
auto dev = new Device(string_path, index);
|
|
|
|
|
|
|
|
this->devicesMutex.lock();
|
|
|
|
this->devices.insert({
|
|
|
|
dev,
|
|
|
|
std::thread{[dev]() {
|
|
|
|
dev->start();
|
|
|
|
}}
|
|
|
|
});
|
|
|
|
this->devicesMutex.unlock();
|
|
|
|
|
|
|
|
log_printf(INFO, "%s detected: device %d on %s", d.name().c_str(), index, string_path.c_str());
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
catch(HIDPP10::Error &e)
|
|
|
|
{
|
|
|
|
if(e.errorCode() != HIDPP10::Error::UnknownDevice)
|
|
|
|
{
|
|
|
|
if(i == max_tries - 1)
|
|
|
|
log_printf(ERROR, "Error while querying %s, wireless device %d: %s", string_path.c_str(), index, e.what());
|
|
|
|
else usleep(try_delay);
|
|
|
|
}
|
|
|
|
else break;
|
|
|
|
}
|
|
|
|
catch(HIDPP20::Error &e)
|
|
|
|
{
|
|
|
|
if(e.errorCode() != HIDPP20::Error::UnknownDevice)
|
|
|
|
{
|
|
|
|
if(i == max_tries - 1)
|
|
|
|
log_printf(ERROR, "Error while querying %s, device %d: %s", string_path.c_str(), index, e.what());
|
|
|
|
else usleep(try_delay);
|
|
|
|
}
|
|
|
|
else break;
|
|
|
|
}
|
|
|
|
catch(HIDPP::Dispatcher::TimeoutError &e)
|
|
|
|
{
|
|
|
|
if(i == max_tries - 1)
|
|
|
|
log_printf(ERROR, "Device %s (index %d) timed out.", string_path.c_str(), index);
|
|
|
|
else usleep(try_delay);
|
|
|
|
}
|
|
|
|
catch(std::runtime_error &e)
|
|
|
|
{
|
|
|
|
if(i == max_tries - 1)
|
|
|
|
log_printf(ERROR, "Runtime error on device %d on %s: %s", index, string_path.c_str(), e.what());
|
|
|
|
else usleep(try_delay);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
catch(HIDPP::Dispatcher::NoHIDPPReportException &e) { }
|
|
|
|
catch(std::system_error &e) { log_printf(WARN, "Failed to open %s: %s", string_path.c_str(), e.what()); }
|
|
|
|
|
|
|
|
}}.detach();
|
|
|
|
}
|
|
|
|
|
|
|
|
void DeviceFinder::removeDevice(const char* path)
|
|
|
|
{
|
|
|
|
devicesMutex.lock();
|
|
|
|
// Iterate through Devices, stop all in path
|
|
|
|
for (auto it = devices.begin(); it != devices.end(); it++)
|
|
|
|
{
|
|
|
|
if(it->first->path == path)
|
|
|
|
{
|
|
|
|
log_printf(INFO, "%s on %s disconnected.", it->first->name.c_str(), path);
|
|
|
|
it->first->stop();
|
|
|
|
it->second.join();
|
|
|
|
delete(it->first);
|
|
|
|
devices.erase(it);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
devicesMutex.unlock();
|
|
|
|
}
|