@neurodevs/ndx-native 7.0.1 → 7.1.1

package/src/impl/LibndxAdapter.ts

@@ -13,6 +13,7 @@ export default class LibndxAdapter implements Libndx {
     private static onDiscoveredProto?: ReturnType<typeof koffi.proto>
     private static onConnectedProto?: ReturnType<typeof koffi.proto>
     private static onRssiProto?: ReturnType<typeof koffi.proto>
+    private static onUsbDataProto?: ReturnType<typeof koffi.proto>
 
     private static instance?: Libndx
 
@@ -49,6 +50,7 @@ export default class LibndxAdapter implements Libndx {
         delete this.onDiscoveredProto
         delete this.onConnectedProto
         delete this.onRssiProto
+        delete this.onUsbDataProto
     }
 
     private tryToLoadBindings() {
@@ -64,11 +66,17 @@ export default class LibndxAdapter implements Libndx {
         LibndxAdapter.getOnDiscoveredProto()
         LibndxAdapter.getOnConnectedProto()
         LibndxAdapter.getOnRssiProto()
+        LibndxAdapter.getOnUsbDataProto()
+
         const lib = LibndxAdapter.koffiLoad(this.libndxPath)
 
         const wrap1 = (f: (a: string) => string) => (args: [string]) =>
             f(args[0])
 
+        const wrap2 =
+            (f: (a: string, b: string) => string) => (args: [string, string]) =>
+                f(args[0], args[1])
+
         const wrap3 =
             (f: (a: string, b: string, c: string) => string) =>
             (args: [string, string, string]) =>
@@ -79,6 +87,11 @@ export default class LibndxAdapter implements Libndx {
             (args: [string, unknown, unknown, number]) =>
                 f(args[0], args[1], args[2], args[3])
 
+        const wrapAddBleCharCallbacks =
+            (f: (a: string, b: unknown, c: number) => string) =>
+            (args: [string, unknown, number]) =>
+                f(args[0], args[1], args[2])
+
         const wrapSetBleRssiInterval =
             (f: (a: string, b: number, c: unknown) => string) =>
             (args: [string, number, unknown]) =>
@@ -89,6 +102,11 @@ export default class LibndxAdapter implements Libndx {
             (args: [string, unknown]) =>
                 f(args[0], args[1])
 
+        const wrapStartUsb =
+            (f: (a: string, b: unknown) => string) =>
+            (args: [string, unknown]) =>
+                f(args[0], args[1])
+
         this.bindings = {
             discover_ble_uuid: wrapDiscoverBleUuid(
                 lib.func(
@@ -103,6 +121,11 @@ export default class LibndxAdapter implements Libndx {
                     'str start_ble_backend(str uuid, OnConnectedFn *on_connected, CharCallback *callbacks, int num_callbacks)'
                 )
             ),
+            add_ble_char_callbacks: wrapAddBleCharCallbacks(
+                lib.func(
+                    'str add_ble_char_callbacks(str uuid, CharCallback *callbacks, int num_callbacks)'
+                )
+            ),
             write_ble_characteristic: wrap3(
                 lib.func(
                     'str write_ble_characteristic(str uuid, str charUuid, str value)'
@@ -114,14 +137,19 @@ export default class LibndxAdapter implements Libndx {
                 )
             ),
             stop_ble_backend: wrap1(lib.func('str stop_ble_backend(str uuid)')),
-            create_ftdi_backend: wrap1(
-                lib.func('str create_ftdi_backend(str config)')
+            create_usb_backend: wrap1(
+                lib.func('str create_usb_backend(str config)')
+            ),
+            start_usb_backend: wrapStartUsb(
+                lib.func(
+                    'str start_usb_backend(str serial, OnUsbDataFn *on_data)'
+                )
             ),
-            start_ftdi_backend: wrap1(
-                lib.func('str start_ftdi_backend(str serial)')
+            write_usb_backend: wrap2(
+                lib.func('str write_usb_backend(str serial, str value)')
             ),
-            stop_ftdi_backend: wrap1(
-                lib.func('str stop_ftdi_backend(str serial)')
+            stop_usb_backend: wrap1(
+                lib.func('str stop_usb_backend(str serial)')
             ),
         }
     }
@@ -204,6 +232,33 @@ export default class LibndxAdapter implements Libndx {
         )
     }
 
+    public addBleCharCallbacks(options: AddBleCharCallbacksOptions) {
+        const { deviceUuid, charCallbacks } = options
+
+        const registered = charCallbacks.map(
+            ({ charUuid, charName, onData }) => ({
+                charUuid,
+                charName,
+                onData: LibndxAdapter.koffiRegister(
+                    onData,
+                    LibndxAdapter.koffiPointer(
+                        LibndxAdapter.getCharCallbackProto()!
+                    )
+                ),
+            })
+        )
+
+        this.registeredCallbacks.push(...registered)
+
+        return JSON.parse(
+            this.bindings.add_ble_char_callbacks([
+                deviceUuid,
+                registered,
+                registered.length,
+            ])
+        )
+    }
+
     public writeBleCharacteristic(options: WriteBleCharacteristicOptions) {
         const { deviceUuid, charUuid: characteristicUuid, value } = options
 
@@ -238,21 +293,37 @@ export default class LibndxAdapter implements Libndx {
         return JSON.parse(this.bindings.stop_ble_backend([deviceUuid]))
     }
 
-    public createFtdiBackend(options: FtdiBackendOptions) {
+    public createUsbBackend(options: UsbBackendOptions) {
         const { serialNumber } = options
         const configJson = JSON.stringify({ serial_number: serialNumber })
 
-        return JSON.parse(this.bindings.create_ftdi_backend([configJson]))
+        return JSON.parse(this.bindings.create_usb_backend([configJson]))
     }
 
-    public startFtdiBackend(options: FtdiBackendOptions) {
-        const { serialNumber } = options
-        return JSON.parse(this.bindings.start_ftdi_backend([serialNumber]))
+    public startUsbBackend(options: UsbBackendOptions) {
+        const { serialNumber, onData } = options
+
+        const registeredOnData = LibndxAdapter.koffiRegister(
+            onData ?? (() => {}),
+            LibndxAdapter.koffiPointer(LibndxAdapter.getOnUsbDataProto()!)
+        )
+
+        return JSON.parse(
+            this.bindings.start_usb_backend([serialNumber, registeredOnData])
+        )
+    }
+
+    public writeUsbBackend(options: WriteUsbBackendOptions) {
+        const { serialNumber, value } = options
+
+        return JSON.parse(
+            this.bindings.write_usb_backend([serialNumber, value])
+        )
     }
 
-    public stopFtdiBackend(options: FtdiBackendOptions) {
+    public stopUsbBackend(options: UsbBackendOptions) {
         const { serialNumber } = options
-        return JSON.parse(this.bindings.stop_ftdi_backend([serialNumber]))
+        return JSON.parse(this.bindings.stop_usb_backend([serialNumber]))
     }
 
     private static getCharCallbackProto() {
@@ -282,6 +353,15 @@ export default class LibndxAdapter implements Libndx {
         return this.onRssiProto
     }
 
+    private static getOnUsbDataProto() {
+        if (!this.onUsbDataProto) {
+            this.onUsbDataProto = LibndxAdapter.koffiProto(
+                'void OnUsbDataFn(uint8 *data, int length, double timestamp_sec)'
+            )
+        }
+        return this.onUsbDataProto
+    }
+
     private static getOnDiscoveredProto() {
         if (!this.onDiscoveredProto) {
             this.onDiscoveredProto = LibndxAdapter.koffiProto(
@@ -311,12 +391,14 @@ export interface Libndx {
     discoverBleUuid(options: DiscoverBleUuidOptions): NativeResult
     createBleBackend(options: BleBackendOptions): NativeResult
     startBleBackend(options: StartBleBackendOptions): NativeResult
+    addBleCharCallbacks(options: AddBleCharCallbacksOptions): NativeResult
     writeBleCharacteristic(options: WriteBleCharacteristicOptions): NativeResult
     setBleRssiInterval(options: BleRssiOptions): NativeResult
     stopBleBackend(options: BleBackendOptions): NativeResult
-    createFtdiBackend(options: FtdiBackendOptions): NativeResult
-    startFtdiBackend(options: FtdiBackendOptions): NativeResult
-    stopFtdiBackend(options: FtdiBackendOptions): NativeResult
+    createUsbBackend(options: UsbBackendOptions): NativeResult
+    startUsbBackend(options: UsbBackendOptions): NativeResult
+    writeUsbBackend(options: WriteUsbBackendOptions): NativeResult
+    stopUsbBackend(options: UsbBackendOptions): NativeResult
 }
 
 export type LibndxConstructor = new (options?: LibndxAdapterOptions) => Libndx
@@ -339,6 +421,10 @@ export interface StartBleBackendOptions extends BleBackendOptions {
     charCallbacks: CharacteristicCallback[]
 }
 
+export interface AddBleCharCallbacksOptions extends BleBackendOptions {
+    charCallbacks: CharacteristicCallback[]
+}
+
 export interface BleRssiOptions extends BleBackendOptions {
     intervalMs: number
     onRssi: (rssi: number) => void
@@ -356,20 +442,27 @@ export interface CharacteristicCallback {
     onData: (data: Buffer, length: number, timestampSec: number) => void
 }
 
-export interface FtdiBackendOptions {
+export interface UsbBackendOptions {
     serialNumber: string
+    onData?: (data: Buffer, length: number, timestampSec: number) => void
+}
+
+export interface WriteUsbBackendOptions extends UsbBackendOptions {
+    value: string
 }
 
 export interface LibndxBindings {
     discover_ble_uuid(args: [string, unknown]): string
     create_ble_backend(args: [string]): string
     start_ble_backend(args: [string, unknown, unknown, number]): string
+    add_ble_char_callbacks(args: [string, unknown, number]): string
     write_ble_characteristic(args: [string, string, string]): string
     set_ble_rssi_interval(args: [string, number, unknown]): string
     stop_ble_backend(args: [string]): string
-    create_ftdi_backend(args: [string]): string
-    start_ftdi_backend(args: [string]): string
-    stop_ftdi_backend(args: [string]): string
+    create_usb_backend(args: [string]): string
+    start_usb_backend(args: [string, unknown]): string
+    write_usb_backend(args: [string, string]): string
+    stop_usb_backend(args: [string]): string
 }
 
 export interface NativePeripheral {

package/src/testDoubles/Libndx/FakeLibndx.ts

@@ -1,7 +1,9 @@
 import {
+    AddBleCharCallbacksOptions,
     BleBackendOptions,
     WriteBleCharacteristicOptions,
-    FtdiBackendOptions,
+    UsbBackendOptions,
+    WriteUsbBackendOptions,
     Libndx,
     LibndxAdapterOptions,
     StartBleBackendOptions,
@@ -15,13 +17,15 @@ export default class FakeLibndx implements Libndx {
     public static callsToDiscoverBleUuid: DiscoverBleUuidOptions[] = []
     public static callsToCreateBleBackend: BleBackendOptions[] = []
     public static callsToStartBleBackend: StartBleBackendOptions[] = []
+    public static callsToAddBleCharCallbacks: AddBleCharCallbacksOptions[] = []
     public static callsToWriteBleCharacteristic: WriteBleCharacteristicOptions[] =
         []
     public static callsToStopBleBackend: BleBackendOptions[] = []
     public static callsToSetBleRssiInterval: BleRssiOptions[] = []
-    public static callsToCreateFtdiBackend: FtdiBackendOptions[] = []
-    public static callsToStartFtdiBackend: FtdiBackendOptions[] = []
-    public static callsToStopFtdiBackend: FtdiBackendOptions[] = []
+    public static callsToCreateUsbBackend: UsbBackendOptions[] = []
+    public static callsToStartUsbBackend: UsbBackendOptions[] = []
+    public static callsToWriteUsbBackend: WriteUsbBackendOptions[] = []
+    public static callsToStopUsbBackend: UsbBackendOptions[] = []
 
     public static fakeResult: NativeResult = { status: 200 }
 
@@ -44,6 +48,11 @@ export default class FakeLibndx implements Libndx {
         return FakeLibndx.fakeResult
     }
 
+    public addBleCharCallbacks(options: AddBleCharCallbacksOptions) {
+        FakeLibndx.callsToAddBleCharCallbacks.push(options)
+        return FakeLibndx.fakeResult
+    }
+
     public writeBleCharacteristic(options: WriteBleCharacteristicOptions) {
         FakeLibndx.callsToWriteBleCharacteristic.push(options)
         return FakeLibndx.fakeResult
@@ -59,18 +68,23 @@ export default class FakeLibndx implements Libndx {
         return FakeLibndx.fakeResult
     }
 
-    public createFtdiBackend(options: FtdiBackendOptions) {
-        FakeLibndx.callsToCreateFtdiBackend.push(options)
+    public createUsbBackend(options: UsbBackendOptions) {
+        FakeLibndx.callsToCreateUsbBackend.push(options)
+        return FakeLibndx.fakeResult
+    }
+
+    public startUsbBackend(options: UsbBackendOptions) {
+        FakeLibndx.callsToStartUsbBackend.push(options)
         return FakeLibndx.fakeResult
     }
 
-    public startFtdiBackend(options: FtdiBackendOptions) {
-        FakeLibndx.callsToStartFtdiBackend.push(options)
+    public writeUsbBackend(options: WriteUsbBackendOptions) {
+        FakeLibndx.callsToWriteUsbBackend.push(options)
         return FakeLibndx.fakeResult
     }
 
-    public stopFtdiBackend(options: FtdiBackendOptions) {
-        FakeLibndx.callsToStopFtdiBackend.push(options)
+    public stopUsbBackend(options: UsbBackendOptions) {
+        FakeLibndx.callsToStopUsbBackend.push(options)
         return FakeLibndx.fakeResult
     }
 
@@ -79,11 +93,13 @@ export default class FakeLibndx implements Libndx {
         FakeLibndx.callsToDiscoverBleUuid = []
         FakeLibndx.callsToCreateBleBackend = []
         FakeLibndx.callsToStartBleBackend = []
+        FakeLibndx.callsToAddBleCharCallbacks = []
         FakeLibndx.callsToWriteBleCharacteristic = []
         FakeLibndx.callsToStopBleBackend = []
         FakeLibndx.callsToSetBleRssiInterval = []
-        FakeLibndx.callsToCreateFtdiBackend = []
-        FakeLibndx.callsToStartFtdiBackend = []
-        FakeLibndx.callsToStopFtdiBackend = []
+        FakeLibndx.callsToCreateUsbBackend = []
+        FakeLibndx.callsToStartUsbBackend = []
+        FakeLibndx.callsToWriteUsbBackend = []
+        FakeLibndx.callsToStopUsbBackend = []
     }
 }