818 lines
33 KiB
C++
818 lines
33 KiB
C++
#include "DRI/Dri_Ble.h"
|
||
#include "DRI/Dri_Hid.h"
|
||
#include "MID/Mid_Ble.h"
|
||
#include <QtCore/QHash>
|
||
#include <QtCore/QList>
|
||
#include <QtCore/QMutex>
|
||
#include <QtCore/QMutexLocker>
|
||
#include <QtCore/QRegularExpression>
|
||
#include <QtCore/QStringList>
|
||
#include <QtCore/QUuid>
|
||
#include <Windows.h>
|
||
#include <SetupAPI.h>
|
||
#include <bluetoothleapis.h>
|
||
#include <bthledef.h>
|
||
#include <hidsdi.h>
|
||
#include <hidpi.h>
|
||
#include <atomic>
|
||
|
||
#pragma comment(lib, "BluetoothAPIs.lib")
|
||
#pragma comment(lib, "hid.lib")
|
||
#pragma comment(lib, "setupapi.lib")
|
||
|
||
struct Dri_Ble_Struct_ServiceContext;
|
||
struct Dri_Ble_Struct_HidPort;
|
||
struct Dri_Ble_Struct_Subscription
|
||
{
|
||
Dri_Ble_Struct_Port* Port = nullptr;
|
||
Dri_Ble_Struct_ServiceContext* Service = nullptr;
|
||
BLUETOOTH_GATT_EVENT_HANDLE Event = nullptr;
|
||
QString DeviceLabel;
|
||
QString ServiceUuid;
|
||
QString CharUuid;
|
||
};
|
||
struct Dri_Ble_Struct_Context
|
||
{
|
||
QMutex Mutex;
|
||
QList<Mid_Struct_RawPacket> Queue;
|
||
QVector<Dri_Ble_Struct_ServiceContext*> Services;
|
||
QVector<Dri_Ble_Struct_HidPort*> Hids;
|
||
std::atomic<long> CallbackCount { 0 };
|
||
};
|
||
struct Dri_Ble_Struct_ServiceContext
|
||
{
|
||
Dri_Ble_Struct_Context* Ctx = nullptr;
|
||
HANDLE Handle = INVALID_HANDLE_VALUE;
|
||
QString Uuid;
|
||
QVector<Dri_Ble_Struct_Subscription*> Subs;
|
||
};
|
||
struct Dri_Ble_Struct_HidPort
|
||
{
|
||
Dri_Hid_Struct_ReadPort ReadPort;
|
||
HANDLE WriteHandle = INVALID_HANDLE_VALUE;
|
||
quint16 UsagePage = 0;
|
||
quint16 Usage = 0;
|
||
quint16 OutputLength = 0;
|
||
};
|
||
|
||
namespace
|
||
{
|
||
|
||
struct ServiceIf { QString Path; QString InstanceId; QString Uuid; };
|
||
struct DeviceIf { QString Path; QString InstanceId; QString Address; };
|
||
struct HidIf
|
||
{
|
||
QString Path;
|
||
QString InstanceId;
|
||
quint16 VendorId = 0;
|
||
quint16 ProductId = 0;
|
||
quint16 UsagePage = 0;
|
||
quint16 Usage = 0;
|
||
quint16 InputLength = 0;
|
||
quint16 OutputLength = 0;
|
||
};
|
||
struct PnpIf
|
||
{
|
||
QString Address;
|
||
quint16 VendorId = 0;
|
||
quint16 ProductId = 0;
|
||
};
|
||
const QString kSvcHidBrace = QStringLiteral("{00001812-0000-1000-8000-00805F9B34FB}");
|
||
const QString kSvcCustom = QStringLiteral("0B7F5000-38D2-4F62-8F6F-36C4FD73A110");
|
||
const QString kSvcDis = QStringLiteral("0000180A-0000-1000-8000-00805F9B34FB");
|
||
const QString kChrPnpId = QStringLiteral("00002A50-0000-1000-8000-00805F9B34FB");
|
||
const quint16 kUsagePageKeyboard = 0x0001;
|
||
const quint16 kUsageKeyboard = 0x0006;
|
||
|
||
QString HResultText(HRESULT hr) { return QStringLiteral("0x%1").arg(static_cast<quint32>(hr), 8, 16, QLatin1Char('0')).toUpper(); }
|
||
bool IsCommandHid(quint16 page, quint16 usage) { return (page == MID_CONST_USAGE_PAGE_VENDOR_COMMAND) && (usage == MID_CONST_USAGE_VENDOR_COMMAND); }
|
||
bool IsUsefulHid(quint16 page, quint16 usage) { return ((page == kUsagePageKeyboard) && (usage == kUsageKeyboard)) || ((page == MID_CONST_USAGE_PAGE_CONSUMER) && (usage == MID_CONST_USAGE_CONSUMER)) || ((page == MID_CONST_USAGE_PAGE_VENDOR) && (usage == MID_CONST_USAGE_VENDOR)) || IsCommandHid(page, usage); }
|
||
bool IsVendorHid(quint16 page, quint16 usage) { return (page == MID_CONST_USAGE_PAGE_VENDOR) && (usage == MID_CONST_USAGE_VENDOR); }
|
||
Mid_Enum_RawPacketSource HidPacketSource(quint16 page, quint16 usage)
|
||
{
|
||
if ((page == kUsagePageKeyboard) && (usage == kUsageKeyboard)) return Mid_Enum_RawPacketSource_BleHidKeyboard;
|
||
if ((page == MID_CONST_USAGE_PAGE_CONSUMER) && (usage == MID_CONST_USAGE_CONSUMER)) return Mid_Enum_RawPacketSource_BleHidConsumer;
|
||
if (IsVendorHid(page, usage)) return Mid_Enum_RawPacketSource_BleHidVendor;
|
||
if (IsCommandHid(page, usage)) return Mid_Enum_RawPacketSource_BleHidVendorCommand;
|
||
return Mid_Enum_RawPacketSource_None;
|
||
}
|
||
QString ExtractAddress(const QString& text) { auto m = QRegularExpression(QStringLiteral("([0-9A-F]{12})(?=[\\\\&_]|$)")).match(text.toUpper()); return m.hasMatch() ? m.captured(1) : QString(); }
|
||
QString ServiceUuidFromId(const QString& id) { auto m = QRegularExpression(QStringLiteral("\\{([0-9A-Fa-f-]{36})\\}")).match(id); return m.hasMatch() ? m.captured(1).toUpper() : QString(); }
|
||
QString DeviceLabel(const QString& addr) { return addr.isEmpty() ? QStringLiteral("BLE") : QStringLiteral("BLE-%1").arg(addr); }
|
||
QString FormatVidPidLabel(quint16 vendorId, quint16 productId)
|
||
{
|
||
return QStringLiteral("0x%1:0x%2")
|
||
.arg(vendorId, 4, 16, QLatin1Char('0'))
|
||
.arg(productId, 4, 16, QLatin1Char('0'))
|
||
.toUpper();
|
||
}
|
||
QString PortName(const QString& dev, const QString& src) { const QString base = dev.isEmpty() ? QStringLiteral("Bluetooth") : QStringLiteral("Bluetooth(%1)").arg(dev); return src.isEmpty() ? base : QStringLiteral("%1/%2").arg(base, src); }
|
||
QString HidSource(quint16 page, quint16 usage)
|
||
{
|
||
if ((page == kUsagePageKeyboard) && (usage == kUsageKeyboard)) return QStringLiteral("HID Keyboard");
|
||
if ((page == MID_CONST_USAGE_PAGE_CONSUMER) && (usage == MID_CONST_USAGE_CONSUMER)) return QStringLiteral("HID Consumer");
|
||
if ((page == MID_CONST_USAGE_PAGE_VENDOR) && (usage == MID_CONST_USAGE_VENDOR)) return QStringLiteral("HID Vendor");
|
||
if (IsCommandHid(page, usage)) return QStringLiteral("HID Vendor Command");
|
||
return QStringLiteral("HID UsagePage 0x%1 / Usage 0x%2").arg(page, 4, 16, QLatin1Char('0')).arg(usage, 4, 16, QLatin1Char('0')).toUpper();
|
||
}
|
||
QString DeviceInstanceId(HDEVINFO set, SP_DEVINFO_DATA* info)
|
||
{
|
||
DWORD need = 0;
|
||
SetupDiGetDeviceInstanceIdW(set, info, nullptr, 0, &need);
|
||
if (need == 0) return QString();
|
||
QVector<wchar_t> buf(static_cast<int>(need) + 1, 0);
|
||
return SetupDiGetDeviceInstanceIdW(set, info, buf.data(), static_cast<DWORD>(buf.size()), nullptr) ? QString::fromWCharArray(buf.constData()).trimmed() : QString();
|
||
}
|
||
bool InterfacePath(HDEVINFO set, SP_DEVICE_INTERFACE_DATA* itf, SP_DEVINFO_DATA* info, QString* path)
|
||
{
|
||
DWORD need = 0;
|
||
SetupDiGetDeviceInterfaceDetailW(set, itf, nullptr, 0, &need, info);
|
||
if (need == 0) return false;
|
||
QByteArray buf(static_cast<int>(need), 0);
|
||
auto* detail = reinterpret_cast<SP_DEVICE_INTERFACE_DETAIL_DATA_W*>(buf.data());
|
||
detail->cbSize = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA_W);
|
||
if (!SetupDiGetDeviceInterfaceDetailW(set, itf, detail, need, nullptr, info)) return false;
|
||
*path = QString::fromWCharArray(detail->DevicePath);
|
||
return true;
|
||
}
|
||
QUuid QtUuid(const BTH_LE_UUID& uuid)
|
||
{
|
||
if (uuid.IsShortUuid) return QUuid(QStringLiteral("{%1-0000-1000-8000-00805F9B34FB}").arg(uuid.Value.ShortUuid, 4, 16, QLatin1Char('0')));
|
||
const GUID& g = uuid.Value.LongUuid;
|
||
return QUuid(g.Data1, g.Data2, g.Data3, g.Data4[0], g.Data4[1], g.Data4[2], g.Data4[3], g.Data4[4], g.Data4[5], g.Data4[6], g.Data4[7]);
|
||
}
|
||
QString CharText(const BTH_LE_GATT_CHARACTERISTIC& c)
|
||
{
|
||
const QString uuid = QtUuid(c.CharacteristicUuid).toString(QUuid::WithoutBraces).toUpper();
|
||
return uuid == QStringLiteral("00000000-0000-0000-0000-000000000000") ? QStringLiteral("HANDLE 0x%1").arg(c.CharacteristicValueHandle, 4, 16, QLatin1Char('0')).toUpper() : uuid;
|
||
}
|
||
HANDLE OpenService(const QString& path)
|
||
{
|
||
HANDLE handle = CreateFileW(reinterpret_cast<LPCWSTR>(path.utf16()), GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, nullptr, OPEN_EXISTING, 0, nullptr);
|
||
return handle != INVALID_HANDLE_VALUE ? handle : CreateFileW(reinterpret_cast<LPCWSTR>(path.utf16()), GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, nullptr, OPEN_EXISTING, 0, nullptr);
|
||
}
|
||
void QueuePacket(
|
||
Dri_Ble_Struct_Context* ctx,
|
||
Mid_Enum_RawPacketSource source,
|
||
const QString& portName,
|
||
const QByteArray& bytes)
|
||
{
|
||
if ((ctx == nullptr) || bytes.isEmpty()) return;
|
||
Mid_Struct_RawPacket packet;
|
||
packet.IsValid = true;
|
||
packet.Source = source;
|
||
packet.PortName = portName;
|
||
packet.ByteArray = bytes;
|
||
QMutexLocker lock(&ctx->Mutex); ctx->Queue.append(packet);
|
||
}
|
||
|
||
QVector<ServiceIf> EnumServices()
|
||
{
|
||
QVector<ServiceIf> out;
|
||
HDEVINFO set = SetupDiGetClassDevsW(&GUID_BLUETOOTH_GATT_SERVICE_DEVICE_INTERFACE, nullptr, nullptr, DIGCF_PRESENT | DIGCF_DEVICEINTERFACE);
|
||
if (set == INVALID_HANDLE_VALUE) return out;
|
||
SP_DEVICE_INTERFACE_DATA itf = { sizeof(SP_DEVICE_INTERFACE_DATA) };
|
||
for (DWORD i = 0; SetupDiEnumDeviceInterfaces(set, nullptr, &GUID_BLUETOOTH_GATT_SERVICE_DEVICE_INTERFACE, i, &itf); ++i)
|
||
{
|
||
SP_DEVINFO_DATA info = { sizeof(SP_DEVINFO_DATA) };
|
||
QString path;
|
||
if (!InterfacePath(set, &itf, &info, &path)) continue;
|
||
ServiceIf item; item.Path = path; item.InstanceId = DeviceInstanceId(set, &info); item.Uuid = ServiceUuidFromId(item.InstanceId); out.append(item);
|
||
}
|
||
SetupDiDestroyDeviceInfoList(set);
|
||
return out;
|
||
}
|
||
|
||
QVector<DeviceIf> EnumBleDevices()
|
||
{
|
||
QVector<DeviceIf> out;
|
||
HDEVINFO set = SetupDiGetClassDevsW(
|
||
&GUID_BLUETOOTHLE_DEVICE_INTERFACE,
|
||
nullptr,
|
||
nullptr,
|
||
DIGCF_PRESENT | DIGCF_DEVICEINTERFACE);
|
||
if (set == INVALID_HANDLE_VALUE) return out;
|
||
|
||
SP_DEVICE_INTERFACE_DATA itf = { sizeof(SP_DEVICE_INTERFACE_DATA) };
|
||
for (DWORD i = 0; SetupDiEnumDeviceInterfaces(set, nullptr, &GUID_BLUETOOTHLE_DEVICE_INTERFACE, i, &itf); ++i)
|
||
{
|
||
SP_DEVINFO_DATA info = { sizeof(SP_DEVINFO_DATA) };
|
||
QString path;
|
||
if (!InterfacePath(set, &itf, &info, &path)) continue;
|
||
|
||
DeviceIf item;
|
||
item.Path = path;
|
||
item.InstanceId = DeviceInstanceId(set, &info);
|
||
item.Address = ExtractAddress(item.InstanceId);
|
||
if (item.Address.isEmpty()) continue;
|
||
out.append(item);
|
||
}
|
||
|
||
SetupDiDestroyDeviceInfoList(set);
|
||
return out;
|
||
}
|
||
|
||
QVector<HidIf> EnumBleHids()
|
||
{
|
||
QVector<HidIf> out;
|
||
GUID hidGuid; HidD_GetHidGuid(&hidGuid);
|
||
HDEVINFO set = SetupDiGetClassDevsW(&hidGuid, nullptr, nullptr, DIGCF_PRESENT | DIGCF_DEVICEINTERFACE);
|
||
if (set == INVALID_HANDLE_VALUE) return out;
|
||
SP_DEVICE_INTERFACE_DATA itf = { sizeof(SP_DEVICE_INTERFACE_DATA) };
|
||
for (DWORD i = 0; SetupDiEnumDeviceInterfaces(set, nullptr, &hidGuid, i, &itf); ++i)
|
||
{
|
||
SP_DEVINFO_DATA info = { sizeof(SP_DEVINFO_DATA) };
|
||
QString path;
|
||
if (!InterfacePath(set, &itf, &info, &path)) continue;
|
||
const QString id = DeviceInstanceId(set, &info).toUpper();
|
||
if (!id.contains(kSvcHidBrace)) continue;
|
||
HANDLE handle = CreateFileW(reinterpret_cast<LPCWSTR>(path.utf16()), 0, FILE_SHARE_READ | FILE_SHARE_WRITE, nullptr, OPEN_EXISTING, 0, nullptr);
|
||
if (handle == INVALID_HANDLE_VALUE) continue;
|
||
HIDD_ATTRIBUTES attrs = {};
|
||
attrs.Size = sizeof(attrs);
|
||
PHIDP_PREPARSED_DATA prep = nullptr;
|
||
HIDP_CAPS caps = {};
|
||
const bool ok =
|
||
HidD_GetAttributes(handle, &attrs) &&
|
||
HidD_GetPreparsedData(handle, &prep) &&
|
||
(HidP_GetCaps(prep, &caps) == HIDP_STATUS_SUCCESS) &&
|
||
IsUsefulHid(caps.UsagePage, caps.Usage) &&
|
||
(caps.InputReportByteLength > 0);
|
||
if (prep != nullptr) HidD_FreePreparsedData(prep);
|
||
CloseHandle(handle);
|
||
if (!ok) continue;
|
||
HidIf item;
|
||
item.Path = path;
|
||
item.InstanceId = id;
|
||
item.VendorId = attrs.VendorID;
|
||
item.ProductId = attrs.ProductID;
|
||
item.UsagePage = caps.UsagePage;
|
||
item.Usage = caps.Usage;
|
||
item.InputLength = caps.InputReportByteLength;
|
||
item.OutputLength = caps.OutputReportByteLength;
|
||
out.append(item);
|
||
}
|
||
SetupDiDestroyDeviceInfoList(set);
|
||
return out;
|
||
}
|
||
|
||
QVector<BTH_LE_GATT_CHARACTERISTIC> Characteristics(HANDLE handle)
|
||
{
|
||
USHORT count = 0;
|
||
HRESULT hr = BluetoothGATTGetCharacteristics(handle, nullptr, 0, nullptr, &count, BLUETOOTH_GATT_FLAG_NONE);
|
||
if (FAILED(hr) && (hr != HRESULT_FROM_WIN32(ERROR_MORE_DATA))) return {};
|
||
QVector<BTH_LE_GATT_CHARACTERISTIC> out(count);
|
||
hr = BluetoothGATTGetCharacteristics(handle, nullptr, count, out.data(), &count, BLUETOOTH_GATT_FLAG_NONE);
|
||
if (FAILED(hr)) return {};
|
||
out.resize(count); return out;
|
||
}
|
||
|
||
QVector<BTH_LE_GATT_DESCRIPTOR> Descriptors(HANDLE handle, const BTH_LE_GATT_CHARACTERISTIC& c)
|
||
{
|
||
USHORT count = 0;
|
||
HRESULT hr = BluetoothGATTGetDescriptors(handle, const_cast<PBTH_LE_GATT_CHARACTERISTIC>(&c), 0, nullptr, &count, BLUETOOTH_GATT_FLAG_NONE);
|
||
if (FAILED(hr) && (hr != HRESULT_FROM_WIN32(ERROR_MORE_DATA))) return {};
|
||
QVector<BTH_LE_GATT_DESCRIPTOR> out(count);
|
||
hr = BluetoothGATTGetDescriptors(handle, const_cast<PBTH_LE_GATT_CHARACTERISTIC>(&c), count, out.data(), &count, BLUETOOTH_GATT_FLAG_NONE);
|
||
if (FAILED(hr)) return {};
|
||
out.resize(count); return out;
|
||
}
|
||
|
||
bool ReadValue(HANDLE handle, const BTH_LE_GATT_CHARACTERISTIC& c, QByteArray* out)
|
||
{
|
||
USHORT need = 0;
|
||
HRESULT hr = BluetoothGATTGetCharacteristicValue(handle, const_cast<PBTH_LE_GATT_CHARACTERISTIC>(&c), 0, nullptr, &need, BLUETOOTH_GATT_FLAG_FORCE_READ_FROM_DEVICE);
|
||
if (FAILED(hr) && (hr != HRESULT_FROM_WIN32(ERROR_MORE_DATA))) return false;
|
||
if (need == 0) return false;
|
||
QByteArray buffer(static_cast<int>(need), 0);
|
||
auto* value = reinterpret_cast<PBTH_LE_GATT_CHARACTERISTIC_VALUE>(buffer.data());
|
||
hr = BluetoothGATTGetCharacteristicValue(handle, const_cast<PBTH_LE_GATT_CHARACTERISTIC>(&c), need, value, nullptr, BLUETOOTH_GATT_FLAG_FORCE_READ_FROM_DEVICE);
|
||
if (FAILED(hr)) return false;
|
||
*out = QByteArray(reinterpret_cast<const char*>(value->Data), static_cast<int>(value->DataSize));
|
||
return true;
|
||
}
|
||
|
||
VOID CALLBACK OnGattEvent(BTH_LE_GATT_EVENT_TYPE type, PVOID out, PVOID context)
|
||
{
|
||
auto* sub = static_cast<Dri_Ble_Struct_Subscription*>(context);
|
||
if ((sub == nullptr) || (sub->Service == nullptr) || (sub->Service->Ctx == nullptr)) return;
|
||
Dri_Ble_Struct_Context* ctx = sub->Service->Ctx;
|
||
ctx->CallbackCount.fetch_add(1, std::memory_order_acq_rel);
|
||
if ((type == CharacteristicValueChangedEvent) && (out != nullptr) && (sub->Port != nullptr))
|
||
{
|
||
const auto* evt = static_cast<const BLUETOOTH_GATT_VALUE_CHANGED_EVENT*>(out);
|
||
if ((evt->CharacteristicValue != nullptr) && (evt->CharacteristicValue->DataSize > 0)) QueuePacket(ctx, Mid_Enum_RawPacketSource_BleGatt, PortName(sub->DeviceLabel, QStringLiteral("SVC %1 / CHR %2").arg(sub->ServiceUuid, sub->CharUuid)), QByteArray(reinterpret_cast<const char*>(evt->CharacteristicValue->Data), static_cast<int>(evt->CharacteristicValue->DataSize)));
|
||
}
|
||
ctx->CallbackCount.fetch_sub(1, std::memory_order_acq_rel);
|
||
}
|
||
|
||
bool Subscribe(Dri_Ble_Struct_Port* port, Dri_Ble_Struct_ServiceContext* svc, const QString& deviceLabel, const BTH_LE_GATT_CHARACTERISTIC& c, QString* error)
|
||
{
|
||
auto* sub = new Dri_Ble_Struct_Subscription();
|
||
sub->Port = port; sub->Service = svc; sub->DeviceLabel = deviceLabel; sub->ServiceUuid = svc->Uuid; sub->CharUuid = CharText(c);
|
||
BLUETOOTH_GATT_VALUE_CHANGED_EVENT_REGISTRATION reg = {}; reg.NumCharacteristics = 1; reg.Characteristics[0] = c;
|
||
HRESULT hr = BluetoothGATTRegisterEvent(svc->Handle, CharacteristicValueChangedEvent, ®, OnGattEvent, sub, &sub->Event, BLUETOOTH_GATT_FLAG_NONE);
|
||
if (FAILED(hr)) { if (error != nullptr) *error = QStringLiteral("BLE notify register failed: %1 / %2 / %3").arg(svc->Uuid, sub->CharUuid, HResultText(hr)); delete sub; return false; }
|
||
bool configured = false;
|
||
for (const BTH_LE_GATT_DESCRIPTOR& d : Descriptors(svc->Handle, c))
|
||
{
|
||
if (d.DescriptorType != ClientCharacteristicConfiguration) continue;
|
||
BTH_LE_GATT_DESCRIPTOR_VALUE value = {}; value.DescriptorType = ClientCharacteristicConfiguration;
|
||
value.ClientCharacteristicConfiguration.IsSubscribeToNotification = c.IsNotifiable;
|
||
value.ClientCharacteristicConfiguration.IsSubscribeToIndication = c.IsIndicatable;
|
||
if (SUCCEEDED(BluetoothGATTSetDescriptorValue(svc->Handle, const_cast<PBTH_LE_GATT_DESCRIPTOR>(&d), &value, BLUETOOTH_GATT_FLAG_NONE))) { configured = true; break; }
|
||
}
|
||
if (!configured)
|
||
{
|
||
if (sub->Event != nullptr) BluetoothGATTUnregisterEvent(sub->Event, BLUETOOTH_GATT_FLAG_NONE);
|
||
if (error != nullptr) *error = QStringLiteral("BLE notify enable failed: %1 / %2").arg(svc->Uuid, sub->CharUuid);
|
||
delete sub;
|
||
return false;
|
||
}
|
||
svc->Subs.append(sub);
|
||
return true;
|
||
}
|
||
|
||
bool AttachService(Dri_Ble_Struct_Port* port, Dri_Ble_Struct_Context* ctx, const ServiceIf& item, const QString& deviceLabel, int* charCount, int* subCount)
|
||
{
|
||
auto* svc = new Dri_Ble_Struct_ServiceContext();
|
||
svc->Ctx = ctx; svc->Uuid = item.Uuid; svc->Handle = OpenService(item.Path);
|
||
if (svc->Handle == INVALID_HANDLE_VALUE) { delete svc; return false; }
|
||
const auto list = Characteristics(svc->Handle);
|
||
if (list.isEmpty()) { CloseHandle(svc->Handle); delete svc; return false; }
|
||
bool keep = false;
|
||
for (const BTH_LE_GATT_CHARACTERISTIC& c : list)
|
||
{
|
||
if (!c.IsReadable && !c.IsNotifiable && !c.IsIndicatable) continue;
|
||
const QString charUuid = CharText(c);
|
||
++(*charCount);
|
||
if (c.IsNotifiable || c.IsIndicatable) { if (Subscribe(port, svc, deviceLabel, c, nullptr)) { keep = true; ++(*subCount); } }
|
||
if (c.IsReadable) { QByteArray bytes; if (ReadValue(svc->Handle, c, &bytes) && !bytes.isEmpty()) QueuePacket(ctx, Mid_Enum_RawPacketSource_BleGatt, PortName(deviceLabel, QStringLiteral("SVC %1 / CHR %2").arg(item.Uuid, charUuid)), bytes); }
|
||
}
|
||
if (keep) { ctx->Services.append(svc); return true; }
|
||
CloseHandle(svc->Handle);
|
||
delete svc;
|
||
return true;
|
||
}
|
||
|
||
void CloseHidPort(Dri_Ble_Struct_HidPort* hid)
|
||
{
|
||
Dri_Hid_CloseReadPort(&hid->ReadPort);
|
||
if ((hid->WriteHandle != nullptr) && (hid->WriteHandle != INVALID_HANDLE_VALUE)) CloseHandle(hid->WriteHandle);
|
||
delete hid;
|
||
}
|
||
|
||
bool OpenHidPort(Dri_Ble_Struct_Context* ctx, const HidIf& item, const QString& deviceLabel)
|
||
{
|
||
auto* hid = new Dri_Ble_Struct_HidPort();
|
||
const QString source = HidSource(item.UsagePage, item.Usage);
|
||
hid->UsagePage = item.UsagePage;
|
||
hid->Usage = item.Usage;
|
||
hid->OutputLength = item.OutputLength;
|
||
QString textError;
|
||
if (!Dri_Hid_InitReadPort(
|
||
&hid->ReadPort,
|
||
item.Path,
|
||
item.InputLength,
|
||
HidPacketSource(item.UsagePage, item.Usage),
|
||
PortName(deviceLabel, source),
|
||
&textError))
|
||
{
|
||
delete hid;
|
||
return false;
|
||
}
|
||
if (item.OutputLength > 0)
|
||
{
|
||
hid->WriteHandle = Dri_Hid_OpenWriteHandle(item.Path, nullptr);
|
||
}
|
||
ctx->Hids.append(hid);
|
||
return true;
|
||
}
|
||
|
||
QString FormatAddressLabel(const QString& Address)
|
||
{
|
||
const QString Formatted = Mid_FormatBleAddress(Address);
|
||
return Formatted.isEmpty() ? QStringLiteral("(unknown)") : Formatted;
|
||
}
|
||
|
||
bool ParsePnpIdValue(const QByteArray& bytes, quint16* vendorId, quint16* productId)
|
||
{
|
||
if (bytes.size() < 7) return false;
|
||
const quint8 vendorSource = static_cast<quint8>(bytes.at(0));
|
||
// Only accept USB-IF sourced PnP IDs so the fields map directly to USB VID/PID.
|
||
if (vendorSource != 0x02U) return false;
|
||
*vendorId =
|
||
static_cast<quint8>(bytes.at(1)) |
|
||
(static_cast<quint16>(static_cast<quint8>(bytes.at(2))) << 8);
|
||
*productId =
|
||
static_cast<quint8>(bytes.at(3)) |
|
||
(static_cast<quint16>(static_cast<quint8>(bytes.at(4))) << 8);
|
||
return true;
|
||
}
|
||
|
||
QVector<PnpIf> EnumPnps(const QVector<DeviceIf>& deviceList, QStringList* p_DebugList)
|
||
{
|
||
QVector<PnpIf> out;
|
||
for (const DeviceIf& device : deviceList)
|
||
{
|
||
HANDLE handle = OpenService(device.Path);
|
||
if (handle == INVALID_HANDLE_VALUE)
|
||
{
|
||
if (p_DebugList != nullptr)
|
||
{
|
||
p_DebugList->append(
|
||
QStringLiteral("PnP: 打开 BLE 设备失败 %1")
|
||
.arg(FormatAddressLabel(device.Address)));
|
||
}
|
||
continue;
|
||
}
|
||
|
||
USHORT serviceCount = 0;
|
||
HRESULT hr = BluetoothGATTGetServices(
|
||
handle,
|
||
0,
|
||
nullptr,
|
||
&serviceCount,
|
||
BLUETOOTH_GATT_FLAG_NONE);
|
||
if (FAILED(hr) && (hr != HRESULT_FROM_WIN32(ERROR_MORE_DATA)))
|
||
{
|
||
if (p_DebugList != nullptr)
|
||
{
|
||
p_DebugList->append(
|
||
QStringLiteral("PnP: 枚举服务失败 %1 / hr=%2")
|
||
.arg(FormatAddressLabel(device.Address), HResultText(hr)));
|
||
}
|
||
CloseHandle(handle);
|
||
continue;
|
||
}
|
||
|
||
QVector<BTH_LE_GATT_SERVICE> services(serviceCount);
|
||
hr = BluetoothGATTGetServices(
|
||
handle,
|
||
serviceCount,
|
||
services.data(),
|
||
&serviceCount,
|
||
BLUETOOTH_GATT_FLAG_NONE);
|
||
if (FAILED(hr))
|
||
{
|
||
if (p_DebugList != nullptr)
|
||
{
|
||
p_DebugList->append(
|
||
QStringLiteral("PnP: 读取服务列表失败 %1 / hr=%2")
|
||
.arg(FormatAddressLabel(device.Address), HResultText(hr)));
|
||
}
|
||
CloseHandle(handle);
|
||
continue;
|
||
}
|
||
services.resize(serviceCount);
|
||
|
||
QByteArray valueBytes;
|
||
bool found = false;
|
||
quint16 vendorId = 0;
|
||
quint16 productId = 0;
|
||
QStringList serviceUuidList;
|
||
QStringList charUuidList;
|
||
bool hasPnpChar = false;
|
||
|
||
for (const BTH_LE_GATT_SERVICE& service : services)
|
||
{
|
||
const QUuid serviceUuid = QtUuid(service.ServiceUuid);
|
||
const QString serviceUuidText =
|
||
serviceUuid.toString(QUuid::WithoutBraces).toUpper();
|
||
serviceUuidList.append(serviceUuidText);
|
||
|
||
USHORT charCount = 0;
|
||
hr = BluetoothGATTGetCharacteristics(
|
||
handle,
|
||
const_cast<PBTH_LE_GATT_SERVICE>(&service),
|
||
0,
|
||
nullptr,
|
||
&charCount,
|
||
BLUETOOTH_GATT_FLAG_NONE);
|
||
if (FAILED(hr) && (hr != HRESULT_FROM_WIN32(ERROR_MORE_DATA)))
|
||
{
|
||
if (p_DebugList != nullptr)
|
||
{
|
||
p_DebugList->append(
|
||
QStringLiteral("PnP: 枚举 180A 特征失败 %1 / hr=%2")
|
||
.arg(FormatAddressLabel(device.Address), HResultText(hr)));
|
||
}
|
||
break;
|
||
}
|
||
|
||
QVector<BTH_LE_GATT_CHARACTERISTIC> chars(charCount);
|
||
hr = BluetoothGATTGetCharacteristics(
|
||
handle,
|
||
const_cast<PBTH_LE_GATT_SERVICE>(&service),
|
||
charCount,
|
||
chars.data(),
|
||
&charCount,
|
||
BLUETOOTH_GATT_FLAG_NONE);
|
||
if (FAILED(hr))
|
||
{
|
||
if (p_DebugList != nullptr)
|
||
{
|
||
p_DebugList->append(
|
||
QStringLiteral("PnP: 读取 180A 特征失败 %1 / hr=%2")
|
||
.arg(FormatAddressLabel(device.Address), HResultText(hr)));
|
||
}
|
||
break;
|
||
}
|
||
chars.resize(charCount);
|
||
|
||
for (const BTH_LE_GATT_CHARACTERISTIC& characteristic : chars)
|
||
{
|
||
const QString charUuid = CharText(characteristic);
|
||
charUuidList.append(QStringLiteral("%1/%2").arg(serviceUuidText, charUuid));
|
||
if (charUuid != kChrPnpId) continue;
|
||
hasPnpChar = true;
|
||
if (!ReadValue(handle, characteristic, &valueBytes))
|
||
{
|
||
if (p_DebugList != nullptr)
|
||
{
|
||
p_DebugList->append(
|
||
QStringLiteral("PnP: 发现 2A50 但读取失败 %1 / svc=%2")
|
||
.arg(FormatAddressLabel(device.Address), serviceUuidText));
|
||
}
|
||
break;
|
||
}
|
||
found = ParsePnpIdValue(valueBytes, &vendorId, &productId);
|
||
if (p_DebugList != nullptr)
|
||
{
|
||
p_DebugList->append(
|
||
QStringLiteral("PnP: %1 / svc=%2 / raw=%3 / parsed=%4")
|
||
.arg(FormatAddressLabel(device.Address))
|
||
.arg(serviceUuidText)
|
||
.arg(Mid_GetHexText(valueBytes))
|
||
.arg(found
|
||
? FormatVidPidLabel(vendorId, productId)
|
||
: QStringLiteral("invalid")));
|
||
}
|
||
break;
|
||
}
|
||
break;
|
||
}
|
||
|
||
CloseHandle(handle);
|
||
if (!hasPnpChar && (p_DebugList != nullptr))
|
||
{
|
||
p_DebugList->append(
|
||
QStringLiteral("PnP: 未发现 2A50 %1 / services=%2 / chars=%3")
|
||
.arg(FormatAddressLabel(device.Address))
|
||
.arg(serviceUuidList.join(QStringLiteral(", ")))
|
||
.arg(charUuidList.join(QStringLiteral(", "))));
|
||
}
|
||
if (!found) continue;
|
||
|
||
bool exists = false;
|
||
for (const PnpIf& item : out)
|
||
{
|
||
if (item.Address == device.Address)
|
||
{
|
||
exists = true;
|
||
break;
|
||
}
|
||
}
|
||
if (exists) continue;
|
||
|
||
PnpIf item;
|
||
item.Address = device.Address;
|
||
item.VendorId = vendorId;
|
||
item.ProductId = productId;
|
||
out.append(item);
|
||
}
|
||
return out;
|
||
}
|
||
|
||
QStringList CollectPnpAddresses(
|
||
const QVector<PnpIf>& pnpList,
|
||
quint16 vendorId,
|
||
quint16 productId)
|
||
{
|
||
QStringList addressList;
|
||
for (const PnpIf& pnp : pnpList)
|
||
{
|
||
if ((pnp.VendorId == vendorId) && (pnp.ProductId == productId) &&
|
||
!addressList.contains(pnp.Address))
|
||
{
|
||
addressList.append(pnp.Address);
|
||
}
|
||
}
|
||
return addressList;
|
||
}
|
||
|
||
QStringList CollectHidAddresses(const QVector<HidIf>& HidList)
|
||
{
|
||
QStringList AddressList;
|
||
for (const HidIf& Hid : HidList)
|
||
{
|
||
const QString Address = ExtractAddress(Hid.InstanceId);
|
||
if (!Address.isEmpty() && !AddressList.contains(Address)) AddressList.append(Address);
|
||
}
|
||
return AddressList;
|
||
}
|
||
|
||
QString BuildCandidateSummary(
|
||
const QVector<PnpIf>& pnpList,
|
||
const QVector<HidIf>& HidList,
|
||
const QVector<ServiceIf>& ServiceList,
|
||
const QStringList& AllowedAddressList)
|
||
{
|
||
QHash<QString, int> HidCountMap;
|
||
QHash<QString, int> GattCountMap;
|
||
QHash<QString, QString> PnpTextMap;
|
||
for (const PnpIf& pnp : pnpList)
|
||
{
|
||
PnpTextMap.insert(
|
||
pnp.Address,
|
||
FormatVidPidLabel(pnp.VendorId, pnp.ProductId));
|
||
}
|
||
for (const HidIf& Hid : HidList)
|
||
{
|
||
const QString Address = ExtractAddress(Hid.InstanceId);
|
||
if (!Address.isEmpty()) ++HidCountMap[Address];
|
||
}
|
||
for (const ServiceIf& Service : ServiceList)
|
||
{
|
||
if (Service.Uuid != kSvcCustom) continue;
|
||
const QString Address = ExtractAddress(Service.InstanceId);
|
||
if (!Address.isEmpty() && AllowedAddressList.contains(Address)) ++GattCountMap[Address];
|
||
}
|
||
|
||
QStringList AddressList = HidCountMap.keys();
|
||
for (const QString& Address : GattCountMap.keys()) if (!AddressList.contains(Address)) AddressList.append(Address);
|
||
if (AddressList.isEmpty()) return QStringLiteral("无");
|
||
|
||
std::sort(AddressList.begin(), AddressList.end());
|
||
QStringList SummaryList;
|
||
for (const QString& Address : AddressList)
|
||
{
|
||
SummaryList.append(
|
||
QStringLiteral("%1 [pnp=%2, hid=%3, gatt=%4]")
|
||
.arg(FormatAddressLabel(Address))
|
||
.arg(PnpTextMap.value(Address, QStringLiteral("unknown")))
|
||
.arg(HidCountMap.value(Address))
|
||
.arg(GattCountMap.value(Address)));
|
||
}
|
||
return SummaryList.join(QLatin1Char('\n'));
|
||
}
|
||
|
||
QString BuildPnpSummary(
|
||
const QVector<PnpIf>& pnpList,
|
||
quint16 vendorId,
|
||
quint16 productId)
|
||
{
|
||
QStringList lineList;
|
||
for (const PnpIf& pnp : pnpList)
|
||
{
|
||
lineList.append(
|
||
QStringLiteral("%1 -> %2")
|
||
.arg(FormatAddressLabel(pnp.Address))
|
||
.arg(FormatVidPidLabel(pnp.VendorId, pnp.ProductId)));
|
||
}
|
||
|
||
if (lineList.isEmpty())
|
||
{
|
||
return QStringLiteral(
|
||
"PnP 扫描结果：未发现任何 DIS/PnP ID。");
|
||
}
|
||
|
||
QString summary = QStringLiteral(
|
||
"PnP 扫描结果（目标 %1）：\n%2")
|
||
.arg(FormatVidPidLabel(vendorId, productId))
|
||
.arg(lineList.join(QLatin1Char('\n')));
|
||
return summary;
|
||
}
|
||
|
||
QString BuildPnpProbeSummary(const QStringList& debugList)
|
||
{
|
||
if (debugList.isEmpty())
|
||
{
|
||
return QStringLiteral("PnP 探测日志：无。");
|
||
}
|
||
|
||
return QStringLiteral("PnP 探测日志：\n%1").arg(debugList.join(QLatin1Char('\n')));
|
||
}
|
||
|
||
} // namespace
|
||
|
||
void Dri_Ble_Close(Dri_Ble_Struct_Port* port)
|
||
{
|
||
Dri_Ble_Struct_Context* ctx = port->p_Context;
|
||
if (ctx != nullptr)
|
||
{
|
||
for (Dri_Ble_Struct_HidPort* hid : ctx->Hids) CloseHidPort(hid);
|
||
for (Dri_Ble_Struct_ServiceContext* svc : ctx->Services) for (Dri_Ble_Struct_Subscription* sub : svc->Subs) { sub->Port = nullptr; if (sub->Event != nullptr) BluetoothGATTUnregisterEvent(sub->Event, BLUETOOTH_GATT_FLAG_NONE); }
|
||
while (ctx->CallbackCount.load(std::memory_order_acquire) > 0) Sleep(1);
|
||
for (Dri_Ble_Struct_ServiceContext* svc : ctx->Services)
|
||
{
|
||
for (Dri_Ble_Struct_Subscription* sub : svc->Subs) delete sub;
|
||
if ((svc->Handle != nullptr) && (svc->Handle != INVALID_HANDLE_VALUE)) CloseHandle(svc->Handle);
|
||
delete svc;
|
||
}
|
||
delete ctx;
|
||
}
|
||
*port = Dri_Ble_Struct_Port();
|
||
}
|
||
bool Dri_Ble_Init(Dri_Ble_Struct_Port* port, const Mid_Struct_DeviceConfig& deviceConfig, QString* textStatus)
|
||
{
|
||
Dri_Ble_Close(port);
|
||
port->IsOpened = true;
|
||
port->p_Context = new Dri_Ble_Struct_Context();
|
||
|
||
const QVector<DeviceIf> devices = EnumBleDevices();
|
||
const QVector<HidIf> hids = EnumBleHids();
|
||
const QVector<ServiceIf> services = EnumServices();
|
||
QStringList pnpDebugList;
|
||
const QVector<PnpIf> pnps = EnumPnps(devices, &pnpDebugList);
|
||
const QStringList HidAddressList = CollectPnpAddresses(
|
||
pnps,
|
||
deviceConfig.VendorId,
|
||
deviceConfig.ProductId);
|
||
QString targetAddress;
|
||
QString SelectStatus;
|
||
if (HidAddressList.size() == 1)
|
||
{
|
||
targetAddress = HidAddressList.first();
|
||
}
|
||
else
|
||
{
|
||
SelectStatus = HidAddressList.isEmpty()
|
||
? QStringLiteral("未检测到匹配 PnP ID %1 的 BLE 设备。")
|
||
.arg(FormatVidPidLabel(deviceConfig.VendorId, deviceConfig.ProductId))
|
||
: QStringLiteral("检测到多个匹配 PnP ID %1 的 BLE 设备，无法唯一绑定。")
|
||
.arg(FormatVidPidLabel(deviceConfig.VendorId, deviceConfig.ProductId));
|
||
}
|
||
QString deviceLabel = targetAddress.isEmpty() ? QString() : DeviceLabel(targetAddress);
|
||
|
||
int charCount = 0;
|
||
int subCount = 0;
|
||
if (!targetAddress.isEmpty())
|
||
{
|
||
for (const ServiceIf& item : services)
|
||
{
|
||
if ((item.Uuid == kSvcCustom) && (ExtractAddress(item.InstanceId) == targetAddress)) AttachService(port, port->p_Context, item, deviceLabel, &charCount, &subCount);
|
||
}
|
||
}
|
||
|
||
if (deviceLabel.isEmpty() && !targetAddress.isEmpty()) deviceLabel = DeviceLabel(targetAddress);
|
||
|
||
int hidCount = 0;
|
||
if (!targetAddress.isEmpty())
|
||
{
|
||
for (const HidIf& hid : hids)
|
||
{
|
||
if ((ExtractAddress(hid.InstanceId) == targetAddress) && OpenHidPort(port->p_Context, hid, deviceLabel)) ++hidCount;
|
||
}
|
||
}
|
||
|
||
if (deviceLabel.isEmpty() && !hids.isEmpty()) deviceLabel = QStringLiteral("BLE");
|
||
|
||
port->IsConnected = (charCount > 0) || (hidCount > 0);
|
||
|
||
|
||
return port->IsConnected;
|
||
}
|
||
bool Dri_Ble_Read(Dri_Ble_Struct_Port* port, Mid_Struct_RawPacket* packet, QString*)
|
||
{
|
||
*packet = Mid_Struct_RawPacket();
|
||
packet->PortName = QStringLiteral("Bluetooth");
|
||
if (!port->IsOpened || (port->p_Context == nullptr)) return false;
|
||
for (Dri_Ble_Struct_HidPort* hid : port->p_Context->Hids)
|
||
{
|
||
Mid_Struct_RawPacket hidPacket;
|
||
if (Dri_Hid_Read(&hid->ReadPort, &hidPacket, nullptr))
|
||
{
|
||
QMutexLocker lock(&port->p_Context->Mutex);
|
||
port->p_Context->Queue.append(hidPacket);
|
||
}
|
||
}
|
||
QMutexLocker lock(&port->p_Context->Mutex);
|
||
if (port->p_Context->Queue.isEmpty()) return false;
|
||
*packet = port->p_Context->Queue.takeFirst();
|
||
return packet->IsValid;
|
||
}
|
||
bool Dri_Ble_Write(Dri_Ble_Struct_Port* port, const QByteArray& bytes, QString* textStatus)
|
||
{
|
||
if (!port->IsOpened || (port->p_Context == nullptr)) { if (textStatus != nullptr) *textStatus = QStringLiteral("Bluetooth port is not open, packet send was skipped."); return false; }
|
||
if (bytes.isEmpty()) { if (textStatus != nullptr) *textStatus = QStringLiteral("Bluetooth packet is empty."); return false; }
|
||
const auto TryWrite = [&](auto MatchFunc, const QString& OkText)
|
||
{
|
||
for (Dri_Ble_Struct_HidPort* hid : port->p_Context->Hids)
|
||
{
|
||
if (!MatchFunc(hid->UsagePage, hid->Usage) || (hid->WriteHandle == INVALID_HANDLE_VALUE)) continue;
|
||
if (Dri_Hid_WritePacket(hid->WriteHandle, hid->OutputLength, bytes, nullptr))
|
||
{
|
||
if (textStatus != nullptr) *textStatus = OkText;
|
||
return true;
|
||
}
|
||
}
|
||
return false;
|
||
};
|
||
if (TryWrite(IsCommandHid, QStringLiteral("Bluetooth Vendor command packet sent."))) return true;
|
||
if (TryWrite(IsVendorHid, QStringLiteral("Bluetooth Vendor packet sent."))) return true;
|
||
if (textStatus != nullptr) *textStatus = QStringLiteral("No writable Bluetooth Vendor endpoint was found.");
|
||
return false;
|
||
}
|
||
|