usb 2.4.3 → 2.5.0

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/index.ts

@@ -26,6 +26,8 @@ declare module './bindings' {
     interface DeviceEvents extends EventListeners<DeviceEvents> {
         attach: Device;
         detach: Device;
+        attachIds: undefined;
+        detachIds: undefined;
     }
 
     function addListener<K extends keyof DeviceEvents>(event: K, listener: (arg: DeviceEvents[K]) => void): void;
@@ -40,20 +42,13 @@ 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
+// Polling mechanism for discovering device changes where hotplug detection is not available
 const pollTimeout = 500;
-const hotplugSupported = usb._getLibusbCapability(usb.LIBUSB_CAP_HAS_HOTPLUG) > 0;
+const hotplugSupported = usb._supportedHotplugEvents();
 let pollingHotplug = false;
 let pollDevices = new Set<usb.Device>();
 
-const pollHotplug = (start = false) => {
-    if (start) {
-        pollingHotplug = true;
-    } else if (!pollingHotplug) {
-        return;
-    }
-
+const pollHotplugOnce = (start: boolean) => {
     // Collect current devices
     const devices = new Set(usb.getDeviceList());
 
@@ -72,11 +67,34 @@ const pollHotplug = (start = false) => {
     }
 
     pollDevices = devices;
+};
+
+const pollHotplugLoop = (start = false) => {
+    if (start) {
+        pollingHotplug = true;
+    } else if (!pollingHotplug) {
+        return;
+    }
+
+    pollHotplugOnce(start);
+
     setTimeout(() => {
-        pollHotplug();
+        pollHotplugLoop();
     }, pollTimeout);
 };
 
+const hotplugModeIsIdsOnly = hotplugSupported === 2;
+if (hotplugModeIsIdsOnly) {
+    // The hotplug backend doesnt emit 'attach' or 'detach', so we need to do some conversion
+    const hotplugEventConversion = () => {
+        // Future: This might want a debounce, to avoid doing multiple polls when attaching a usb hub or something
+        pollHotplugOnce(false);
+    };
+
+    usb.on('attachIds', hotplugEventConversion);
+    usb.on('detachIds', hotplugEventConversion);
+}
+
 usb.on('newListener', event => {
     if (event !== 'attach' && event !== 'detach') {
         return;
@@ -86,7 +104,7 @@ usb.on('newListener', event => {
         if (hotplugSupported) {
             usb._enableHotplugEvents();
         } else {
-            pollHotplug(true);
+            pollHotplugLoop(true);
         }
     }
 });