Method open

src/core/HidEncoderManager.cpp:423–560

}

bool HidEncoderManager::open(uint16_t vid, uint16_t pid)
{
    if (m_device) close();

    // Block if more than one RC-28-compatible device is connected — interleaved
    // events from two encoders would produce unpredictable tuning behaviour.
    // macOS reports each HID usage collection as a separate enumeration entry, so
    // counting raw entries would over-count a single device. We group by a stable
    // physical-device key: the USB serial number when present, otherwise the
    // hidapi path. The RC-28 exposes no serial, but all usage-collection entries
    // of one physical interface share the same path, while two separate devices
    // get distinct paths — so the path fallback distinguishes them correctly.
    if (isRC28CompatibleId(vid, pid)) {
        bool multiplePhysical = false;
        QString firstKey;
        bool firstSeen = false;
        if (auto* info = hid_enumerate(vid, pid)) {
            for (auto* cur = info; cur; cur = cur->next) {
                const QString key = (cur->serial_number && cur->serial_number[0] != L'\0')
                    ? QStringLiteral("sn:") + QString::fromWCharArray(cur->serial_number)
                    : QStringLiteral("path:") + QString::fromLatin1(cur->path ? cur->path : "");
                if (!firstSeen) {
                    firstKey  = key;
                    firstSeen = true;
                } else if (key != firstKey) {
                    multiplePhysical = true;
                    break;
                }
            }
            hid_free_enumeration(info);
        }
        if (multiplePhysical) {
            const auto* devices = HidDeviceParser::supportedDevices();
            int count = HidDeviceParser::supportedDeviceCount();
            QString name;
            for (int i = 0; i < count; ++i) {
                if (devices[i].vid == vid && devices[i].pid == pid) {
                    name = devices[i].name;
                    break;
                }
            }
            // open() is retried every hotplug tick while two devices remain, so
            // warn + emit only on the transition into the blocked state.
            if (!m_multipleDetected.load(std::memory_order_acquire)) {
                // Write the name before the release store so the main thread
                // sees a valid QString when it reads m_multipleDetected as true.
                m_blockedDeviceName = name;
                m_multipleDetected.store(true, std::memory_order_release);
                qCWarning(lcDevices) << "HidEncoderManager: multiple" << name
                                     << "devices detected — blocking until only one is present";
                emit multipleDevicesDetected(name);
            }
            return false;
        }
        m_blockedDeviceName.clear();
        m_multipleDetected.store(false, std::memory_order_release);
    }