@neurodevs/ndx-native 6.0.1 → 6.1.0

package/src/__tests__/impl/LibndxAdapter.test.ts

@@ -5,6 +5,7 @@ import LibndxAdapter, {
     Libndx,
     LibndxBindings,
 } from '../../impl/LibndxAdapter.js'
+import type { NativePeripheral } from '../../impl/LibndxAdapter.js'
 import AbstractPackageTest from '../AbstractPackageTest.js'
 import FakeLibndx from '../../testDoubles/Libndx/FakeLibndx.js'
 
@@ -16,11 +17,13 @@ export default class LibndxAdapterTest extends AbstractPackageTest {
 
     private static koffiLoadPath?: string
     private static koffiFuncSignatures?: string[]
+    private static koffiProtoCalls?: string[]
     private static koffiStructCalls?: { name: string; fields: object }[]
 
     private static readonly bleDeviceUuid = this.generateId()
     private static readonly bleCharacteristicUuid = this.generateId()
     private static readonly bleValueToWrite = this.generateId()
+    private static readonly bleRssiIntervalMs = Math.random()
 
     private static readonly ftdiSerialNumber = this.generateId()
 
@@ -34,6 +37,12 @@ export default class LibndxAdapterTest extends AbstractPackageTest {
 
     private static readonly successfulResult = { status: 200 }
 
+    private static readonly bleNamePrefix = this.generateId()
+
+    private static readonly callsToDiscoverBle: {
+        namePrefix: string
+        onDiscovered: unknown
+    }[] = []
     private static readonly callsToCreateBle: string[][] = []
     private static readonly callsToStartBle: {
         uuid: string
@@ -41,7 +50,11 @@ export default class LibndxAdapterTest extends AbstractPackageTest {
         charCallbacks: CharacteristicCallback[]
     }[] = []
     private static readonly callsToWriteBle: string[][] = []
-    private static readonly callsToReadRssi: string[][] = []
+    private static readonly callsToSetBleRssiInterval: {
+        uuid: string
+        intervalMs: number
+        onRssi: unknown
+    }[] = []
     private static readonly callsToStopBle: string[][] = []
 
     private static readonly callsToCreateFtdi: string[][] = []
@@ -94,10 +107,11 @@ export default class LibndxAdapterTest extends AbstractPackageTest {
         assert.isEqualDeep(
             this.koffiFuncSignatures,
             [
+                'str discover_ble_uuid(str name_prefix, OnDiscoveredFn *on_discovered)',
                 'str create_ble_backend(str config)',
                 'str start_ble_backend(str uuid, OnConnectedFn *on_connected, CharCallback *callbacks, int num_callbacks)',
                 'str write_ble_characteristic(str uuid, str charUuid, str value)',
-                'str read_ble_rssi(str uuid)',
+                'str set_ble_rssi_interval(str uuid, int interval_ms, OnRssiFn *on_rssi)',
                 'str stop_ble_backend(str uuid)',
                 'str create_ftdi_backend(str config)',
                 'str start_ftdi_backend(str serial)',
@@ -125,6 +139,69 @@ export default class LibndxAdapterTest extends AbstractPackageTest {
         )
     }
 
+    @test()
+    protected static async registersOnRssiProtoBeforeLoadingBindings() {
+        const onRssiProtoIdx = this.koffiProtoCalls!.findIndex((s) =>
+            s.includes('OnRssiFn')
+        )
+        const firstFuncIdx = this.koffiFuncSignatures!.findIndex((s) =>
+            s.includes('OnRssiFn')
+        )
+        assert.isAbove(
+            onRssiProtoIdx,
+            -1,
+            'Did not register OnRssiFn proto before loading bindings!'
+        )
+        assert.isBelow(
+            onRssiProtoIdx,
+            firstFuncIdx + this.koffiProtoCalls!.length,
+            'OnRssiFn proto must be registered before bindings are loaded!'
+        )
+    }
+
+    @test()
+    protected static async registersOnDiscoveredProtoBeforeLoadingBindings() {
+        const onDiscoveredProtoIdx = this.koffiProtoCalls!.findIndex((s) =>
+            s.includes('OnDiscoveredFn')
+        )
+        const firstFuncIdx = this.koffiFuncSignatures!.findIndex((s) =>
+            s.includes('OnDiscoveredFn')
+        )
+        assert.isAbove(
+            onDiscoveredProtoIdx,
+            -1,
+            'Did not register OnDiscoveredFn proto before loading bindings!'
+        )
+        assert.isBelow(
+            onDiscoveredProtoIdx,
+            firstFuncIdx + this.koffiProtoCalls!.length,
+            'OnDiscoveredFn proto must be registered before bindings are loaded!'
+        )
+    }
+
+    @test()
+    protected static async onConnectedReceivesPeripheral() {
+        let received: NativePeripheral | undefined = undefined
+
+        this.startBleBackend((peripheral: NativePeripheral) => {
+            received = peripheral
+        })
+
+        const peripheral = { uuid: this.generateId(), name: 'Muse-1234' }
+
+        const registeredOnConnected = this.callsToStartBle[0].onConnected as (
+            uuid: string,
+            name: string
+        ) => void
+        registeredOnConnected(peripheral.uuid, peripheral.name)
+
+        assert.isEqualDeep(
+            received,
+            peripheral,
+            'onConnected was not called with the peripheral!'
+        )
+    }
+
     @test()
     protected static async getInstanceReturnsASingleton() {
         assert.isEqual(LibndxAdapter.getInstance(), LibndxAdapter.getInstance())
@@ -137,6 +214,53 @@ export default class LibndxAdapterTest extends AbstractPackageTest {
         assert.isEqual(LibndxAdapter.getInstance(), fake)
     }
 
+    @test()
+    protected static async discoverBleUuidCallsBindingWithExpectedArgs() {
+        this.discoverBleUuid()
+
+        assert.isEqual(
+            this.callsToDiscoverBle[0].namePrefix,
+            this.bleNamePrefix,
+            'discoverBleUuid did not pass expected namePrefix to binding!'
+        )
+
+        assert.isFunction(
+            this.callsToDiscoverBle[0].onDiscovered,
+            'discoverBleUuid did not pass an onDiscovered callback to the binding!'
+        )
+    }
+
+    @test()
+    protected static async discoverBleUuidReturnsJson() {
+        const json = this.discoverBleUuid()
+
+        assert.isEqualDeep(
+            json,
+            this.successfulResult,
+            'discoverBleUuid did not return a JSON string!'
+        )
+    }
+
+    @test()
+    protected static async discoverBleUuidInvokesOnDiscoveredWithUuid() {
+        let received: string | undefined
+
+        this.discoverBleUuid((uuid: string) => {
+            received = uuid
+        })
+
+        const discoveredUuid = this.generateId()
+        const registeredOnDiscovered = this.callsToDiscoverBle[0]
+            .onDiscovered as (uuid: string) => void
+        registeredOnDiscovered(discoveredUuid)
+
+        assert.isEqual(
+            received,
+            discoveredUuid,
+            'onDiscovered was not invoked with discovered uuid!'
+        )
+    }
+
     @test()
     protected static async createBleBackendCallsBindingWithExpectedArgs() {
         this.createBleBackend()
@@ -216,27 +340,53 @@ export default class LibndxAdapterTest extends AbstractPackageTest {
     }
 
     @test()
-    protected static async getRssiBleBackendCallsBindingWithExpectedArgs() {
-        this.getRssiBleBackend()
+    protected static async setBleRssiIntervalCallsBindingWithExpectedArgs() {
+        this.setBleRssiInterval()
 
-        assert.isEqual(
-            this.callsToReadRssi[0][0],
-            this.bleDeviceUuid,
-            'getRssiBleBackend did not call binding with expected args!'
+        const { uuid, intervalMs } = this.callsToSetBleRssiInterval[0]
+
+        assert.isEqualDeep(
+            { uuid, intervalMs },
+            {
+                uuid: this.bleDeviceUuid,
+                intervalMs: this.bleRssiIntervalMs,
+            },
+            'setBleRssiInterval did not call binding with expected args!'
+        )
+
+        assert.isFunction(
+            this.callsToSetBleRssiInterval[0].onRssi,
+            'setBleRssiInterval did not pass an onRssi callback to the binding!'
         )
     }
 
     @test()
-    protected static async getRssiBleBackendReturnsJson() {
-        const json = this.getRssiBleBackend()
+    protected static async setBleRssiIntervalReturnsJson() {
+        const json = this.setBleRssiInterval()
 
         assert.isEqualDeep(
             json,
             this.successfulResult,
-            'getRssiBleBackend did not return a JSON string!'
+            'setBleRssiInterval did not return a JSON string!'
         )
     }
 
+    @test()
+    protected static async setBleRssiIntervalInvokesOnRssiWithRssiValue() {
+        let received: number | undefined
+
+        this.setBleRssiInterval((rssi: number) => {
+            received = rssi
+        })
+
+        const registeredOnRssi = this.callsToSetBleRssiInterval[0].onRssi as (
+            rssi: number
+        ) => void
+        registeredOnRssi(-72)
+
+        assert.isEqual(received, -72, 'onRssi was not invoked with rssi value!')
+    }
+
     @test()
     protected static async stopBleBackendCallsBindingWithExpectedArgs() {
         this.stopBleBackend()
@@ -325,16 +475,25 @@ export default class LibndxAdapterTest extends AbstractPackageTest {
         )
     }
 
+    private static discoverBleUuid(onDiscovered?: (uuid: string) => void) {
+        return this.instance.discoverBleUuid({
+            namePrefix: this.bleNamePrefix,
+            onDiscovered: onDiscovered ?? (() => {}),
+        })
+    }
+
     private static createBleBackend() {
         return this.instance.createBleBackend({
             deviceUuid: this.bleDeviceUuid,
         })
     }
 
-    private static startBleBackend() {
+    private static startBleBackend(
+        onConnected?: (peripheral: NativePeripheral) => void
+    ) {
         return this.instance.startBleBackend({
             deviceUuid: this.bleDeviceUuid,
-            onConnected: () => {},
+            onConnected: onConnected || (() => {}),
             charCallbacks: this.charCallbacks,
         })
     }
@@ -353,9 +512,11 @@ export default class LibndxAdapterTest extends AbstractPackageTest {
         })
     }
 
-    private static getRssiBleBackend() {
-        return this.instance.readBleRssi({
+    private static setBleRssiInterval(onRssi?: (rssi: number) => void) {
+        return this.instance.setBleRssiInterval({
             deviceUuid: this.bleDeviceUuid,
+            intervalMs: this.bleRssiIntervalMs,
+            onRssi: onRssi ?? (() => {}),
         })
     }
 
@@ -379,6 +540,13 @@ export default class LibndxAdapterTest extends AbstractPackageTest {
 
     private static FakeBindings(): LibndxBindings {
         return {
+            discover_ble_uuid: (args: any) => {
+                this.callsToDiscoverBle.push({
+                    namePrefix: args[0],
+                    onDiscovered: args[1],
+                })
+                return JSON.stringify(this.successfulResult)
+            },
             create_ble_backend: (args) => {
                 this.callsToCreateBle.push(args)
                 return JSON.stringify(this.successfulResult)
@@ -395,8 +563,12 @@ export default class LibndxAdapterTest extends AbstractPackageTest {
                 this.callsToWriteBle.push(args)
                 return JSON.stringify(this.successfulResult)
             },
-            read_ble_rssi: (args) => {
-                this.callsToReadRssi.push(args)
+            set_ble_rssi_interval: (args) => {
+                this.callsToSetBleRssiInterval.push({
+                    uuid: args[0],
+                    intervalMs: args[1],
+                    onRssi: args[2],
+                })
                 return JSON.stringify(this.successfulResult)
             },
             stop_ble_backend: (args) => {
@@ -419,10 +591,11 @@ export default class LibndxAdapterTest extends AbstractPackageTest {
     }
 
     private static resetCallsToFakeBindings() {
+        this.callsToDiscoverBle.length = 0
         this.callsToCreateBle.length = 0
         this.callsToStartBle.length = 0
         this.callsToStopBle.length = 0
-        this.callsToReadRssi.length = 0
+        this.callsToSetBleRssiInterval.length = 0
         this.callsToCreateFtdi.length = 0
         this.callsToStartFtdi.length = 0
         this.callsToStopFtdi.length = 0
@@ -431,6 +604,7 @@ export default class LibndxAdapterTest extends AbstractPackageTest {
     private static clearAndFakeFfi() {
         delete this.koffiLoadPath
         this.koffiFuncSignatures = []
+        this.koffiProtoCalls = []
         this.koffiStructCalls = []
         LibndxAdapter.resetKoffiCache()
         this.fakeKoffiLoad()
@@ -449,7 +623,10 @@ export default class LibndxAdapterTest extends AbstractPackageTest {
     }
 
     private static fakeKoffiProto() {
-        LibndxAdapter.koffiProto = (() => ({})) as any
+        LibndxAdapter.koffiProto = ((sig: string) => {
+            this.koffiProtoCalls!.push(sig)
+            return {} as any
+        }) as any
     }
 
     private static fakeKoffiStruct() {

package/src/impl/LibndxAdapter.ts

@@ -10,40 +10,9 @@ export default class LibndxAdapter implements Libndx {
 
     private static charCallbackProto?: ReturnType<typeof koffi.proto>
     private static charCallbackStruct?: ReturnType<typeof koffi.struct>
+    private static onDiscoveredProto?: ReturnType<typeof koffi.proto>
     private static onConnectedProto?: ReturnType<typeof koffi.proto>
-
-    private static getCharCallbackProto() {
-        if (!this.charCallbackProto) {
-            this.charCallbackProto = LibndxAdapter.koffiProto(
-                'void CharCallbackFn(uint8 *data, int length, double timestamp)'
-            )
-        }
-        return this.charCallbackProto
-    }
-
-    private static getOnConnectedProto() {
-        if (!this.onConnectedProto) {
-            this.onConnectedProto = LibndxAdapter.koffiProto(
-                'void OnConnectedFn()'
-            )
-        }
-        return this.onConnectedProto
-    }
-
-    private static getCharCallbackStruct() {
-        if (!this.charCallbackStruct) {
-            this.getCharCallbackProto()
-            this.charCallbackStruct = LibndxAdapter.koffiStruct(
-                'CharCallback',
-                {
-                    charUuid: 'str',
-                    charName: 'str',
-                    onData: LibndxAdapter.koffiPointer(this.charCallbackProto!),
-                }
-            )
-        }
-        return this.charCallbackStruct
-    }
+    private static onRssiProto?: ReturnType<typeof koffi.proto>
 
     private static instance?: Libndx
 
@@ -77,7 +46,9 @@ export default class LibndxAdapter implements Libndx {
     public static resetKoffiCache() {
         delete this.charCallbackProto
         delete this.charCallbackStruct
+        delete this.onDiscoveredProto
         delete this.onConnectedProto
+        delete this.onRssiProto
     }
 
     private tryToLoadBindings() {
@@ -90,7 +61,9 @@ export default class LibndxAdapter implements Libndx {
 
     private defineBindings() {
         LibndxAdapter.getCharCallbackStruct()
+        LibndxAdapter.getOnDiscoveredProto()
         LibndxAdapter.getOnConnectedProto()
+        LibndxAdapter.getOnRssiProto()
         const lib = LibndxAdapter.koffiLoad(this.libndxPath)
 
         const wrap1 = (f: (a: string) => string) => (args: [string]) =>
@@ -106,7 +79,22 @@ export default class LibndxAdapter implements Libndx {
             (args: [string, unknown, unknown, number]) =>
                 f(args[0], args[1], args[2], args[3])
 
+        const wrapSetBleRssiInterval =
+            (f: (a: string, b: number, c: unknown) => string) =>
+            (args: [string, number, unknown]) =>
+                f(args[0], args[1], args[2])
+
+        const wrapDiscoverBleUuid =
+            (f: (a: string, b: unknown) => string) =>
+            (args: [string, unknown]) =>
+                f(args[0], args[1])
+
         this.bindings = {
+            discover_ble_uuid: wrapDiscoverBleUuid(
+                lib.func(
+                    'str discover_ble_uuid(str name_prefix, OnDiscoveredFn *on_discovered)'
+                )
+            ),
             create_ble_backend: wrap1(
                 lib.func('str create_ble_backend(str config)')
             ),
@@ -120,7 +108,11 @@ export default class LibndxAdapter implements Libndx {
                     'str write_ble_characteristic(str uuid, str charUuid, str value)'
                 )
             ),
-            read_ble_rssi: wrap1(lib.func('str read_ble_rssi(str uuid)')),
+            set_ble_rssi_interval: wrapSetBleRssiInterval(
+                lib.func(
+                    'str set_ble_rssi_interval(str uuid, int interval_ms, OnRssiFn *on_rssi)'
+                )
+            ),
             stop_ble_backend: wrap1(lib.func('str stop_ble_backend(str uuid)')),
             create_ftdi_backend: wrap1(
                 lib.func('str create_ftdi_backend(str config)')
@@ -158,6 +150,22 @@ export default class LibndxAdapter implements Libndx {
         )
     }
 
+    public discoverBleUuid(options: DiscoverBleUuidOptions) {
+        const { namePrefix, onDiscovered } = options
+
+        const registeredOnDiscovered = LibndxAdapter.koffiRegister(
+            onDiscovered,
+            LibndxAdapter.koffiPointer(LibndxAdapter.getOnDiscoveredProto()!)
+        )
+
+        return JSON.parse(
+            this.bindings.discover_ble_uuid([
+                namePrefix,
+                registeredOnDiscovered,
+            ])
+        )
+    }
+
     public createBleBackend(options: BleBackendOptions) {
         const { deviceUuid } = options
         const configJson = JSON.stringify({ uuid: deviceUuid })
@@ -169,7 +177,7 @@ export default class LibndxAdapter implements Libndx {
         const { deviceUuid, onConnected, charCallbacks } = options
 
         const registeredOnConnected = LibndxAdapter.koffiRegister(
-            onConnected,
+            (uuid: string, name: string) => onConnected({ uuid, name }),
             LibndxAdapter.koffiPointer(LibndxAdapter.getOnConnectedProto()!)
         )
 
@@ -208,9 +216,21 @@ export default class LibndxAdapter implements Libndx {
         )
     }
 
-    public readBleRssi(options: BleBackendOptions) {
-        const { deviceUuid } = options
-        return JSON.parse(this.bindings.read_ble_rssi([deviceUuid]))
+    public setBleRssiInterval(options: BleRssiOptions) {
+        const { deviceUuid, intervalMs, onRssi } = options
+
+        const registeredOnRssi = LibndxAdapter.koffiRegister(
+            onRssi,
+            LibndxAdapter.koffiPointer(LibndxAdapter.getOnRssiProto()!)
+        )
+
+        return JSON.parse(
+            this.bindings.set_ble_rssi_interval([
+                deviceUuid,
+                intervalMs,
+                registeredOnRssi,
+            ])
+        )
     }
 
     public stopBleBackend(options: BleBackendOptions) {
@@ -234,13 +254,65 @@ export default class LibndxAdapter implements Libndx {
         const { serialNumber } = options
         return JSON.parse(this.bindings.stop_ftdi_backend([serialNumber]))
     }
+
+    private static getCharCallbackProto() {
+        if (!this.charCallbackProto) {
+            this.charCallbackProto = LibndxAdapter.koffiProto(
+                'void CharCallbackFn(uint8 *data, int length, double timestamp)'
+            )
+        }
+        return this.charCallbackProto
+    }
+
+    private static getOnConnectedProto() {
+        if (!this.onConnectedProto) {
+            this.onConnectedProto = LibndxAdapter.koffiProto(
+                'void OnConnectedFn(str uuid, str name)'
+            )
+        }
+        return this.onConnectedProto
+    }
+
+    private static getOnRssiProto() {
+        if (!this.onRssiProto) {
+            this.onRssiProto = LibndxAdapter.koffiProto(
+                'void OnRssiFn(int rssi)'
+            )
+        }
+        return this.onRssiProto
+    }
+
+    private static getOnDiscoveredProto() {
+        if (!this.onDiscoveredProto) {
+            this.onDiscoveredProto = LibndxAdapter.koffiProto(
+                'void OnDiscoveredFn(str uuid)'
+            )
+        }
+        return this.onDiscoveredProto
+    }
+
+    private static getCharCallbackStruct() {
+        if (!this.charCallbackStruct) {
+            this.getCharCallbackProto()
+            this.charCallbackStruct = LibndxAdapter.koffiStruct(
+                'CharCallback',
+                {
+                    charUuid: 'str',
+                    charName: 'str',
+                    onData: LibndxAdapter.koffiPointer(this.charCallbackProto!),
+                }
+            )
+        }
+        return this.charCallbackStruct
+    }
 }
 
 export interface Libndx {
+    discoverBleUuid(options: DiscoverBleUuidOptions): NativeResult
     createBleBackend(options: BleBackendOptions): NativeResult
     startBleBackend(options: StartBleBackendOptions): NativeResult
     writeBleCharacteristic(options: WriteBleCharacteristicOptions): NativeResult
-    readBleRssi(options: BleBackendOptions): NativeResult
+    setBleRssiInterval(options: BleRssiOptions): NativeResult
     stopBleBackend(options: BleBackendOptions): NativeResult
     createFtdiBackend(options: FtdiBackendOptions): NativeResult
     startFtdiBackend(options: FtdiBackendOptions): NativeResult
@@ -253,6 +325,11 @@ export interface LibndxAdapterOptions {
     libndxPath?: string
 }
 
+export interface DiscoverBleUuidOptions {
+    namePrefix: string
+    onDiscovered: (uuid: string) => void
+}
+
 export interface BleBackendOptions {
     deviceUuid: string
 }
@@ -262,6 +339,11 @@ export interface StartBleBackendOptions extends BleBackendOptions {
     charCallbacks: CharacteristicCallback[]
 }
 
+export interface BleRssiOptions extends BleBackendOptions {
+    intervalMs: number
+    onRssi: (rssi: number) => void
+}
+
 export interface WriteBleCharacteristicOptions {
     deviceUuid: string
     charUuid: string
@@ -279,10 +361,11 @@ export interface FtdiBackendOptions {
 }
 
 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
     write_ble_characteristic(args: [string, string, string]): string
-    read_ble_rssi(args: [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

package/src/impl/LibxdfAdapter.ts

@@ -1,9 +1,10 @@
-import fs from 'fs'
+import fs from 'node:fs'
+
+import { DataType, define, open } from 'ffi-rs'
 import {
     MangledNameExtractor,
     MangledNameMap,
 } from '@neurodevs/node-mangled-names'
-import { DataType, define, open } from 'ffi-rs'
 
 export default class LibxdfAdapter implements Libxdf {
     public static Class?: LibxdfConstructor

package/src/testDoubles/Libndx/FakeLibndx.ts

@@ -6,15 +6,19 @@ import {
     LibndxAdapterOptions,
     StartBleBackendOptions,
     NativeResult,
+    BleRssiOptions,
+    DiscoverBleUuidOptions,
 } from '../../impl/LibndxAdapter.js'
 
 export default class FakeLibndx implements Libndx {
     public static callsToConstructor: (LibndxAdapterOptions | undefined)[] = []
+    public static callsToDiscoverBleUuid: DiscoverBleUuidOptions[] = []
     public static callsToCreateBleBackend: BleBackendOptions[] = []
     public static callsToStartBleBackend: StartBleBackendOptions[] = []
-    public static callsToWriteBleChar: WriteBleCharacteristicOptions[] = []
+    public static callsToWriteBleCharacteristic: WriteBleCharacteristicOptions[] =
+        []
     public static callsToStopBleBackend: BleBackendOptions[] = []
-    public static callsToGetRssiBleBackend: BleBackendOptions[] = []
+    public static callsToSetBleRssiInterval: BleRssiOptions[] = []
     public static callsToCreateFtdiBackend: FtdiBackendOptions[] = []
     public static callsToStartFtdiBackend: FtdiBackendOptions[] = []
     public static callsToStopFtdiBackend: FtdiBackendOptions[] = []
@@ -25,6 +29,11 @@ export default class FakeLibndx implements Libndx {
         FakeLibndx.callsToConstructor.push(options)
     }
 
+    public discoverBleUuid(options: DiscoverBleUuidOptions) {
+        FakeLibndx.callsToDiscoverBleUuid.push(options)
+        return FakeLibndx.fakeResult
+    }
+
     public createBleBackend(options: BleBackendOptions) {
         FakeLibndx.callsToCreateBleBackend.push(options)
         return FakeLibndx.fakeResult
@@ -36,12 +45,12 @@ export default class FakeLibndx implements Libndx {
     }
 
     public writeBleCharacteristic(options: WriteBleCharacteristicOptions) {
-        FakeLibndx.callsToWriteBleChar.push(options)
+        FakeLibndx.callsToWriteBleCharacteristic.push(options)
         return FakeLibndx.fakeResult
     }
 
-    public readBleRssi(options: BleBackendOptions) {
-        FakeLibndx.callsToGetRssiBleBackend.push(options)
+    public setBleRssiInterval(options: BleRssiOptions) {
+        FakeLibndx.callsToSetBleRssiInterval.push(options)
         return FakeLibndx.fakeResult
     }
 
@@ -67,11 +76,12 @@ export default class FakeLibndx implements Libndx {
 
     public static resetTestDouble() {
         FakeLibndx.callsToConstructor = []
+        FakeLibndx.callsToDiscoverBleUuid = []
         FakeLibndx.callsToCreateBleBackend = []
         FakeLibndx.callsToStartBleBackend = []
-        FakeLibndx.callsToWriteBleChar = []
+        FakeLibndx.callsToWriteBleCharacteristic = []
         FakeLibndx.callsToStopBleBackend = []
-        FakeLibndx.callsToGetRssiBleBackend = []
+        FakeLibndx.callsToSetBleRssiInterval = []
         FakeLibndx.callsToCreateFtdiBackend = []
         FakeLibndx.callsToStartFtdiBackend = []
         FakeLibndx.callsToStopFtdiBackend = []