refresh_devices()

size_t MayaFlux::Core::HIDBackend::refresh_devices ( )

overridevirtual

Refresh the device list.

Returns

Number of devices found

Re-enumerates available devices. May trigger device callbacks for newly connected or disconnected devices.

Implements MayaFlux::Core::IInputBackend.

Definition at line 131 of file HIDBackend.cpp.

{
    if (!m_initialized.load()) {
        return 0;
    }
 
    std::lock_guard lock(m_devices_mutex);
 
    std::unordered_set<std::string> previous_paths;
    for (const auto& [id, info] : m_enumerated_devices) {
        previous_paths.insert(info.path);
    }
 
    std::unordered_set<std::string> current_paths;
 
    hid_device_info* devs = hid_enumerate(0x0, 0x0);
    hid_device_info* cur = devs;
 
    while (cur) {
        if (!m_config.filters.empty()) {
            if (!matches_any_filter(cur->vendor_id, cur->product_id,
                    cur->usage_page, cur->usage)) {
                cur = cur->next;
                continue;
            }
        }
 
        std::string path(cur->path);
        const bool first_in_pass = current_paths.insert(path).second;
 
        bool is_new = first_in_pass && (previous_paths.find(path) == previous_paths.end());
 
        uint32_t dev_id = find_or_assign_device_id(path);
 
        HIDDeviceInfoExt info;
        info.id = dev_id;
        info.backend_type = InputType::HID;
        info.vendor_id = cur->vendor_id;
        info.product_id = cur->product_id;
        info.usage_page = cur->usage_page;
        info.usage = cur->usage;
        info.release_number = cur->release_number;
        info.interface_number = cur->interface_number;
        info.path = path;
        info.is_connected = true;
 
        info.manufacturer = wide_to_utf8(cur->manufacturer_string);
        if (cur->product_string) {
            info.name = wide_to_utf8(cur->product_string);
        } else {
            info.name = "HID Device " + std::to_string(cur->vendor_id) + ":" + std::to_string(cur->product_id);
        }
        info.serial_number = wide_to_utf8(cur->serial_number);
 
        m_enumerated_devices[dev_id] = info;
 
        if (is_new) {
            MF_INFO(Journal::Component::Core, Journal::Context::InputBackend,
                "HID device found: {} (VID:{:04X} PID:{:04X})",
                info.name, info.vendor_id, info.product_id);
            notify_device_change(info, true);
        }
 
        cur = cur->next;
    }
 
    hid_free_enumeration(devs);
 
    for (auto it = m_enumerated_devices.begin(); it != m_enumerated_devices.end();) {
        if (current_paths.find(it->second.path) == current_paths.end()) {
            MF_INFO(Journal::Component::Core, Journal::Context::InputBackend,
                "HID device disconnected: {}", it->second.name);
 
            auto open_it = m_open_devices.find(it->first);
            if (open_it != m_open_devices.end()) {
                if (open_it->second->handle) {
                    hid_close(open_it->second->handle);
                }
                m_open_devices.erase(open_it);
            }
 
            notify_device_change(it->second, false);
            it = m_enumerated_devices.erase(it);
        } else {
            ++it;
        }
    }
 
    return m_enumerated_devices.size();
}

References MayaFlux::Core::InputDeviceInfo::backend_type, MayaFlux::Journal::Core, MayaFlux::Core::HIDBackend::Config::filters, find_or_assign_device_id(), MayaFlux::Core::HID, MayaFlux::Core::InputDeviceInfo::id, MayaFlux::Journal::InputBackend, MayaFlux::Core::HIDDeviceInfoExt::interface_number, MayaFlux::Core::InputDeviceInfo::is_connected, m_config, m_devices_mutex, m_enumerated_devices, m_initialized, m_open_devices, MayaFlux::Core::InputDeviceInfo::manufacturer, matches_any_filter(), MF_INFO, MayaFlux::Core::InputDeviceInfo::name, notify_device_change(), MayaFlux::Core::HIDDeviceInfoExt::path, MayaFlux::Core::InputDeviceInfo::product_id, MayaFlux::Core::HIDDeviceInfoExt::release_number, MayaFlux::Core::InputDeviceInfo::serial_number, MayaFlux::Core::HIDDeviceInfoExt::usage, MayaFlux::Core::HIDDeviceInfoExt::usage_page, MayaFlux::Core::InputDeviceInfo::vendor_id, and MayaFlux::Core::wide_to_utf8().

Referenced by initialize().

Here is the call graph for this function:

Here is the caller graph for this function: