device_info.cpp

#include "device_info.h"
#include <Windows.h>
#include <SetupAPI.h>
#include <devguid.h>
#include <cfgmgr32.h>
#include <sstream>
#include <iomanip>
#include <algorithm>
#include <regex>

// Link SetupAPI
#pragma comment(lib, "setupapi.lib")

std::wstring USBDeviceInfo::getVidPidString() const {
    std::wostringstream oss;
    oss << L"VID:" << std::uppercase << std::hex << std::setfill(L'0') << std::setw(4) << vendorId
        << L" PID:" << std::setw(4) << productId;
    return oss.str();
}

std::wstring USBDeviceInfo::getDisplayString() const {
    std::wostringstream oss;
    oss << name;
    if (vendorId != 0 || productId != 0) {
        oss << L" (" << getVidPidString() << L")";
    }
    if (!locationInfo.empty()) {
        oss << L" " << locationInfo;
    }
    if (maxPowerMa > 0) {
        oss << L" Power:" << std::dec << maxPowerMa << L"mA";
    }
    return oss.str();
}

std::wstring AudioDeviceInfo::getDisplayString() const {
    std::wostringstream oss;
    oss << (isOutput ? L"[OUT] " : L"[IN]  ");
    oss << name;
    if (isDefault) {
        oss << L" (Default)";
    }
    oss << L" - " << (isActive ? L"Active" : L"Disabled");
    return oss.str();
}

bool parseVidPid(const std::wstring& devicePath, uint16_t& vid, uint16_t& pid) {
    // Pattern: VID_XXXX&PID_XXXX or vid_xxxx&pid_xxxx
    std::wstring upper = devicePath;
    std::transform(upper.begin(), upper.end(), upper.begin(), ::towupper);

    size_t vidPos = upper.find(L"VID_");
    size_t pidPos = upper.find(L"PID_");

    if (vidPos != std::wstring::npos && pidPos != std::wstring::npos) {
        try {
            vid = static_cast<uint16_t>(std::stoul(upper.substr(vidPos + 4, 4), nullptr, 16));
            pid = static_cast<uint16_t>(std::stoul(upper.substr(pidPos + 4, 4), nullptr, 16));
            return true;
        } catch (...) {
            return false;
        }
    }
    return false;
}

std::wstring getDeviceProperty(HDEVINFO deviceInfoSet, SP_DEVINFO_DATA& deviceInfoData, DWORD property) {
    DWORD dataType = 0;
    DWORD requiredSize = 0;

    SetupDiGetDeviceRegistryPropertyW(deviceInfoSet, &deviceInfoData, property,
        &dataType, nullptr, 0, &requiredSize);

    if (requiredSize == 0) return L"";

    std::vector<BYTE> buffer(requiredSize);
    if (SetupDiGetDeviceRegistryPropertyW(deviceInfoSet, &deviceInfoData, property,
        &dataType, buffer.data(), requiredSize, nullptr)) {
        return std::wstring(reinterpret_cast<wchar_t*>(buffer.data()));
    }
    return L"";
}

std::vector<USBDeviceInfo> enumerateUSBDevices() {
    std::vector<USBDeviceInfo> devices;

    // Get USB device class
    HDEVINFO deviceInfoSet = SetupDiGetClassDevsW(
        nullptr, L"USB", nullptr,
        DIGCF_PRESENT | DIGCF_ALLCLASSES);

    if (deviceInfoSet == INVALID_HANDLE_VALUE) {
        return devices;
    }

    SP_DEVINFO_DATA deviceInfoData;
    deviceInfoData.cbSize = sizeof(SP_DEVINFO_DATA);

    for (DWORD i = 0; SetupDiEnumDeviceInfo(deviceInfoSet, i, &deviceInfoData); i++) {
        USBDeviceInfo device;

        // Get device description
        device.description = getDeviceProperty(deviceInfoSet, deviceInfoData, SPDRP_DEVICEDESC);
        device.name = getDeviceProperty(deviceInfoSet, deviceInfoData, SPDRP_FRIENDLYNAME);
        if (device.name.empty()) {
            device.name = device.description;
        }

        // Skip if no name
        if (device.name.empty()) continue;

        // Get hardware ID for VID/PID
        std::wstring hardwareId = getDeviceProperty(deviceInfoSet, deviceInfoData, SPDRP_HARDWAREID);
        parseVidPid(hardwareId, device.vendorId, device.productId);

        // Get location info
        device.locationInfo = getDeviceProperty(deviceInfoSet, deviceInfoData, SPDRP_LOCATION_INFORMATION);

        // Get device instance path
        WCHAR instanceId[MAX_DEVICE_ID_LEN];
        if (CM_Get_Device_IDW(deviceInfoData.DevInst, instanceId, MAX_DEVICE_ID_LEN, 0) == CR_SUCCESS) {
            device.devicePath = instanceId;
        }

        // Try to get power info from registry
        // USB devices report max power in their configuration descriptor
        // This is stored in registry under device parameters
        HKEY hKey = SetupDiOpenDevRegKey(deviceInfoSet, &deviceInfoData,
            DICS_FLAG_GLOBAL, 0, DIREG_DEV, KEY_READ);
        if (hKey != INVALID_HANDLE_VALUE) {
            DWORD powerValue = 0;
            DWORD size = sizeof(powerValue);
            // Some USB devices store power in registry, but it's not standardized
            RegCloseKey(hKey);
        }

        // Skip hub devices and root hubs
        if (device.name.find(L"Hub") != std::wstring::npos ||
            device.name.find(L"Root") != std::wstring::npos) {
            continue;
        }

        devices.push_back(device);
    }

    SetupDiDestroyDeviceInfoList(deviceInfoSet);
    return devices;
}

USBDeviceInfo getUSBDeviceFromPath(const std::wstring& devicePath) {
    USBDeviceInfo device;
    device.devicePath = devicePath;

    parseVidPid(devicePath, device.vendorId, device.productId);

    // Try to find more info about this device
    HDEVINFO deviceInfoSet = SetupDiGetClassDevsW(
        nullptr, L"USB", nullptr,
        DIGCF_PRESENT | DIGCF_ALLCLASSES);

    if (deviceInfoSet == INVALID_HANDLE_VALUE) {
        device.name = L"USB Device";
        return device;
    }

    SP_DEVINFO_DATA deviceInfoData;
    deviceInfoData.cbSize = sizeof(SP_DEVINFO_DATA);

    for (DWORD i = 0; SetupDiEnumDeviceInfo(deviceInfoSet, i, &deviceInfoData); i++) {
        WCHAR instanceId[MAX_DEVICE_ID_LEN];
        if (CM_Get_Device_IDW(deviceInfoData.DevInst, instanceId, MAX_DEVICE_ID_LEN, 0) == CR_SUCCESS) {
            std::wstring currentPath = instanceId;

            // Check if this device matches (case insensitive partial match)
            std::wstring upperPath = devicePath;
            std::wstring upperCurrent = currentPath;
            std::transform(upperPath.begin(), upperPath.end(), upperPath.begin(), ::towupper);
            std::transform(upperCurrent.begin(), upperCurrent.end(), upperCurrent.begin(), ::towupper);

            if (upperPath.find(upperCurrent) != std::wstring::npos ||
                upperCurrent.find(upperPath) != std::wstring::npos) {
                device.description = getDeviceProperty(deviceInfoSet, deviceInfoData, SPDRP_DEVICEDESC);
                device.name = getDeviceProperty(deviceInfoSet, deviceInfoData, SPDRP_FRIENDLYNAME);
                if (device.name.empty()) {
                    device.name = device.description;
                }
                device.locationInfo = getDeviceProperty(deviceInfoSet, deviceInfoData, SPDRP_LOCATION_INFORMATION);
                break;
            }
        }
    }

    SetupDiDestroyDeviceInfoList(deviceInfoSet);

    if (device.name.empty()) {
        device.name = L"USB Device (" + device.getVidPidString() + L")";
    }

    return device;
}