sportident.js 1.0.0

package/src/SiDevice/SiDevice.test.ts

@@ -0,0 +1,354 @@
+import { describe, expect, test } from '@jest/globals';
+import * as testUtils from '../testUtils';
+import type { ISiDeviceDriver } from './ISiDeviceDriver';
+import { DeviceClosedError, type ISiDeviceDriverData, SiDeviceState, SiDeviceStateChangeEvent } from './ISiDevice';
+import { SiDevice } from './SiDevice';
+
+testUtils.useFakeTimers();
+
+function mockDriver(driver: Partial<ISiDeviceDriver<ISiDeviceDriverData<unknown>>>) {
+	return driver as unknown as ISiDeviceDriver<ISiDeviceDriverData<unknown>>;
+}
+
+describe('SiDevice', () => {
+	test('state management', () => {
+		const siDevice = new SiDevice('stateManagement', {
+			driver: mockDriver({ name: 'FakeDriver' })
+		});
+		const stateChanges: SiDeviceState[] = [];
+		const onStateChange = (e: SiDeviceStateChangeEvent) => {
+			stateChanges.push(e.state);
+		};
+		siDevice.addEventListener('stateChange', onStateChange);
+		expect(stateChanges).toEqual([]);
+		expect(siDevice.state).toBe(SiDeviceState.Closed);
+		siDevice.setState(SiDeviceState.Closed);
+		expect(stateChanges).toEqual([]);
+		expect(siDevice.state).toBe(SiDeviceState.Closed);
+		siDevice.setState(SiDeviceState.Opening);
+		expect(stateChanges).toEqual([SiDeviceState.Opening]);
+		expect(siDevice.state).toBe(SiDeviceState.Opening);
+		siDevice.setState(SiDeviceState.Opened);
+		expect(stateChanges).toEqual([SiDeviceState.Opening, SiDeviceState.Opened]);
+		expect(siDevice.state).toBe(SiDeviceState.Opened);
+		siDevice.removeEventListener('stateChange', onStateChange);
+	});
+	test('fails opening while opening', (done) => {
+		const data = {
+			driver: mockDriver({})
+		};
+		const siDevice = new SiDevice('receiveLoopFail', data);
+
+		siDevice.setState(SiDeviceState.Opening);
+		siDevice.open().catch(() => done());
+	});
+	test('fails opening while closing', (done) => {
+		let count = 0;
+		const siDevice = new SiDevice('receiveLoopFail', {
+			driver: mockDriver({
+				receive: (_device: unknown) => {
+					if (count > 2) {
+						throw new DeviceClosedError('test');
+					}
+					count += 1;
+					throw new Error('test');
+				}
+			})
+		});
+
+		siDevice.setState(SiDeviceState.Closing);
+		siDevice.open().catch(() => done());
+	});
+	test('immediately opens when opened', (done) => {
+		let count = 0;
+		const data = {
+			driver: mockDriver({
+				receive: (_device: unknown) => {
+					if (count > 2) {
+						throw new DeviceClosedError('test');
+					}
+					count += 1;
+					throw new Error('test');
+				}
+			})
+		};
+		const siDevice = new SiDevice('receiveLoopFail', data);
+
+		siDevice.setState(SiDeviceState.Opened);
+		siDevice.open().then((openedDevice) => {
+			expect(openedDevice).toBe(siDevice);
+			done();
+		});
+	});
+	test('opens when closed', (done) => {
+		let opened = false;
+		const data = {
+			driver: mockDriver({
+				open: (_device: unknown) => {
+					opened = true;
+					return Promise.resolve();
+				}
+			})
+		};
+		const siDevice = new SiDevice('receiveLoopFail', data);
+
+		siDevice.setState(SiDeviceState.Closed);
+		siDevice.open().then((openedDevice) => {
+			expect(openedDevice).toBe(siDevice);
+			expect(opened).toBe(true);
+			done();
+		});
+	});
+	test('opening can fail', (done) => {
+		const data = {
+			driver: mockDriver({
+				open: (_device: unknown) => {
+					throw new Error('test');
+				}
+			})
+		};
+		const siDevice = new SiDevice('receiveLoopFail', data);
+
+		siDevice.setState(SiDeviceState.Closed);
+		siDevice.open().catch((err) => {
+			expect(err.message).toBe('test');
+			done();
+		});
+	});
+	test('opening can reject', (done) => {
+		const data = {
+			driver: mockDriver({
+				open: (_device: unknown) => Promise.reject(new Error('test'))
+			})
+		};
+		const siDevice = new SiDevice('receiveLoopFail', data);
+
+		siDevice.setState(SiDeviceState.Closed);
+		siDevice.open().catch((err) => {
+			expect(err.message).toBe('test');
+			done();
+		});
+	});
+	test('fails closing while opening', (done) => {
+		const data = {
+			driver: mockDriver({})
+		};
+		const siDevice = new SiDevice('receiveLoopFail', data);
+
+		siDevice.setState(SiDeviceState.Opening);
+		siDevice.close().catch(() => done());
+	});
+	test('fails closing while closing', (done) => {
+		const data = {
+			driver: mockDriver({})
+		};
+		const siDevice = new SiDevice('receiveLoopFail', data);
+
+		siDevice.setState(SiDeviceState.Closing);
+		siDevice.close().catch(() => done());
+	});
+	test('immediately closes when closed', (done) => {
+		const data = {
+			driver: mockDriver({})
+		};
+		const siDevice = new SiDevice('receiveLoopFail', data);
+
+		siDevice.setState(SiDeviceState.Closed);
+		siDevice.close().then((openedDevice) => {
+			expect(openedDevice).toBe(siDevice);
+			done();
+		});
+	});
+	test('closes when opened', (done) => {
+		let opened = true;
+		const data = {
+			driver: mockDriver({
+				close: (_device: unknown) => {
+					opened = false;
+					return Promise.resolve();
+				}
+			})
+		};
+		const siDevice = new SiDevice('receiveLoopFail', data);
+
+		siDevice.setState(SiDeviceState.Opened);
+		siDevice.close().then((openedDevice) => {
+			expect(openedDevice).toBe(siDevice);
+			expect(opened).toBe(false);
+			done();
+		});
+	});
+	test('closing can fail', (done) => {
+		const data = {
+			driver: mockDriver({
+				close: (_device: unknown) => {
+					throw new Error('test');
+				}
+			})
+		};
+		const siDevice = new SiDevice('receiveLoopFail', data);
+
+		siDevice.setState(SiDeviceState.Opened);
+		siDevice.close().catch((err) => {
+			expect(err.message).toBe('test');
+			done();
+		});
+	});
+	test('closing can reject', (done) => {
+		const data = {
+			driver: mockDriver({
+				close: (_device: unknown) => Promise.reject(new Error('test'))
+			})
+		};
+		const siDevice = new SiDevice('receiveLoopFail', data);
+
+		siDevice.setState(SiDeviceState.Opened);
+		siDevice.close().catch((err) => {
+			expect(err.message).toBe('test');
+			done();
+		});
+	});
+	test('receiveLoop succeed', async () => {
+		let count = 0;
+		const data = {
+			driver: mockDriver({
+				receive: (_device: unknown) =>
+					new Promise((resolve) => {
+						if (count > 2) {
+							throw new DeviceClosedError('test');
+						}
+						setTimeout(() => {
+							count += 1;
+							resolve([0x12]);
+						}, 1);
+					})
+			})
+		};
+		const siDevice = new SiDevice('receiveLoopSucceed', data);
+
+		const received: number[][] = [];
+		siDevice.addEventListener('receive', (e) => {
+			received.push(e.uint8Data);
+		});
+		siDevice.setState(SiDeviceState.Opened);
+		siDevice.receiveLoop();
+
+		await testUtils.nTimesAsync(1, () => testUtils.advanceTimersByTime(1));
+		expect(count).toBe(1);
+		expect(received).toEqual([[0x12]]);
+
+		await testUtils.nTimesAsync(1, () => testUtils.advanceTimersByTime(1));
+		expect(count).toBe(2);
+		expect(received).toEqual([[0x12], [0x12]]);
+	});
+	test('receiveLoop can fail', async () => {
+		let count = 0;
+		const data = {
+			driver: mockDriver({
+				receive: (_device: unknown) => {
+					if (count > 2) {
+						throw new DeviceClosedError('test');
+					}
+					count += 1;
+					throw new Error('test');
+				}
+			})
+		};
+		const siDevice = new SiDevice('receiveLoopFail', data);
+
+		const received: number[][] = [];
+		siDevice.addEventListener('receive', (e) => {
+			received.push(e.uint8Data);
+		});
+		siDevice.setState(SiDeviceState.Opened);
+		siDevice.receiveLoop();
+
+		await testUtils.nTimesAsync(1, () => testUtils.advanceTimersByTime(1));
+		expect(count).toBe(1);
+		expect(received).toEqual([]);
+
+		await testUtils.nTimesAsync(1, () => testUtils.advanceTimersByTime(100));
+		expect(count).toBe(2);
+		expect(received).toEqual([]);
+	});
+	test('receiveLoop can reject', async () => {
+		let count = 0;
+		const data = {
+			driver: mockDriver({
+				receive: (_device: unknown) => {
+					if (count > 2) {
+						throw new DeviceClosedError('test');
+					}
+					count += 1;
+					return Promise.reject(new Error('test'));
+				}
+			})
+		};
+		const siDevice = new SiDevice('receiveLoopReject', data);
+
+		const received: number[][] = [];
+		siDevice.addEventListener('receive', (e) => {
+			received.push(e.uint8Data);
+		});
+		siDevice.setState(SiDeviceState.Opened);
+		siDevice.receiveLoop();
+
+		await testUtils.nTimesAsync(1, () => testUtils.advanceTimersByTime(1));
+		expect(count).toBe(1);
+		expect(received).toEqual([]);
+
+		await testUtils.nTimesAsync(1, () => testUtils.advanceTimersByTime(100));
+		expect(count).toBe(2);
+		expect(received).toEqual([]);
+	});
+	test('receiveLoop can fail if device closed', async () => {
+		let count = 0;
+		const data = {
+			driver: mockDriver({
+				receive: (_device: unknown) => {
+					count += 1;
+					throw new DeviceClosedError('test');
+				}
+			})
+		};
+		const siDevice = new SiDevice('receiveLoopFailIfClosed', data);
+
+		const received: number[][] = [];
+		siDevice.addEventListener('receive', (e) => {
+			received.push(e.uint8Data);
+		});
+		siDevice.setState(SiDeviceState.Opened);
+		siDevice.receiveLoop();
+
+		await testUtils.nTimesAsync(1, () => testUtils.advanceTimersByTime(1));
+		expect(count).toBe(1);
+		expect(received).toEqual([]);
+
+		await testUtils.nTimesAsync(1, () => testUtils.advanceTimersByTime(100));
+		expect(count).toBe(1);
+		expect(received).toEqual([]);
+	});
+
+	test('can send', async () => {
+		const sent: number[][] = [];
+		const data = {
+			driver: mockDriver({
+				send: (_device: unknown, buffer: number[]) => {
+					sent.push(buffer);
+					return Promise.resolve();
+				}
+			})
+		};
+		const siDevice = new SiDevice('canSend', data);
+
+		siDevice.setState(SiDeviceState.Opened);
+		siDevice.send([0x34]);
+
+		await testUtils.nTimesAsync(1, () => testUtils.advanceTimersByTime(0));
+		expect(sent).toEqual([[0x34]]);
+		siDevice.send([0x56]);
+
+		await testUtils.nTimesAsync(1, () => testUtils.advanceTimersByTime(100));
+		expect(sent).toEqual([[0x34], [0x56]]);
+	});
+});

package/src/SiDevice/SiDevice.ts

@@ -0,0 +1,132 @@
+import { DeviceClosedError, type ISiDevice, type ISiDeviceDriverData, type SiDeviceEvents, SiDeviceReceiveEvent, SiDeviceState, SiDeviceStateChangeEvent } from './ISiDevice';
+import * as utils from '../utils';
+import type { ISiDeviceDriver } from './ISiDeviceDriver';
+
+export class SiDevice<T extends ISiDeviceDriverData<ISiDeviceDriver<T>>> implements ISiDevice<T> {
+	name: string;
+	ident: string;
+	data: T;
+	private internalState: SiDeviceState;
+
+	constructor(typeSpecificIdent: string, data: T) {
+		this.data = data;
+		this.name = `${data.driver.name}(${typeSpecificIdent})`;
+		this.ident = `${data.driver.name}-${typeSpecificIdent}`;
+		this.internalState = SiDeviceState.Closed;
+	}
+
+	get state(): SiDeviceState {
+		return this.internalState;
+	}
+
+	setState(newState: SiDeviceState): void {
+		if (newState !== this.internalState) {
+			this.internalState = newState;
+			this.dispatchEvent('stateChange', new SiDeviceStateChangeEvent(this, newState));
+		}
+	}
+
+	open(): Promise<SiDevice<T>> {
+		if (this.state === SiDeviceState.Closing) {
+			return Promise.reject(new Error(`Cannot open closing ${this.constructor.name}`));
+		}
+		if (this.state === SiDeviceState.Opening) {
+			return Promise.reject(new Error(`Cannot open opening ${this.constructor.name}`));
+		}
+		if (this.state === SiDeviceState.Opened) {
+			return Promise.resolve(this);
+		}
+		this.setState(SiDeviceState.Opening);
+		try {
+			return this.data.driver
+				.open(this)
+				.then(() => {
+					console.debug('Starting Receive Loop...');
+					this.receiveLoop();
+					this.setState(SiDeviceState.Opened);
+					return this;
+				})
+				.catch((err: Error) => {
+					this.setState(SiDeviceState.Closed);
+					throw err;
+				});
+		} catch (err) {
+			return Promise.reject(err);
+		}
+	}
+
+	close(): Promise<SiDevice<T>> {
+		if (this.state === SiDeviceState.Closing) {
+			return Promise.reject(new Error(`Cannot close closing ${this.constructor.name}`));
+		}
+		if (this.state === SiDeviceState.Opening) {
+			return Promise.reject(new Error(`Cannot close opening ${this.constructor.name}`));
+		}
+		if (this.state === SiDeviceState.Closed) {
+			return Promise.resolve(this);
+		}
+		this.setState(SiDeviceState.Closing);
+		try {
+			return this.data.driver
+				.close(this)
+				.then(() => {
+					this.setState(SiDeviceState.Closed);
+					return this;
+				})
+				.catch((err: Error) => {
+					this.setState(SiDeviceState.Closed);
+					throw err;
+				});
+		} catch (err) {
+			return Promise.reject(err);
+		}
+	}
+
+	receiveLoop(): void {
+		try {
+			// Stop receive loop when closing
+			if (this.internalState == SiDeviceState.Closing || this.internalState == SiDeviceState.Closed) {
+				return;
+			}
+			this.receive()
+				.then((uint8Data) => {
+					console.debug(`<= (${this.name})\n${utils.prettyHex(uint8Data, 16)}`);
+					this.dispatchEvent('receive', new SiDeviceReceiveEvent(this, uint8Data));
+				})
+				.catch((err: Error) => {
+					if (this.shouldStopReceivingBecauseOfError(err)) {
+						console.warn('Receive loop stopped while receiving');
+						throw err;
+					}
+					console.warn(`${this.name}: Error receiving: ${err.message}`);
+					return utils.waitFor(100);
+				})
+				.then(() => this.receiveLoop())
+				.catch(() => undefined);
+		} catch (exc: unknown) {
+			const err = utils.getErrorOrThrow(exc);
+			console.warn(`${this.name}: Error starting receiving: ${err.message}`);
+			if (this.shouldStopReceivingBecauseOfError(err)) {
+				console.warn('Receive loop stopped while starting receiving');
+				return;
+			}
+			utils.waitFor(100).then(() => this.receiveLoop());
+		}
+	}
+
+	shouldStopReceivingBecauseOfError(error: unknown): boolean {
+		return error instanceof DeviceClosedError || error instanceof utils.NotImplementedError;
+	}
+
+	receive(): Promise<number[]> {
+		return this.data.driver.receive(this);
+	}
+
+	send(buffer: number[]): Promise<unknown> {
+		console.debug(`=> (${this.name})\n${utils.prettyHex(buffer, 16)}`);
+		return this.data.driver.send(this, buffer);
+	}
+}
+// eslint-disable-next-line @typescript-eslint/no-empty-interface,@typescript-eslint/no-unused-vars
+export interface SiDevice<T extends ISiDeviceDriverData<ISiDeviceDriver<T>>> extends utils.EventTarget<SiDeviceEvents> {}
+utils.applyMixins(SiDevice, [utils.EventTarget]);

package/src/SiDevice/WebSerialSiDeviceDriver.ts

@@ -0,0 +1,146 @@
+import * as utils from '../utils';
+import type { ISiDevice, ISiDeviceDriverData } from '../SiDevice/ISiDevice';
+import type { ISiDeviceDriver, SiDeviceDriverWithAutodetectionEvents } from '../SiDevice/ISiDeviceDriver';
+import { SiDeviceRemoveEvent } from '../SiDevice/ISiDeviceDriver';
+import { SiDevice } from '../SiDevice/SiDevice';
+import type * as nav from './INavigatorWebSerial';
+
+const siDeviceFilters = [{ usbVendorId: 0x10c4, usbProductId: 0x800a }];
+const matchesSiDeviceFilters = (usbVendorId: number, usbProductId: number) => siDeviceFilters.some((filter) => usbVendorId === filter.usbVendorId && usbProductId === filter.usbProductId);
+
+const getIdent = (device: nav.WebSerialDevice) => `${device.getInfo().usbProductId}`;
+
+export interface WebSerialSiDeviceDriverData extends ISiDeviceDriverData<WebSerialSiDeviceDriver> {
+	driver: WebSerialSiDeviceDriver;
+	device: nav.WebSerialDevice;
+}
+
+export type IWebSerialSiDevice = ISiDevice<WebSerialSiDeviceDriverData>;
+export type WebSerialSiDevice = SiDevice<WebSerialSiDeviceDriverData>;
+
+class WebSerialSiDeviceDriver implements ISiDeviceDriver<WebSerialSiDeviceDriverData> {
+	public name = 'WebSerial';
+
+	private siDeviceByIdent: { [ident: string]: WebSerialSiDevice } = {};
+
+	private autodetectedSiDevices: { [ident: string]: WebSerialSiDevice } = {};
+
+	private reader: ReadableStreamDefaultReader<any> | undefined;
+
+	constructor(private navigatorSerial: nav.Serial) {}
+
+	detect(): Promise<WebSerialSiDevice> {
+		return this.navigatorSerial
+			.requestPort({
+				filters: siDeviceFilters
+			})
+			.catch((e) => {
+				return Promise.reject(new Error('Failed to get access to Serial device!' + e.toString()));
+			})
+			.then((navigatorWebSerialDevice: nav.WebSerialDevice) => {
+				if (!matchesSiDeviceFilters(navigatorWebSerialDevice.getInfo().usbVendorId || 0, navigatorWebSerialDevice.getInfo().usbProductId || 0)) {
+					return Promise.reject(new Error('Not a SI device'));
+				}
+				const ident = getIdent(navigatorWebSerialDevice);
+				if (this.autodetectedSiDevices[ident] !== undefined) {
+					return Promise.reject(new Error('Duplicate SI device'));
+				}
+				const siDevice = this.getSiDevice(navigatorWebSerialDevice);
+				this.autodetectedSiDevices[ident] = siDevice;
+				return siDevice.open();
+			});
+	}
+
+	getSiDevice(navigatorWebSerialDevice: nav.WebSerialDevice): WebSerialSiDevice {
+		const ident = getIdent(navigatorWebSerialDevice);
+		if (this.siDeviceByIdent[ident] !== undefined) {
+			return this.siDeviceByIdent[ident];
+		}
+		const newSiDeviceData: WebSerialSiDeviceDriverData = {
+			driver: this,
+			device: navigatorWebSerialDevice
+		};
+		const newSiDevice = new SiDevice(ident, newSiDeviceData);
+		this.siDeviceByIdent[ident] = newSiDevice;
+		return newSiDevice;
+	}
+
+	forgetSiDevice(siDevice: IWebSerialSiDevice) {
+		const navigatorWebSerialDevice = siDevice.data.device;
+		const ident = getIdent(navigatorWebSerialDevice);
+		delete this.siDeviceByIdent[ident];
+		if (this.autodetectedSiDevices[ident] !== undefined) {
+			this.dispatchEvent('remove', new SiDeviceRemoveEvent(siDevice));
+		}
+		delete this.autodetectedSiDevices[ident];
+	}
+
+	open(device: IWebSerialSiDevice): Promise<void> {
+		console.debug('Opening...');
+		const navigatorDevice = device.data.device;
+		return navigatorDevice.open({ baudRate: 38400 })
+		.catch((e) => {
+			return Promise.reject(new Error("Failed to open serial device"))
+		});
+	}
+
+	async close(device: IWebSerialSiDevice): Promise<void> {
+		console.debug('Disabling Serial...');
+		const navigatorDevice = device.data.device;
+		try {
+			if (this.reader != undefined) {
+				this.reader.releaseLock();
+			}
+		} catch (e) {
+			console.warn(e);
+		}
+		this.forgetSiDevice(device);
+		await navigatorDevice.readable.cancel();
+		await navigatorDevice.close();
+	}
+
+	async receive(device: IWebSerialSiDevice): Promise<number[]> {
+		const navigatorDevice = device.data.device;
+		this.reader = navigatorDevice.readable.getReader();
+		try {
+			while (true) {
+				const { value, done } = await this.reader.read();
+				if (done) {
+					if (value == undefined) {
+						return [];
+					}
+					return value;
+				}
+				if (value != undefined) {
+					return value;
+				}
+			}
+		} catch (error) {
+			console.warn(error);
+		} finally {
+			this.reader.releaseLock();
+		}
+		return [];
+	}
+
+	async send(device: IWebSerialSiDevice, uint8Data: number[]): Promise<void> {
+		const navigatorDevice = device.data.device;
+		const buffer = new Uint8Array(uint8Data);
+		if (navigatorDevice.writable == null) {
+			console.error('SiStation is not writable!');
+			return;
+		}
+		const writer = navigatorDevice.writable.getWriter();
+		await writer
+			.write(buffer)
+			.then(() => {
+				return writer.releaseLock();
+			})
+			.then(() => true);
+	}
+}
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+interface WebSerialSiDeviceDriver extends utils.EventTarget<SiDeviceDriverWithAutodetectionEvents<WebSerialSiDeviceDriverData>> {}
+utils.applyMixins(WebSerialSiDeviceDriver, [utils.EventTarget]);
+
+export const getWebSerialSiDeviceDriver = (navigatorWebSerial: Serial): WebSerialSiDeviceDriver => new WebSerialSiDeviceDriver(<nav.Serial>(<unknown>navigatorWebSerial));