Windows: improved handling of composite devices

Author: manuelbl

java-does-usb/pom.xml

@@ -149,6 +149,18 @@
             <version>3.24.2</version>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>org.tinylog</groupId>
+            <artifactId>tinylog-impl</artifactId>
+            <version>2.6.2</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.tinylog</groupId>
+            <artifactId>jsl-tinylog</artifactId>
+            <version>2.6.2</version>
+            <scope>test</scope>
+        </dependency>
     </dependencies>
 
 </project>

java-does-usb/src/main/java/net/codecrete/usb/windows/InterfaceHandle.java

@@ -13,6 +13,10 @@
  * Handles for WinUSB devices and interfaces
  */
 class InterfaceHandle {
+    InterfaceHandle(int interfaceNumber, int firstInterfaceNumber) {
+        this.interfaceNumber = interfaceNumber;
+        this.firstInterfaceNumber = firstInterfaceNumber;
+    }
     /**
      * The number of this interface.
      */
@@ -21,13 +25,6 @@ class InterfaceHandle {
      * The number of the first interface in the same composite function.
      */
     int firstInterfaceNumber;
-    /**
-     * The device path.
-     * <p>
-     * This is only set for the first interface in a composite function.
-     * </p>
-     */
-    String devicePath;
     /**
      * The file handle of the device.
      * <p>
@@ -39,7 +36,7 @@ class InterfaceHandle {
      * The WinUSB handle of the interface.
      */
     @SuppressWarnings("java:S1700")
-    MemorySegment interfaceHandle;
+    MemorySegment winusbHandle;
     /**
      * Count indicating how many interface depend on the device being open.
      */

java-does-usb/src/main/java/net/codecrete/usb/windows/WindowsUSBDevice.java

@@ -31,10 +31,7 @@
 import java.lang.invoke.MethodHandles;
 import java.lang.invoke.MethodType;
 import java.util.*;
-import java.util.regex.Pattern;
-import java.util.stream.Collectors;
 
-import static java.lang.System.Logger.Level.DEBUG;
 import static java.lang.System.Logger.Level.INFO;
 import static java.lang.foreign.MemorySegment.NULL;
 import static java.lang.foreign.ValueLayout.*;
@@ -177,61 +174,19 @@ private USBDevice createDeviceFromDeviceInfo(DeviceInfoSet deviceInfoSet, String
                 hubHandles.put(hubPath, hubHandle);
             }
 
-            // check for composite device
-            var children = getChildDevices(deviceInfoSet, devicePath);
-
-            return createDevice(devicePath, children, hubHandle, usbPortNum);
-        }
-    }
-
-    @SuppressWarnings({"java:S106", "java:S1168"})
-    private Map<Integer, String> getChildDevices(DeviceInfoSet deviceInfoSet, String devicePath) {
-        if (!deviceInfoSet.isCompositeDevice())
-            return null;
-
-        // For certain devices, it seems to take some time until the "Device_Children"
-        // entry is present. So we retry a few times if needed and pause in between.
-        List<String> childrenInstanceIDs;
-        var numTries = 5;
-        while (true) {
-            numTries -= 1;
-            childrenInstanceIDs = deviceInfoSet.getStringListProperty(Children);
-            if (childrenInstanceIDs != null || numTries == 0)
-                break;
-
-            // sleep and retry
-            try {
-                LOG.log(DEBUG, "Sleeping for 200ms (after unsuccessfully retrieving DEVPKEY_Device_Children)");
-                //noinspection BusyWait
-                Thread.sleep(200);
-            } catch (InterruptedException e) {
-                Thread.currentThread().interrupt();
-            }
+            return createDevice(devicePath, hubHandle, usbPortNum);
         }
-
-        if (childrenInstanceIDs == null) {
-            LOG.log(DEBUG, "unable to retrieve information about children of device {0} - ignoring", devicePath);
-            return null;
-        }
-
-        // create children map (interface number -> device path)
-        return childrenInstanceIDs.stream()
-                .map(WindowsUSBDeviceRegistry::getNumberPathTuple)
-                .filter(Objects::nonNull)
-                .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
     }
 
     /**
      * Retrieve device descriptor and create {@code USBDevice} instance
      *
      * @param devicePath the device path
-     * @param children   map of child device paths, indexed by the first interface number
      * @param hubHandle  the hub handle (parent)
      * @param usbPortNum the USB port number
      * @return the {@code USBDevice} instance
      */
-    private USBDevice createDevice(String devicePath, Map<Integer, String> children, MemorySegment hubHandle,
-                                   int usbPortNum) {
+    private USBDevice createDevice(String devicePath, MemorySegment hubHandle, int usbPortNum) {
 
         try (var arena = Arena.ofConfined()) {
 
@@ -253,7 +208,8 @@ private USBDevice createDevice(String devicePath, Map<Integer, String> children,
 
             var configDesc = getDescriptor(hubHandle, usbPortNum, CONFIGURATION_DESCRIPTOR_TYPE, 0, (short) 0, arena);
 
-            var device = new WindowsUSBDevice(devicePath, children, vendorId, productId, configDesc);
+            // create new device
+            var device = new WindowsUSBDevice(devicePath, vendorId, productId, configDesc);
             device.setFromDeviceDescriptor(descriptorSegment);
             device.setProductString(descriptorSegment, index -> getStringDescriptor(hubHandle, usbPortNum, index));
 
@@ -397,54 +353,4 @@ protected int findDeviceIndex(List<USBDevice> deviceList, Object deviceId) {
         }
         return -1;
     }
-
-    /**
-     * Looks up the interface number and device path for the child device with the given instance ID.
-     *
-     * @param instanceId child instance ID
-     * @return tuple consisting of interface number and device path, or {@code null} if unsuccessful
-     */
-    private static Map.Entry<Integer, String> getNumberPathTuple(String instanceId) {
-        try (var deviceInfoSet = DeviceInfoSet.ofInstance(instanceId)) {
-
-            // get hardware IDs (to extract interface number)
-            var hardwareIds = deviceInfoSet.getStringListProperty(HardwareIds);
-            if (hardwareIds == null)
-                throwException("internal error (device property 'HardwareIds' is missing)");
-            var interfaceNumber = extractInterfaceNumber(hardwareIds);
-            if (interfaceNumber == -1) {
-                LOG.log(DEBUG, "Child device {0} has no interface number", instanceId);
-                return null;
-            }
-
-            var devicePath = deviceInfoSet.getDevicePathByGUID(instanceId);
-            if (devicePath == null) {
-                LOG.log(DEBUG, "Child device {0} has no device path", instanceId);
-                return null;
-            }
-
-            return new AbstractMap.SimpleImmutableEntry<>(interfaceNumber, devicePath);
-        }
-    }
-
-    private static final Pattern MULTIPLE_INTERFACE_ID = Pattern.compile(
-            "USB\\\\VID_[0-9A-Fa-f]{4}&PID_[0-9A-Fa-f]{4}&MI_([0-9A-Fa-f]{2})");
-
-    private static int extractInterfaceNumber(List<String> hardwareIds) {
-        // Also see https://docs.microsoft.com/en-us/windows-hardware/drivers/install/standard-usb-identifiers#multiple-interface-usb-devices
-
-        for (var id : hardwareIds) {
-            var matcher = MULTIPLE_INTERFACE_ID.matcher(id);
-            if (matcher.find()) {
-                var intfHexNumber = matcher.group(1);
-                try {
-                    return Integer.parseInt(intfHexNumber, 16);
-                } catch (NumberFormatException e) {
-                    // ignore and try next one
-                }
-            }
-        }
-
-        return -1;
-    }
 }

java-does-usb/src/main/java/net/codecrete/usb/windows/WindowsUSBDeviceRegistry.java

@@ -51,6 +51,20 @@ public static int WinUsb_Initialize(MemorySegment DeviceHandle, MemorySegment In
         }
     }
 
+    private static final FunctionDescriptor WinUsb_GetAssociatedInterface$FUNC = FunctionDescriptor.of(JAVA_INT, ADDRESS, JAVA_BYTE, ADDRESS);
+
+    private static final MethodHandle WinUsb_GetAssociatedInterface$MH =
+            LINKER.downcallHandle(LOOKUP.find("WinUsb_GetAssociatedInterface").get(), WinUsb_GetAssociatedInterface$FUNC, Win.LAST_ERROR_STATE);
+
+    public static int WinUsb_GetAssociatedInterface(MemorySegment InterfaceHandle, byte AssociatedInterfaceIndex,
+                                                    MemorySegment AssociatedInterfaceHandle, MemorySegment lastErrorState) {
+        try {
+            return (int) WinUsb_GetAssociatedInterface$MH.invokeExact(lastErrorState, InterfaceHandle, AssociatedInterfaceIndex, AssociatedInterfaceHandle);
+        } catch (Throwable ex) {
+            throw new AssertionError(ex);
+        }
+    }
+
     private static final FunctionDescriptor WinUsb_SetCurrentAlternateSetting$FUNC = FunctionDescriptor.of(JAVA_INT,
             ADDRESS, JAVA_BYTE);
 

java-does-usb/src/main/java/net/codecrete/usb/windows/winsdk/WinUSB2.java

@@ -0,0 +1,3 @@
+writer        = console
+writer.format = {date: HH:mm:ss.SSS} {level|size=5} [{class|size=40}] {message}
+writer.level  = debug

java-does-usb/src/test/resources/tinylog.properties

@@ -22,8 +22,8 @@
 #include <regex>
 #include <thread>
 
-usb_device::usb_device(usb_registry* registry, std::wstring&& device_path, int vendor_id, int product_id, const std::vector<uint8_t>& config_desc, bool is_composite)
-: registry_(registry), vendor_id_(vendor_id), product_id_(product_id), is_open_(false), device_path_(std::move(device_path)), is_composite_(is_composite) {
+usb_device::usb_device(usb_registry* registry, std::wstring&& device_path, int vendor_id, int product_id, const std::vector<uint8_t>& config_desc)
+: registry_(registry), vendor_id_(vendor_id), product_id_(product_id), is_open_(false), device_path_(std::move(device_path)) {
 
     config_parser parser{};
     parser.parse(config_desc.data(), static_cast<int>(config_desc.size()));
@@ -513,27 +513,27 @@ int usb_device::get_child_device_path(const std::wstring& child_id, int interfac
     auto hardware_ids = dev_info_set.get_device_property_string_list(DEVPKEY_Device_HardwareIds);
     if (hardware_ids.empty()) {
         std::wcerr << "child device " << child_id << " has no hardware IDs" << std::endl;
-        return 0;
+        return 0; // continue with next child
     }
 
     auto intf_num = extract_interface_number(hardware_ids);
     if (intf_num == -1) {
         std::wcerr << "child device " << child_id << " has no interface number" << std::endl;
-        return 0;
+        return 0; // continue with next child
     }
 
     if (intf_num != interface_num)
-        return 0;
+        return 0; // continue with next child
 
     device_path = dev_info_set.get_device_path_by_guid(child_id);
     if (device_path.empty()) {
         std::wcerr << "child device " << child_id << " has no device path" << std::endl;
-        return -1;
+        return -1; // retry later
     }
 
     std::wcerr << "child device: interface=" << intf_num << ", device path=" << device_path << std::endl;
     interface_device_paths_[interface_num] = device_path;
-    return 1;
+    return 1;  // success
 }
 
 static const std::wregex multiple_interface_id_pattern(L"USB\\\\VID_[0-9A-Fa-f]{4}&PID_[0-9A-Fa-f]{4}&MI_([0-9A-Fa-f]{2})");

reference/windows/USB/usb_device.cpp

@@ -248,7 +248,7 @@ class usb_device {
         interface_handle(int intf_num, int first_num, std::wstring&& path);
     };
 
-    usb_device(usb_registry* registry, std::wstring&& device_path, int vendor_id, int product_id, const std::vector<uint8_t>& config_desc, bool is_composite);
+    usb_device(usb_registry* registry, std::wstring&& device_path, int vendor_id, int product_id, const std::vector<uint8_t>& config_desc);
     void set_product_names(const std::string& manufacturer, const std::string& product, const std::string& serial_number);
     void build_handles(const std::wstring& device_path);
     std::wstring get_interface_device_path(int interface_num);
@@ -289,7 +289,6 @@ class usb_device {
     std::vector<usb_composite_function> functions_;
     std::vector<interface_handle> interface_handles_;
     std::map<int, std::wstring> interface_device_paths_;
-    bool is_composite_;
 
     friend class usb_registry;
     friend class usb_istreambuf;

reference/windows/USB/usb_device.hpp

@@ -167,10 +167,10 @@ std::shared_ptr<usb_device> usb_registry::create_device_from_device_info(device_
         hub_handles[hub_path] = hub_handle;
     }
 
-    return create_device(std::move(device_path), dev_info_set.is_composite_device(), hub_handle, usb_port_num);
+    return create_device(std::move(device_path), hub_handle, usb_port_num);
 }
 
-std::shared_ptr<usb_device> usb_registry::create_device(std::wstring&& device_path, bool is_composite, HANDLE hub_handle, DWORD usb_port_num) {
+std::shared_ptr<usb_device> usb_registry::create_device(std::wstring&& device_path, HANDLE hub_handle, DWORD usb_port_num) {
 
     // get device descriptor
     USB_NODE_CONNECTION_INFORMATION_EX conn_info = { 0 };
@@ -186,8 +186,7 @@ std::shared_ptr<usb_device> usb_registry::create_device(std::wstring&& device_pa
     auto config_desc = get_descriptor(hub_handle, usb_port_num, USB_CONFIGURATION_DESCRIPTOR_TYPE, 0, 0);
 
     // Create new device
-    // usb_registry* registry, std::wstring&& device_path, int vendor_id, int product_id, const std::vector<uint8_t>& config_desc, std::map<int, std::wstring>&& children
-    std::shared_ptr<usb_device> device(new usb_device(this, std::move(device_path), vendorId, productId, config_desc, is_composite));
+    std::shared_ptr<usb_device> device(new usb_device(this, std::move(device_path), vendorId, productId, config_desc));
     device->set_product_names(
         get_string(hub_handle, usb_port_num, conn_info.DeviceDescriptor.iManufacturer),
         get_string(hub_handle, usb_port_num, conn_info.DeviceDescriptor.iProduct),

reference/windows/USB/usb_registry.cpp

@@ -53,11 +53,10 @@ class usb_registry {
 
     void detect_present_devices();
     std::shared_ptr<usb_device> create_device_from_device_info(device_info_set& dev_info_set, std::wstring&& device_path, std::map<std::wstring, HANDLE>& hub_handles);
-    std::shared_ptr<usb_device> create_device(std::wstring&& device_path, bool is_composite, HANDLE hub_handle, DWORD usb_port_num);
+    std::shared_ptr<usb_device> create_device(std::wstring&& device_path, HANDLE hub_handle, DWORD usb_port_num);
 
     static std::string get_string(HANDLE hub_handle, ULONG usb_port_num, int index);
     static std::vector<uint8_t> get_descriptor(HANDLE hub_handle, ULONG usb_port_num, uint16_t descriptor_type, int index, int language_id, int request_size = 0);
-    static int extract_interface_number(const std::vector<std::wstring>& hardware_ids);
 
     void on_device_connected(const WCHAR* path);
     void on_device_disconnected(const WCHAR* path);