usb 2.0.0-alpha.1 → 2.0.3

package/tsc/webusb/index.ts

@@ -1,54 +1,148 @@
 import * as usb from '../usb';
+import { EventEmitter } from 'events';
 import { WebUSBDevice } from './webusb-device';
-import { TypedEventTarget } from './typed-event-target';
 
 /**
  * USB Options
  */
 export interface USBOptions {
     /**
-     * A `device found` callback function to allow the user to select a device
+     * Optional `device found` callback function to allow the user to select a device
      */
-    devicesFound?: (devices: Array<USBDevice>) => Promise<USBDevice | void>;
-}
+    devicesFound?: (devices: USBDevice[]) => Promise<USBDevice | void>;
 
-/**
- * @hidden
- */
-interface Device {
-    vendorId?: number;
-    productId?: number;
-    serialNumber?: string;
-}
+    /**
+     * Optional array of preconfigured allowed devices
+     */
+    allowedDevices?: USBDeviceFilter[];
 
-/**
- * @hidden
- */
-export type USBEvents = {
     /**
-     * USBDevice connected event
+     * Optional flag to automatically allow all devices
      */
-    connect: USBConnectionEvent;
+    allowAllDevices?: boolean;
+
     /**
-     * USBDevice disconnected event
+     * Optional timeout (in milliseconds) to use for the device control transfers
      */
-    disconnect: USBConnectionEvent;
-};
+    deviceTimeout?: number;
+}
 
-export class WebUSB extends TypedEventTarget<USBEvents> implements USB {
+export class WebUSB implements USB {
 
-    private allowedDevices: Array<Device> = [];
+    protected emitter = new EventEmitter();
+    protected knownDevices: Map<string, USBDevice> = new Map();
+    protected allowedDevices: USBDeviceFilter[];
 
     constructor(private options: USBOptions = {}) {
-        super();
+        this.allowedDevices = options.allowedDevices || [];
+
+        const deviceConnectCallback = async (device: usb.Device) => {
+            const webDevice = await WebUSBDevice.createInstance(device);
+
+            // When connected, emit an event if it is an allowed device
+            if (webDevice && this.isAllowedDevice(webDevice)) {
+                const deviceId = this.getDeviceId(device);
+                if (deviceId) {
+                    this.knownDevices.set(deviceId, webDevice);
+                }
+
+                const event = {
+                    type: 'connect',
+                    device: webDevice
+                };
+
+                this.emitter.emit('connect', event);
+            }
+        };
+
+        const deviceDisconnectCallback = async (device: usb.Device) => {
+            const deviceId = this.getDeviceId(device);
+
+            // When disconnected, emit an event if the device was a known allowed device
+            if (deviceId !== undefined && this.knownDevices.has(deviceId)) {
+                const webDevice = this.knownDevices.get(deviceId);
+
+                if (webDevice && this.isAllowedDevice(webDevice)) {
+                    const event = {
+                        type: 'disconnect',
+                        device: webDevice
+                    };
+
+                    this.emitter.emit('disconnect', event);
+                }
+            }
+        };
+
+        this.emitter.on('newListener', event => {
+            const listenerCount = this.emitter.listenerCount(event);
+
+            if (listenerCount !== 0) {
+                return;
+            }
+
+            if (event === 'connect') {
+                usb.addListener('attach', deviceConnectCallback);
+            } else if (event === 'disconnect') {
+                usb.addListener('detach', deviceDisconnectCallback);
+            }
+        });
+
+        this.emitter.on('removeListener', event => {
+            const listenerCount = this.emitter.listenerCount(event);
+
+            if (listenerCount !== 0) {
+                return;
+            }
+
+            if (event === 'connect') {
+                usb.removeListener('attach', deviceConnectCallback);
+            } else if (event === 'disconnect') {
+                usb.removeListener('detach', deviceDisconnectCallback);
+            }
+        });
+    }
+
+    private _onconnect: ((ev: USBConnectionEvent) => void) | undefined;
+    public set onconnect(fn: (ev: USBConnectionEvent) => void) {
+        if (this._onconnect) {
+            this.removeEventListener('connect', this._onconnect);
+            this._onconnect = undefined;
+        }
+
+        if (fn) {
+            this._onconnect = fn;
+            this.addEventListener('connect', this._onconnect);
+        }
+    }
+
+    private _ondisconnect: ((ev: USBConnectionEvent) => void) | undefined;
+    public set ondisconnect(fn: (ev: USBConnectionEvent) => void) {
+        if (this._ondisconnect) {
+            this.removeEventListener('disconnect', this._ondisconnect);
+            this._ondisconnect = undefined;
+        }
+
+        if (fn) {
+            this._ondisconnect = fn;
+            this.addEventListener('disconnect', this._ondisconnect);
+        }
+    }
+
+    public addEventListener(type: 'connect' | 'disconnect', listener: (this: this, ev: USBConnectionEvent) => void): void;
+    public addEventListener(type: 'connect' | 'disconnect', listener: EventListener): void;
+    public addEventListener(type: string, listener: (ev: USBConnectionEvent) => void): void {
+        this.emitter.addListener(type, listener);
     }
 
-    public set onconnect(listener: (event: USBConnectionEvent) => void) {
-        this.addEventListener('connect', listener);
+    public removeEventListener(type: 'connect' | 'disconnect', callback: (this: this, ev: USBConnectionEvent) => void): void;
+    public removeEventListener(type: 'connect' | 'disconnect', callback: EventListener): void;
+    public removeEventListener(type: string, callback: (this: this, ev: USBConnectionEvent) => void): void {
+        this.emitter.removeListener(type, callback);
     }
 
-    public set ondisconnect(listener: (event: USBConnectionEvent) => void) {
-        this.addEventListener('disconnect', listener);
+    public dispatchEvent(_event: Event): boolean {
+        // Don't dispatch from here
+        return false;
     }
 
     /**
@@ -105,7 +199,7 @@ export class WebUSB extends TypedEventTarget<USBEvents> implements USB {
                 throw new Error('selected device not found');
             }
 
-            if (!this.replaceAllowedDevice(device)) {
+            if (!this.isAllowedDevice(device)) {
                 this.allowedDevices.push({
                     vendorId: device.vendorId,
                     productId: device.productId,
@@ -114,7 +208,7 @@ export class WebUSB extends TypedEventTarget<USBEvents> implements USB {
             }
 
             return device;
-        } catch(error) {
+        } catch (error) {
             throw new Error(`requestDevice error: ${error}`);
         }
     }
@@ -124,47 +218,54 @@ export class WebUSB extends TypedEventTarget<USBEvents> implements USB {
      * @returns Promise containing an array of devices
      */
     public async getDevices(): Promise<USBDevice[]> {
-        // Create pre-filters
-        const preFilters = this.allowedDevices.map(device => ({
-            vendorId: device.vendorId || undefined,
-            productId: device.productId || undefined,
-            serialNumber: device.serialNumber || undefined
-        }));
+        let preFilters: USBDeviceFilter[] | undefined;
+
+        if (!this.options.allowAllDevices) {
+            // Create pre-filters
+            preFilters = this.allowedDevices.map(device => ({
+                vendorId: device.vendorId || undefined,
+                productId: device.productId || undefined,
+                serialNumber: device.serialNumber || undefined
+            }));
+        }
 
         // Refresh devices and filter for allowed ones
-        let devices = await this.loadDevices(preFilters);
-        devices = devices.filter(device => {
-            for (const i in this.allowedDevices) {
-                if (this.isSameDevice(device, this.allowedDevices[i])) {
-                    return true;
-                }
-            }
-
-            return false;
-        });
-
-        return devices;
+        const devices = await this.loadDevices(preFilters);
+        return devices.filter(device => this.isAllowedDevice(device));
     }
 
-    private async loadDevices(preFilters?: Array<Device>): Promise<USBDevice[]> {
+    private async loadDevices(preFilters?: USBDeviceFilter[]): Promise<USBDevice[]> {
         let devices = usb.getDeviceList();
 
-        if (preFilters) {
-            // Pre-filter devices
-            devices = this.preFilterDevices(devices, preFilters);
-        }
+        // Pre-filter devices
+        devices = this.preFilterDevices(devices, preFilters);
 
         const webDevices: USBDevice[] = [];
 
         for (const device of devices) {
+            if (this.options.deviceTimeout) {
+                device.timeout = this.options.deviceTimeout;
+            }
+
             const webDevice = await WebUSBDevice.createInstance(device);
-            webDevices.push(webDevice);
+            if (webDevice) {
+                webDevices.push(webDevice);
+
+                const deviceId = this.getDeviceId(device);
+                if (deviceId) {
+                    this.knownDevices.set(deviceId, webDevice);
+                }
+            }
         }
 
         return webDevices;
     }
 
-    private preFilterDevices(devices: Array<usb.Device>, preFilters: Array<Device>): Array<usb.Device> {
+    private preFilterDevices(devices: usb.Device[], preFilters?: USBDeviceFilter[]): usb.Device[] {
+        if (!preFilters || !preFilters.length) {
+            return devices;
+        }
+
         // Just pre-filter on vid/pid
         return devices.filter(device => preFilters.some(filter => {
             // Vendor
@@ -178,28 +279,11 @@ export class WebUSB extends TypedEventTarget<USBEvents> implements USB {
         }));
     }
 
-    private isSameDevice(device1: Device, device2: Device): boolean {
-        return (device1.productId === device2.productId
-             && device1.vendorId === device2.vendorId
-             && device1.serialNumber === device2.serialNumber);
-    }
-
-    private replaceAllowedDevice(device: USBDevice): boolean {
-        for (const i in this.allowedDevices) {
-            if (this.isSameDevice(device, this.allowedDevices[i])) {
-                this.allowedDevices[i] = {
-                    vendorId: device.vendorId,
-                    productId: device.productId,
-                    serialNumber: device.serialNumber
-                };
-                return true;
-            }
+    private filterDevice(options: USBDeviceRequestOptions, device: USBDevice): boolean {
+        if (!options.filters || !options.filters.length) {
+            return true;
         }
 
-        return false;
-    }
-
-    private filterDevice(options: USBDeviceRequestOptions, device: USBDevice): boolean {
         return options.filters.some(filter => {
             // Vendor
             if (filter.vendorId && filter.vendorId !== device.vendorId) return false;
@@ -248,4 +332,32 @@ export class WebUSB extends TypedEventTarget<USBEvents> implements USB {
             return true;
         });
     }
+
+    private getDeviceId(device: usb.Device): string | undefined {
+        if (device.busNumber === undefined || device.deviceAddress === undefined) {
+            return undefined;
+        }
+
+        return `${device.busNumber}.${device.deviceAddress}`;
+    }
+
+    private isAllowedDevice(device: USBDeviceFilter): boolean {
+        if (this.options.allowAllDevices) {
+            return true;
+        }
+
+        const isSameDevice = (device1: USBDeviceFilter, device2: USBDeviceFilter): boolean => {
+            return (device1.productId === device2.productId
+                && device1.vendorId === device2.vendorId
+                && device1.serialNumber === device2.serialNumber);
+        };
+
+        for (const i in this.allowedDevices) {
+            if (isSameDevice(device, this.allowedDevices[i])) {
+                return true;
+            }
+        }
+
+        return false;
+    }
 }

package/tsc/webusb/webusb-device.ts

@@ -12,10 +12,14 @@ const ENDPOINT_HALT = 0x00;
  * Wrapper to make a node-usb device look like a webusb device
  */
 export class WebUSBDevice implements USBDevice {
-    public static async createInstance(device: usb.Device): Promise<WebUSBDevice> {
-        const instance = new WebUSBDevice(device);
-        await instance.initialize();
-        return instance;
+    public static async createInstance(device: usb.Device): Promise<WebUSBDevice | undefined> {
+        try {
+            const instance = new WebUSBDevice(device);
+            await instance.initialize();
+            return instance;
+        } catch {
+            return undefined;
+        }
     }
 
     public readonly usbVersionMajor: number;
@@ -98,9 +102,9 @@ export class WebUSBDevice implements USBDevice {
                         // Re-create the USBInterface to set the claimed attribute
                         this.configuration.interfaces[this.configuration.interfaces.indexOf(iface)] = {
                             interfaceNumber: iface.interfaceNumber,
-                            alternate : iface.alternate,
-                            alternates : iface.alternates,
-                            claimed : false
+                            alternate: iface.alternate,
+                            alternates: iface.alternates,
+                            claimed: false
                         };
                     }
                 }
@@ -128,7 +132,7 @@ export class WebUSBDevice implements USBDevice {
                 return;
             }
 
-            const config =  this.configurations.find(configuration => configuration.configurationValue === configurationValue);
+            const config = this.configurations.find(configuration => configuration.configurationValue === configurationValue);
             if (!config) {
                 throw new Error('selectConfiguration error: configuration not found');
             }
@@ -171,9 +175,9 @@ export class WebUSBDevice implements USBDevice {
                 // Re-create the USBInterface to set the claimed attribute
                 this.configuration.interfaces[this.configuration.interfaces.indexOf(iface)] = {
                     interfaceNumber,
-                    alternate : iface.alternate,
-                    alternates : iface.alternates,
-                    claimed : true
+                    alternate: iface.alternate,
+                    alternates: iface.alternates,
+                    claimed: true
                 };
             } catch (error) {
                 throw new Error(`claimInterface error: ${error}`);
@@ -194,9 +198,9 @@ export class WebUSBDevice implements USBDevice {
                     // Re-create the USBInterface to set the claimed attribute
                     this.configuration.interfaces[this.configuration.interfaces.indexOf(iface)] = {
                         interfaceNumber,
-                        alternate : iface.alternate,
-                        alternates : iface.alternates,
-                        claimed : false
+                        alternate: iface.alternate,
+                        alternates: iface.alternates,
+                        claimed: false
                     };
                 }
             }
@@ -275,7 +279,7 @@ export class WebUSBDevice implements USBDevice {
             const type = this.controlTransferParamsToType(setup, usb.LIBUSB_ENDPOINT_OUT);
             const controlTransfer = promisify(this.device.controlTransfer).bind(this.device);
             const buffer = data ? Buffer.from(data) : Buffer.alloc(0);
-            const bytesWritten = <number> await controlTransfer(type, setup.request, setup.value, setup.index, buffer);
+            const bytesWritten = <number>await controlTransfer(type, setup.request, setup.value, setup.index, buffer);
 
             return {
                 bytesWritten,
@@ -387,13 +391,20 @@ export class WebUSBDevice implements USBDevice {
     private async initialize(): Promise<void> {
         try {
             await this.deviceMutex.lock();
-            this.device.open();
+
+            if (!this.opened) {
+                this.device.open();
+            }
+
             this.manufacturerName = await this.getStringDescriptor(this.device.deviceDescriptor.iManufacturer);
             this.productName = await this.getStringDescriptor(this.device.deviceDescriptor.iProduct);
             this.serialNumber = await this.getStringDescriptor(this.device.deviceDescriptor.iSerialNumber);
             this.configurations = await this.getConfigurations();
         } finally {
-            this.device.close();
+            if (this.opened) {
+                this.device.close();
+            }
+
             this.deviceMutex.unlock();
         }
     }

package/.github/workflows/prebuild.yml

@@ -1,48 +0,0 @@
-name: prebuild
-
-on:
-  push:
-    branches:
-      - master
-    tags:
-      - '*'
-  pull_request:
-    branches:
-      - master
-  workflow_dispatch:
-
-jobs:
-  prebuild:
-    strategy:
-      matrix:
-        config:
-          - { os: macos-latest, arch: x64 }
-          - { os: ubuntu-18.04, arch: x64 }
-          - { os: windows-latest, arch: x64 }
-          - { os: windows-latest, arch: ia32 }
-    runs-on: ${{ matrix.config.os }}
-    steps:
-      - if: matrix.config.os == 'ubuntu-18.04'
-        run: |
-          sudo apt-get update
-          sudo apt-get install libudev-dev
-      - uses: actions/setup-node@v2
-        with:
-          node-version: 14.x
-      - uses: actions/checkout@v2
-        with:
-          submodules: recursive
-      - run: yarn
-      - run: yarn run prebuild -- -a ${{ matrix.config.arch }}
-      - if: startsWith(github.ref, 'refs/tags/')
-        shell: bash
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        run: |
-          assets=()
-          for asset in ./prebuilds/*; do
-            assets+=("-a" "$asset")
-          done
-          tag_name="${GITHUB_REF##*/}"
-          hub release create -m "$tag_name" "$tag_name" || true
-          hub release edit "${assets[@]}" -m "" "$tag_name"