◆ 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);
        current_paths.insert(path);
 
        bool is_new = (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;
 
        if (cur->manufacturer_string) {
            std::wstring ws(cur->manufacturer_string);
            info.manufacturer.resize(ws.length());
            std::ranges::transform(ws, info.manufacturer.begin(), [](wchar_t c) { return static_cast<char>(c); });
        }
        if (cur->product_string) {
            std::wstring ws(cur->product_string);
            info.name.resize(ws.length());
            std::ranges::transform(ws, info.name.begin(), [](wchar_t c) { return static_cast<char>(c); });
        } else {
            info.name = "HID Device " + std::to_string(cur->vendor_id) + ":" + std::to_string(cur->product_id);
        }
        if (cur->serial_number) {
            std::wstring ws(cur->serial_number);
            info.serial_number.resize(ws.length());
            std::ranges::transform(ws, info.serial_number.begin(), [](wchar_t c) { return static_cast<char>(c); });
        }
 
        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();
}

Referenced by initialize().

Here is the call graph for this function:

Here is the caller graph for this function: