usb 2.4.2 → 2.5.1

package/test/webusb.coffee

@@ -3,187 +3,187 @@ util = require('util')
 webusb = require('../').webusb
 
 if typeof gc is 'function'
-	# running with --expose-gc, do a sweep between tests so valgrind blames the right one
-	afterEach -> gc()
+    # running with --expose-gc, do a sweep between tests so valgrind blames the right one
+    afterEach -> gc()
 
 describe 'WebUSB Module', ->
-	it 'should describe basic constants', ->
-		assert.notEqual(webusb, undefined, "webusb must be undefined")
+    it 'should describe basic constants', ->
+        assert.notEqual(webusb, undefined, "webusb must be undefined")
 
 describe 'requestDevice', ->
-	it 'should return a device', ->
-		device = await webusb.requestDevice({ filters: [{ vendorId: 0x59e3 }] });
-		assert.notEqual(device, undefined)
+    it 'should return a device', ->
+        device = await webusb.requestDevice({ filters: [{ vendorId: 0x59e3 }] });
+        assert.notEqual(device, undefined)
 
 describe 'getDevices', ->
-	it 'should return one device', ->
-		device = await webusb.requestDevice({ filters: [{ vendorId: 0x59e3 }] });
-		l = await webusb.getDevices()
-		assert.equal(l.length, 1)
-		assert.notEqual(l[0], undefined)
-		assert.deepEqual(l[0], device)
+    it 'should return one device', ->
+        device = await webusb.requestDevice({ filters: [{ vendorId: 0x59e3 }] });
+        l = await webusb.getDevices()
+        assert.equal(l.length, 1)
+        assert.notEqual(l[0], undefined)
+        assert.deepEqual(l[0], device)
 
 describe 'Device properties', ->
-	device = null
-	before ->
-		device = await webusb.requestDevice({ filters: [{ vendorId: 0x59e3 }] });
+    device = null
+    before ->
+        device = await webusb.requestDevice({ filters: [{ vendorId: 0x59e3 }] });
 
-	it 'should have usb version properties', ->
-		assert.equal(device.usbVersionMajor, 1)
-		assert.equal(device.usbVersionMinor, 1)
-		assert.equal(device.usbVersionSubminor, 0)
+    it 'should have usb version properties', ->
+        assert.equal(device.usbVersionMajor, 1)
+        assert.equal(device.usbVersionMinor, 1)
+        assert.equal(device.usbVersionSubminor, 0)
 
-	it 'should have device version properties', ->
-		assert.equal(device.deviceVersionMajor, 1)
-		assert.equal(device.deviceVersionMinor, 1)
-		assert.equal(device.deviceVersionSubminor, 0)
+    it 'should have device version properties', ->
+        assert.equal(device.deviceVersionMajor, 1)
+        assert.equal(device.deviceVersionMinor, 1)
+        assert.equal(device.deviceVersionSubminor, 0)
 
-	it 'should have class properties', ->
-		assert.equal(device.deviceClass, 0)
-		assert.equal(device.deviceSubclass, 0)
+    it 'should have class properties', ->
+        assert.equal(device.deviceClass, 0)
+        assert.equal(device.deviceSubclass, 0)
 
-	it 'should have protocol property', ->
-		assert.equal(device.deviceProtocol, 0)
+    it 'should have protocol property', ->
+        assert.equal(device.deviceProtocol, 0)
 
-	it 'should have vid/pid properties', ->
-		assert.equal(device.vendorId, 0x59e3)
-		assert.equal(device.productId, 0x0a23)
+    it 'should have vid/pid properties', ->
+        assert.equal(device.vendorId, 0x59e3)
+        assert.equal(device.productId, 0x0a23)
 
-	it 'should have a single configuration', ->
-		assert.equal(device.configurations.length, 1)
-		assert.equal(device.configurations[0].configurationValue, 1)
+    it 'should have a single configuration', ->
+        assert.equal(device.configurations.length, 1)
+        assert.equal(device.configurations[0].configurationValue, 1)
 
-	it 'should have a configuration property', ->
-		assert.notEqual(device.configuration, undefined)
+    it 'should have a configuration property', ->
+        assert.notEqual(device.configuration, undefined)
 
-	it 'should have a single interface', ->
-		assert.equal(device.configuration.interfaces.length, 1)
-		assert.equal(device.configuration.interfaces[0].interfaceNumber, 0)
+    it 'should have a single interface', ->
+        assert.equal(device.configuration.interfaces.length, 1)
+        assert.equal(device.configuration.interfaces[0].interfaceNumber, 0)
 
-	it 'should have a single alternate', ->
-		assert.equal(device.configuration.interfaces[0].alternates.length, 1)
-		assert.equal(device.configuration.interfaces[0].alternates[0].alternateSetting, 0)
+    it 'should have a single alternate', ->
+        assert.equal(device.configuration.interfaces[0].alternates.length, 1)
+        assert.equal(device.configuration.interfaces[0].alternates[0].alternateSetting, 0)
 
 describe 'String descriptors', ->
-	device = null
-	before ->
-		device = await webusb.requestDevice({ filters: [{ vendorId: 0x59e3 }] });
+    device = null
+    before ->
+        device = await webusb.requestDevice({ filters: [{ vendorId: 0x59e3 }] });
 
-	it 'gets serialNumber string', ->
-		assert.equal(device.serialNumber, "TEST_DEVICE")
+    it 'gets serialNumber string', ->
+        assert.equal(device.serialNumber, "TEST_DEVICE")
 
-	it 'gets manufacturerName string', ->
-		assert.equal(device.manufacturerName, "Nonolith Labs")
+    it 'gets manufacturerName string', ->
+        assert.equal(device.manufacturerName, "Nonolith Labs")
 
-	it 'gets productName string', ->
-		assert.equal(device.productName, "STM32F103 Test Device")
+    it 'gets productName string', ->
+        assert.equal(device.productName, "STM32F103 Test Device")
 
 describe 'Device access', ->
-	device = null
-	before ->
-		device = await webusb.requestDevice({ filters: [{ vendorId: 0x59e3 }] });
+    device = null
+    before ->
+        device = await webusb.requestDevice({ filters: [{ vendorId: 0x59e3 }] });
 
-	it 'is not open', ->
-		assert.equal(device.opened, false)
+    it 'is not open', ->
+        assert.equal(device.opened, false)
 
-	it 'is opens and closes', ->
-		assert.equal(device.opened, false)
-		await device.open()
-		assert.equal(device.opened, true)
-		await device.close()
-		assert.equal(device.opened, false)
+    it 'is opens and closes', ->
+        assert.equal(device.opened, false)
+        await device.open()
+        assert.equal(device.opened, true)
+        await device.close()
+        assert.equal(device.opened, false)
 
 describe 'Configurations', ->
-	device = null
-	before ->
-		device = await webusb.requestDevice({ filters: [{ vendorId: 0x59e3 }] });
-		await device.open()
+    device = null
+    before ->
+        device = await webusb.requestDevice({ filters: [{ vendorId: 0x59e3 }] });
+        await device.open()
 
-	it 'selects existing configuration', ->
-		assert.doesNotReject(device.selectConfiguration(1))
+    it 'selects existing configuration', ->
+        assert.doesNotReject(device.selectConfiguration(1))
 
-	it 'fails to select missing configuration', ->
-		assert.rejects(device.selectConfiguration(99))
+    it 'fails to select missing configuration', ->
+        assert.rejects(device.selectConfiguration(99))
 
-	after ->
-		device.close()
+    after ->
+        device.close()
 
 describe 'Interfaces', ->
-	device = null
-	before ->
-		device = await webusb.requestDevice({ filters: [{ vendorId: 0x59e3 }] });
-		await device.open()
+    device = null
+    before ->
+        device = await webusb.requestDevice({ filters: [{ vendorId: 0x59e3 }] });
+        await device.open()
 
-	it 'claims existing interface', ->
-		assert.doesNotReject(device.claimInterface(0))
+    it 'claims existing interface', ->
+        assert.doesNotReject(device.claimInterface(0))
 
-	it 'fails to claim missing interface', ->
-		assert.rejects(device.claimInterface(99))
+    it 'fails to claim missing interface', ->
+        assert.rejects(device.claimInterface(99))
 
-	it 'releases existing interface', ->
-		assert.doesNotReject(device.releaseInterface(0))
+    it 'releases existing interface', ->
+        assert.doesNotReject(device.releaseInterface(0))
 
-	it 'fails to release missing interface', ->
-		assert.rejects(device.releaseInterface(99))
+    it 'fails to release missing interface', ->
+        assert.rejects(device.releaseInterface(99))
 
-	after ->
-		device.close()
+    after ->
+        device.close()
 
 describe 'Alternates', ->
-	device = null
-	before ->
-		device = await webusb.requestDevice({ filters: [{ vendorId: 0x59e3 }] });
-		await device.open()
-		await device.claimInterface(0)
+    device = null
+    before ->
+        device = await webusb.requestDevice({ filters: [{ vendorId: 0x59e3 }] });
+        await device.open()
+        await device.claimInterface(0)
 
-	it 'selects existing alternate', ->
-		assert.doesNotReject(device.selectAlternateInterface(0, 0))
+    it 'selects existing alternate', ->
+        assert.doesNotReject(device.selectAlternateInterface(0, 0))
 
-	after ->
-		device.close()
+    after ->
+        device.close()
 
 describe 'Transfers', ->
-	device = null
-	b = Uint8Array.from([0x30...0x40]).buffer
-
-	before ->
-		device = await webusb.requestDevice({ filters: [{ vendorId: 0x59e3 }] });
-		await device.open()
-		await device.claimInterface(0)
-
-	it 'should control transfer OUT', ->
-		transferResult = await device.controlTransferOut({
-			requestType: 'device',
-			recipient: 'vendor';
-			request: 0x81,
-			value: 0,
-			index: 0
-		}, b)
-
-		assert.equal(transferResult.status, 'ok')
-		assert.equal(transferResult.bytesWritten, b.byteLength)
-
-	it 'should control transfer IN', ->
-		transferResult = await device.controlTransferIn({
-			requestType: 'device',
-			recipient: 'vendor';
-			request: 0x81,
-			value: 0,
-			index: 0
-		}, 128)
-
-		assert.equal(transferResult.status, 'ok')
-		assert.equal(transferResult.data.buffer.toString(), b.toString())
-
-	it 'should transfer OUT', ->
-		transferResult = await device.transferOut(2, b)
-		assert.equal(transferResult.status, 'ok')
-		assert.equal(transferResult.bytesWritten, b.byteLength)
-
-	it 'should transfer IN', ->
-		transferResult = await device.transferIn(1, 64)
-		assert.equal(transferResult.status, 'ok')
-		assert.equal(transferResult.data.byteLength, 64)
-
-	after ->
-		device.close()
+    device = null
+    b = Uint8Array.from([0x30...0x40]).buffer
+
+    before ->
+        device = await webusb.requestDevice({ filters: [{ vendorId: 0x59e3 }] });
+        await device.open()
+        await device.claimInterface(0)
+
+    it 'should control transfer OUT', ->
+        transferResult = await device.controlTransferOut({
+            requestType: 'device',
+            recipient: 'vendor';
+            request: 0x81,
+            value: 0,
+            index: 0
+        }, b)
+
+        assert.equal(transferResult.status, 'ok')
+        assert.equal(transferResult.bytesWritten, b.byteLength)
+
+    it 'should control transfer IN', ->
+        transferResult = await device.controlTransferIn({
+            requestType: 'device',
+            recipient: 'vendor';
+            request: 0x81,
+            value: 0,
+            index: 0
+        }, 128)
+
+        assert.equal(transferResult.status, 'ok')
+        assert.equal(transferResult.data.buffer.toString(), b.toString())
+
+    it 'should transfer OUT', ->
+        transferResult = await device.transferOut(2, b)
+        assert.equal(transferResult.status, 'ok')
+        assert.equal(transferResult.bytesWritten, b.byteLength)
+
+    it 'should transfer IN', ->
+        transferResult = await device.transferIn(1, 64)
+        assert.equal(transferResult.status, 'ok')
+        assert.equal(transferResult.data.byteLength, 64)
+
+    after ->
+        device.close()

package/tsc/usb/bindings.ts

@@ -31,6 +31,7 @@ export declare function setDebugLevel(level: number): void;
  */
 export declare function useUsbDkBackend(): void;
 
+export declare function _supportedHotplugEvents(): number;
 export declare function _enableHotplugEvents(): void;
 export declare function _disableHotplugEvents(): void;
 export declare function _getLibusbCapability(capability: number): number;

package/tsc/usb/endpoint.ts

@@ -52,7 +52,7 @@ export class InEndpoint extends Endpoint {
     /** Endpoint direction. */
     public direction: 'in' | 'out' = 'in';
 
-    protected pollTransfers: Transfer[] | undefined;
+    protected pollTransfers: Transfer[] = [];
     protected pollTransferSize = 0;
     protected pollPending = 0;
     public pollActive = false;
@@ -113,6 +113,7 @@ export class InEndpoint extends Endpoint {
 
                 if (this.pollPending === 0) {
                     this.pollTransfers = [];
+                    this.pollActive = false;
                     this.emit('end');
                 }
             }
@@ -138,7 +139,7 @@ export class InEndpoint extends Endpoint {
     }
 
     protected startPollTransfers(nTransfers = 3, transferSize = this.descriptor.wMaxPacketSize, callback: (error: LibUSBException | undefined, buffer: Buffer, actualLength: number) => void): Transfer[] {
-        if (this.pollTransfers) {
+        if (this.pollActive) {
             throw new Error('Polling already active');
         }
 
@@ -163,7 +164,7 @@ export class InEndpoint extends Endpoint {
      * @param callback
      */
     public stopPoll(callback?: () => void): void {
-        if (!this.pollTransfers) {
+        if (!this.pollActive) {
             throw new Error('Polling is not active.');
         }
         for (let i = 0; i < this.pollTransfers.length; i++) {

package/tsc/usb/index.ts

@@ -18,6 +18,11 @@ interface EventListeners<T> {
     removeListener: keyof T;
 }
 
+interface DeviceIds {
+    idVendor: number;
+    idProduct: number;
+}
+
 declare module './bindings' {
 
     /* eslint-disable @typescript-eslint/no-empty-interface */
@@ -26,6 +31,8 @@ declare module './bindings' {
     interface DeviceEvents extends EventListeners<DeviceEvents> {
         attach: Device;
         detach: Device;
+        attachIds: DeviceIds;
+        detachIds: DeviceIds;
     }
 
     function addListener<K extends keyof DeviceEvents>(event: K, listener: (arg: DeviceEvents[K]) => void): void;
@@ -40,41 +47,83 @@ declare module './bindings' {
     function listenerCount<K extends keyof DeviceEvents>(event: K): number;
 }
 
-// Polling mechanism for discovering device changes until this is fixed:
-// https://github.com/libusb/libusb/issues/86
-const pollTimeout = 500;
-const hotplugSupported = usb._getLibusbCapability(usb.LIBUSB_CAP_HAS_HOTPLUG) > 0;
-let pollingHotplug = false;
-let pollDevices = new Set<usb.Device>();
+// Hotplug support
+const hotplugSupported = usb._supportedHotplugEvents();
+
+// Devices delta support for non-libusb hotplug events
+// This methd needs to be used for attach/detach IDs (hotplugSupportType === 2) rather than a lookup because vid/pid are not unique
+let hotPlugDevices = new Set<usb.Device>();
+const emitHotplugEvents = () => {
+    // Collect current devices
+    const devices = new Set(usb.getDeviceList());
+
+    // Find attached devices
+    for (const device of devices) {
+        if (!hotPlugDevices.has(device)) {
+            usb.emit('attach', device);
+        }
+    }
+
+    // Find detached devices
+    for (const device of hotPlugDevices) {
+        if (!devices.has(device)) {
+            usb.emit('detach', device);
+        }
+    }
+
+    hotPlugDevices = devices;
+};
 
+// Polling mechanism for checking device changes where hotplug detection is not available
+let pollingHotplug = false;
 const pollHotplug = (start = false) => {
     if (start) {
         pollingHotplug = true;
     } else if (!pollingHotplug) {
         return;
+    } else {
+        emitHotplugEvents();
     }
 
-    // Collect current devices
-    const devices = new Set(usb.getDeviceList());
+    setTimeout(() => pollHotplug(), 500);
+};
 
-    if (!start) {
-        // Find attached devices
-        for (const device of devices) {
-            if (!pollDevices.has(device))
-                usb.emit('attach', device);
-        }
+// Hotplug control
+const startHotplug = () => {
+    if (hotplugSupported !== 1) {
+        // Collect initial devices when not using libusb
+        hotPlugDevices = new Set(usb.getDeviceList());
+    }
+
+    if (hotplugSupported) {
+        // Use hotplug event emitters
+        usb._enableHotplugEvents();
 
-        // Find detached devices
-        for (const device of pollDevices) {
-            if (!devices.has(device))
-                usb.emit('detach', device);
+        if (hotplugSupported === 2) {
+            // Use hotplug ID events to trigger a change check
+            usb.on('attachIds', emitHotplugEvents);
+            usb.on('detachIds', emitHotplugEvents);
         }
+    } else {
+        // Fallback to using polling to check for changes
+        pollHotplug(true);
     }
+};
+
+const stopHotplug = () => {
+    if (hotplugSupported) {
+        // Disable hotplug events
+        usb._disableHotplugEvents();
 
-    pollDevices = devices;
-    setTimeout(() => {
-        pollHotplug();
-    }, pollTimeout);
+        if (hotplugSupported === 2) {
+            // Remove hotplug ID event listeners
+            usb.off('attachIds', emitHotplugEvents);
+            usb.off('detachIds', emitHotplugEvents);
+        }
+    } else {
+        // Stop polling
+        pollingHotplug = false;
+    }
 };
 
 usb.on('newListener', event => {
@@ -83,11 +132,7 @@ usb.on('newListener', event => {
     }
     const listenerCount = usb.listenerCount('attach') + usb.listenerCount('detach');
     if (listenerCount === 0) {
-        if (hotplugSupported) {
-            usb._enableHotplugEvents();
-        } else {
-            pollHotplug(true);
-        }
+        startHotplug();
     }
 });
 
@@ -97,11 +142,7 @@ usb.on('removeListener', event => {
     }
     const listenerCount = usb.listenerCount('attach') + usb.listenerCount('detach');
     if (listenerCount === 0) {
-        if (hotplugSupported) {
-            usb._disableHotplugEvents();
-        } else {
-            pollingHotplug = false;
-        }
+        stopHotplug();
     }
 });