usb_monitor.cpp

#include "usb_monitor.h"
#include "device_info.h"
#include "logger.h"
#include <initguid.h>
#include <Usbiodef.h>

// GUID_DEVINTERFACE_USB_DEVICE is defined in Usbiodef.h

USBMonitor::USBMonitor() = default;

USBMonitor::~USBMonitor() {
    stop();
}

bool USBMonitor::start(HWND hwnd) {
    DEV_BROADCAST_DEVICEINTERFACE notificationFilter;
    ZeroMemory(&notificationFilter, sizeof(notificationFilter));
    notificationFilter.dbcc_size = sizeof(DEV_BROADCAST_DEVICEINTERFACE);
    notificationFilter.dbcc_devicetype = DBT_DEVTYP_DEVICEINTERFACE;
    notificationFilter.dbcc_classguid = GUID_DEVINTERFACE_USB_DEVICE;

    m_notificationHandle = RegisterDeviceNotificationW(
        hwnd,
        &notificationFilter,
        DEVICE_NOTIFY_WINDOW_HANDLE);

    if (!m_notificationHandle) {
        LOG_ERROR(L"Failed to register for USB device notifications");
        return false;
    }

    return true;
}

void USBMonitor::stop() {
    if (m_notificationHandle) {
        UnregisterDeviceNotification(m_notificationHandle);
        m_notificationHandle = nullptr;
    }
}

void USBMonitor::setCallback(DeviceCallback callback) {
    m_callback = callback;
}

void USBMonitor::processDeviceChange(WPARAM wParam, LPARAM lParam) {
    if (wParam != DBT_DEVICEARRIVAL && wParam != DBT_DEVICEREMOVECOMPLETE) {
        return;
    }

    PDEV_BROADCAST_HDR header = reinterpret_cast<PDEV_BROADCAST_HDR>(lParam);
    if (!header || header->dbch_devicetype != DBT_DEVTYP_DEVICEINTERFACE) {
        return;
    }

    PDEV_BROADCAST_DEVICEINTERFACE_W devInterface =
        reinterpret_cast<PDEV_BROADCAST_DEVICEINTERFACE_W>(lParam);

    std::wstring devicePath = devInterface->dbcc_name;
    bool connected = (wParam == DBT_DEVICEARRIVAL);

    // Get device info
    USBDeviceInfo deviceInfo = getUSBDeviceFromPath(devicePath);

    if (connected) {
        LOG_USB_CONNECTED(deviceInfo.getDisplayString());
    } else {
        LOG_USB_DISCONNECTED(deviceInfo.getDisplayString());
    }

    if (m_callback) {
        m_callback(connected, devicePath);
    }
}

void USBMonitor::listCurrentDevices() {
    auto devices = enumerateUSBDevices();

    LOG_SECTION(L"USB DEVICES");

    if (devices.empty()) {
        LOG_INFO(L"No USB devices found");
        return;
    }

    for (const auto& device : devices) {
        LOG_USB(device.getDisplayString());
    }
}