@neurosity/sdk 6.0.0-next.11

package/dist/cjs/api/bluetooth/BluetoothClient.d.ts

@@ -0,0 +1,59 @@
+import { Observable } from "rxjs";
+import { ReplaySubject } from "rxjs";
+import { WebBluetoothTransport } from "./web/WebBluetoothTransport";
+import { ReactNativeTransport } from "./react-native/ReactNativeTransport";
+import { DeviceInfo } from "../../types/deviceInfo";
+import { Action } from "../../types/actions";
+import { Epoch } from "../../types/epoch";
+import { BLUETOOTH_CONNECTION } from "./types";
+import { DeviceNicknameOrPeripheral } from "./BluetoothTransport";
+import { Peripheral } from "./react-native/types/BleManagerTypes";
+export declare type BluetoothTransport = WebBluetoothTransport | ReactNativeTransport;
+declare type IsAuthenticated = boolean;
+declare type ExpiresIn = number;
+declare type IsAuthenticatedResponse = [IsAuthenticated, ExpiresIn];
+declare type CreateBluetoothToken = () => Promise<string>;
+declare type Options = {
+    transport: BluetoothTransport;
+    selectedDevice$: Observable<DeviceInfo>;
+    createBluetoothToken: CreateBluetoothToken;
+};
+export declare class BluetoothClient {
+    transport: BluetoothTransport;
+    deviceInfo: DeviceInfo;
+    selectedDevice$: ReplaySubject<DeviceInfo>;
+    isAuthenticated$: ReplaySubject<boolean>;
+    constructor(options: Options);
+    _autoAuthenticate(createBluetoothToken: CreateBluetoothToken): Observable<IsAuthenticatedResponse>;
+    _hasBluetoothSupport(): Promise<boolean>;
+    authenticate(token: string): Promise<IsAuthenticatedResponse>;
+    isAuthenticated(): Promise<IsAuthenticatedResponse>;
+    scan(options?: any): Observable<Peripheral[]>;
+    connect(deviceNicknameORPeripheral?: DeviceNicknameOrPeripheral): Promise<void>;
+    disconnect(): Promise<void>;
+    connection(): Observable<BLUETOOTH_CONNECTION>;
+    logs(): Observable<string>;
+    getDeviceId(): Promise<string>;
+    _withAuthentication<T>(getter: () => Promise<T>): Promise<T>;
+    _subscribeWhileAuthenticated(characteristicName: string): Observable<any>;
+    focus(): Observable<any>;
+    calm(): Observable<any>;
+    accelerometer(): Observable<any>;
+    brainwaves(label: string): Observable<Epoch | any>;
+    signalQuality(): Observable<any>;
+    addMarker(label: string): Promise<void>;
+    getInfo(): Promise<DeviceInfo>;
+    status(): Observable<any>;
+    dispatchAction(action: Action): Promise<any>;
+    settings(): Observable<any>;
+    haptics(effects: any): Promise<any>;
+    get wifi(): {
+        nearbyNetworks: () => Observable<any>;
+        connections: () => Observable<any>;
+        connect: (ssid: string, password?: string) => Promise<any>;
+        forgetConnection: (ssid: string) => Promise<any>;
+        reset: () => Promise<any>;
+        speedTest: () => Promise<any>;
+    };
+}
+export {};

package/dist/cjs/api/bluetooth/BluetoothClient.js

@@ -0,0 +1,287 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BluetoothClient = void 0;
+const rxjs_1 = require("rxjs");
+const rxjs_2 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const operators_2 = require("rxjs/operators");
+const WebBluetoothTransport_1 = require("./web/WebBluetoothTransport");
+const ReactNativeTransport_1 = require("./react-native/ReactNativeTransport");
+const csvBufferToEpoch_1 = require("./utils/csvBufferToEpoch");
+const types_1 = require("./types");
+const osHasBluetoothSupport_1 = require("./utils/osHasBluetoothSupport");
+class BluetoothClient {
+    constructor(options) {
+        this.selectedDevice$ = new rxjs_2.ReplaySubject(1);
+        this.isAuthenticated$ = new rxjs_2.ReplaySubject(1);
+        const { transport, selectedDevice$, createBluetoothToken } = options !== null && options !== void 0 ? options : {};
+        if (!transport) {
+            throw new Error(`No bluetooth transport provided.`);
+        }
+        this.transport = transport;
+        // Pass events to the internal selectedDevice$ if selectedDevice$ is passed via options
+        if (selectedDevice$) {
+            selectedDevice$.subscribe(this.selectedDevice$);
+        }
+        // Auto Connect
+        this.transport._autoConnect(this.selectedDevice$).subscribe({
+            error: (error) => {
+                var _a;
+                this.transport.addLog(`Auto connect: error -> ${(_a = error === null || error === void 0 ? void 0 : error.message) !== null && _a !== void 0 ? _a : error}`);
+            }
+        });
+        // Auto authentication
+        if (typeof createBluetoothToken === "function") {
+            this.transport.addLog("Auto authentication enabled");
+            this._autoAuthenticate(createBluetoothToken).subscribe();
+        }
+        else {
+            this.transport.addLog("Auto authentication not enabled");
+        }
+        // Auto manage action notifications
+        this.transport._autoToggleActionNotifications(this.selectedDevice$);
+    }
+    _autoAuthenticate(createBluetoothToken) {
+        const REAUTHENTICATE_INTERVAL = 3600000; // 1 hour
+        const reauthenticateInterval$ = (0, rxjs_1.timer)(0, REAUTHENTICATE_INTERVAL).pipe((0, operators_1.tap)(() => {
+            this.transport.addLog(`Auto authentication in progress...`);
+        }));
+        return this.selectedDevice$.pipe((0, operators_1.switchMap)((selectedDevice) => !(0, osHasBluetoothSupport_1.osHasBluetoothSupport)(selectedDevice)
+            ? rxjs_2.EMPTY
+            : this.connection().pipe((0, operators_1.switchMap)((connection) => connection === types_1.BLUETOOTH_CONNECTION.CONNECTED
+                ? reauthenticateInterval$
+                : rxjs_2.EMPTY), (0, operators_1.switchMap)(() => __awaiter(this, void 0, void 0, function* () { return yield this.isAuthenticated(); })), (0, operators_1.tap)(([isAuthenticated]) => __awaiter(this, void 0, void 0, function* () {
+                if (!isAuthenticated) {
+                    const token = yield createBluetoothToken();
+                    yield this.authenticate(token);
+                }
+                else {
+                    this.transport.addLog(`Already authenticated`);
+                }
+            })))));
+    }
+    _hasBluetoothSupport() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const selectedDevice = yield (0, rxjs_1.firstValueFrom)(this.selectedDevice$);
+            return (0, osHasBluetoothSupport_1.osHasBluetoothSupport)(selectedDevice);
+        });
+    }
+    authenticate(token) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const hasBluetoothSupport = yield this._hasBluetoothSupport();
+            if (!hasBluetoothSupport) {
+                const errorMessage = `authenticate method: The OS version does not support Bluetooth.`;
+                this.transport.addLog(errorMessage);
+                return Promise.reject(errorMessage);
+            }
+            yield this.transport.writeCharacteristic("auth", token);
+            const isAuthenticatedResponse = yield this.isAuthenticated();
+            const [isAuthenticated] = isAuthenticatedResponse;
+            this.transport.addLog(`Authentication ${isAuthenticated ? "succeeded" : "failed"}`);
+            this.isAuthenticated$.next(isAuthenticated);
+            return isAuthenticatedResponse;
+        });
+    }
+    isAuthenticated() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const [isAuthenticated, expiresIn] = yield this.transport.readCharacteristic("auth", true);
+            this.isAuthenticated$.next(isAuthenticated);
+            return [isAuthenticated, expiresIn];
+        });
+    }
+    // Method for React Native only
+    scan(options) {
+        if (this.transport instanceof ReactNativeTransport_1.ReactNativeTransport) {
+            return this.transport.scan(options);
+        }
+        if (this.transport instanceof WebBluetoothTransport_1.WebBluetoothTransport) {
+            throw new Error(`scan method is compatibly with the React Native transport only`);
+        }
+        throw new Error(`unknown transport`);
+    }
+    // Argument for React Native only
+    connect(deviceNicknameORPeripheral) {
+        if (this.transport instanceof ReactNativeTransport_1.ReactNativeTransport) {
+            return this.transport.connect(deviceNicknameORPeripheral);
+        }
+        if (this.transport instanceof WebBluetoothTransport_1.WebBluetoothTransport) {
+            return deviceNicknameORPeripheral
+                ? this.transport.connect(deviceNicknameORPeripheral)
+                : this.transport.connect();
+        }
+    }
+    disconnect() {
+        return this.transport.disconnect();
+    }
+    connection() {
+        return this.transport.connection();
+    }
+    logs() {
+        return this.transport.logs$.asObservable();
+    }
+    getDeviceId() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // This is a public characteristic and does not require authentication
+            return this.transport.readCharacteristic("deviceId");
+        });
+    }
+    _withAuthentication(getter) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // First check if the OS supports Bluetooth before checking if the device is authenticated
+            const hasBluetoothSupport = yield this._hasBluetoothSupport();
+            if (!hasBluetoothSupport) {
+                const errorMessage = `The OS version does not support Bluetooth.`;
+                this.transport.addLog(errorMessage);
+                return Promise.reject(errorMessage);
+            }
+            const isAuthenticated = yield (0, rxjs_1.firstValueFrom)(this.isAuthenticated$);
+            if (!isAuthenticated) {
+                const errorMessage = `Authentication required.`;
+                this.transport.addLog(errorMessage);
+                return Promise.reject(errorMessage);
+            }
+            return yield getter();
+        });
+    }
+    _subscribeWhileAuthenticated(characteristicName) {
+        return this.selectedDevice$.pipe((0, operators_1.switchMap)((selectedDevice) => !(0, osHasBluetoothSupport_1.osHasBluetoothSupport)(selectedDevice)
+            ? rxjs_2.EMPTY
+            : this.isAuthenticated$.pipe((0, operators_2.distinctUntilChanged)(), (0, operators_1.switchMap)((isAuthenticated) => isAuthenticated
+                ? this.transport.subscribeToCharacteristic({
+                    characteristicName
+                })
+                : rxjs_2.EMPTY))));
+    }
+    focus() {
+        return this._subscribeWhileAuthenticated("focus");
+    }
+    calm() {
+        return this._subscribeWhileAuthenticated("calm");
+    }
+    accelerometer() {
+        return this._subscribeWhileAuthenticated("accelerometer");
+    }
+    brainwaves(label) {
+        switch (label) {
+            case "raw":
+            case "rawUnfiltered":
+                return (0, rxjs_1.defer)(() => this.getInfo()).pipe((0, operators_1.switchMap)((deviceInfo) => this._subscribeWhileAuthenticated(label).pipe((0, csvBufferToEpoch_1.csvBufferToEpoch)(deviceInfo))));
+            default:
+                return this._subscribeWhileAuthenticated(label);
+        }
+    }
+    signalQuality() {
+        return this._subscribeWhileAuthenticated("signalQuality");
+    }
+    addMarker(label) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.dispatchAction({
+                action: "marker",
+                command: "add",
+                message: {
+                    timestamp: Date.now(),
+                    label
+                }
+            });
+        });
+    }
+    getInfo() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._withAuthentication(() => (0, rxjs_1.firstValueFrom)(this.transport.subscribeToCharacteristic({
+                characteristicName: "deviceInfo"
+            })));
+        });
+    }
+    // Tested
+    status() {
+        return this._subscribeWhileAuthenticated("status");
+    }
+    dispatchAction(action) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._withAuthentication(() => this.transport.dispatchAction({
+                characteristicName: "actions",
+                action
+            }));
+        });
+    }
+    settings() {
+        return this._subscribeWhileAuthenticated("settings");
+    }
+    haptics(effects) {
+        const metric = "haptics";
+        return this.dispatchAction({
+            action: metric,
+            command: "queue",
+            responseRequired: true,
+            responseTimeout: 4000,
+            //  @TODO: implement validation logic as per SDK
+            message: { effects }
+        });
+    }
+    get wifi() {
+        return {
+            nearbyNetworks: () => this._subscribeWhileAuthenticated("wifiNearbyNetworks"),
+            connections: () => this._subscribeWhileAuthenticated("wifiConnections"),
+            connect: (ssid, password) => {
+                if (!ssid) {
+                    return Promise.reject(`Missing ssid`);
+                }
+                return this.dispatchAction({
+                    action: "wifi",
+                    command: "connect",
+                    responseRequired: true,
+                    responseTimeout: 1000 * 60 * 2,
+                    message: {
+                        ssid,
+                        password: password !== null && password !== void 0 ? password : null
+                    }
+                });
+            },
+            forgetConnection: (ssid) => {
+                if (!ssid) {
+                    return Promise.reject(`Missing ssid`);
+                }
+                return this.dispatchAction({
+                    action: "wifi",
+                    command: "forget-connection",
+                    responseRequired: true,
+                    responseTimeout: 1000 * 15,
+                    message: {
+                        ssid
+                    }
+                });
+            },
+            reset: () => {
+                return this.dispatchAction({
+                    action: "wifi",
+                    command: "reset",
+                    responseRequired: true,
+                    responseTimeout: 1000 * 30,
+                    message: {
+                        // without this, the action will resolve as soon as the
+                        // action is received by the OS
+                        respondOnSuccess: true
+                    }
+                });
+            },
+            speedTest: () => {
+                return this.dispatchAction({
+                    action: "wifi",
+                    command: "speed-test",
+                    responseRequired: true,
+                    responseTimeout: 1000 * 60 * 1 // 1 minute
+                });
+            }
+        };
+    }
+}
+exports.BluetoothClient = BluetoothClient;

package/dist/cjs/api/bluetooth/BluetoothTransport.d.ts

@@ -0,0 +1,32 @@
+import { Observable, Subject } from "rxjs";
+import { BLUETOOTH_CONNECTION, TRANSPORT_TYPE } from "./types";
+import { Action } from "../../types/actions";
+import { DeviceInfo } from "../../types/deviceInfo";
+import { Peripheral } from "./react-native/types/BleManagerTypes";
+export declare type DeviceNicknameOrPeripheral = string | Peripheral;
+/**
+ * @hidden
+ */
+export interface BluetoothTransport {
+    type: TRANSPORT_TYPE;
+    connect(deviceNicknameORPeripheral?: DeviceNicknameOrPeripheral): Promise<void>;
+    _autoConnect(selectedDevice$: Observable<DeviceInfo>): Observable<void>;
+    disconnect(): Promise<void>;
+    connection(): Observable<BLUETOOTH_CONNECTION>;
+    requestDevice?(): any;
+    addLog: (log: string) => void;
+    logs$: Subject<string>;
+    scan?(options?: {
+        seconds?: number;
+    }): Observable<Peripheral[]>;
+    subscribeToCharacteristic(args: {
+        characteristicName: string;
+        manageNotifications?: boolean;
+    }): Observable<any>;
+    readCharacteristic(characteristicName: string, parse?: boolean): Promise<any>;
+    writeCharacteristic(characteristicName: string, data: string): Promise<void>;
+    dispatchAction(args: {
+        characteristicName: string;
+        action: Action;
+    }): Promise<any>;
+}

package/dist/cjs/api/bluetooth/BluetoothTransport.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/api/bluetooth/constants.d.ts

@@ -0,0 +1,4 @@
+export declare const ANDROID_MAX_MTU: number;
+export declare const REACT_NATIVE_MAX_BYTE_SIZE: number;
+export declare const DEFAULT_ACTION_RESPONSE_TIMEOUT: number;
+export declare const CHARACTERISTIC_UUIDS_TO_NAMES: any;

package/dist/cjs/api/bluetooth/constants.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CHARACTERISTIC_UUIDS_TO_NAMES = exports.DEFAULT_ACTION_RESPONSE_TIMEOUT = exports.REACT_NATIVE_MAX_BYTE_SIZE = exports.ANDROID_MAX_MTU = void 0;
+const ipk_1 = require("@neurosity/ipk");
+exports.ANDROID_MAX_MTU = 512;
+exports.REACT_NATIVE_MAX_BYTE_SIZE = 512; // the default is 20
+exports.DEFAULT_ACTION_RESPONSE_TIMEOUT = 1000 * 60; // 1 minute
+// Reverse BLUETOOTH_CHARACTERISTICS key/values for easy lookup
+exports.CHARACTERISTIC_UUIDS_TO_NAMES = Object.fromEntries(Object.entries(ipk_1.BLUETOOTH_CHARACTERISTICS).map((entries) => entries.reverse()));

package/dist/cjs/api/bluetooth/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./BluetoothClient";
+export * from "./web/WebBluetoothTransport";
+export * from "./react-native/ReactNativeTransport";
+export * from "./utils/osHasBluetoothSupport";

package/dist/cjs/api/bluetooth/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./BluetoothClient"), exports);
+__exportStar(require("./web/WebBluetoothTransport"), exports);
+__exportStar(require("./react-native/ReactNativeTransport"), exports);
+__exportStar(require("./utils/osHasBluetoothSupport"), exports);

package/dist/cjs/api/bluetooth/react-native/ReactNativeTransport.d.ts

@@ -0,0 +1,65 @@
+import { BehaviorSubject, ReplaySubject } from "rxjs";
+import { Observable } from "rxjs";
+import { BluetoothTransport } from "../BluetoothTransport";
+import { ActionOptions, SubscribeOptions } from "../types";
+import { TRANSPORT_TYPE, BLUETOOTH_CONNECTION } from "../types";
+import { BleManager } from "./types/BleManagerTypes";
+import { Peripheral } from "./types/BleManagerTypes";
+import { NativeEventEmitter } from "./types/ReactNativeTypes";
+import { PlatformOSType } from "./types/ReactNativeTypes";
+import { DeviceInfo } from "../../../types/deviceInfo";
+declare type Characteristic = {
+    characteristicUUID: string;
+    serviceUUID: string;
+    peripheralId: string;
+};
+declare type CharacteristicsByName = {
+    [name: string]: Characteristic;
+};
+declare type Options = {
+    BleManager: BleManager;
+    bleManagerEmitter: NativeEventEmitter;
+    platform: PlatformOSType;
+};
+declare type BleManagerEvents = {
+    stopScan$: Observable<void>;
+    discoverPeripheral$: Observable<Peripheral>;
+    connectPeripheral$: Observable<void>;
+    disconnectPeripheral$: Observable<void>;
+    didUpdateValueForCharacteristic$: Observable<any>;
+};
+export declare class ReactNativeTransport implements BluetoothTransport {
+    type: TRANSPORT_TYPE;
+    BleManager: BleManager;
+    bleManagerEmitter: NativeEventEmitter;
+    platform: PlatformOSType;
+    bleEvents: BleManagerEvents;
+    device: Peripheral;
+    characteristicsByName: CharacteristicsByName;
+    connection$: BehaviorSubject<BLUETOOTH_CONNECTION>;
+    pendingActions$: BehaviorSubject<any[]>;
+    logs$: ReplaySubject<string>;
+    onDisconnected$: Observable<void>;
+    connectionStream$: Observable<BLUETOOTH_CONNECTION>;
+    constructor(options: Options);
+    addLog(log: string): void;
+    isConnected(): boolean;
+    _autoConnect(selectedDevice$: Observable<DeviceInfo>): Observable<void>;
+    connection(): Observable<BLUETOOTH_CONNECTION>;
+    _fromEvent(eventName: string): Observable<any>;
+    scan(options?: {
+        seconds?: number;
+        once?: boolean;
+    }): Observable<Peripheral[]>;
+    connect(peripheral: Peripheral): Promise<void>;
+    disconnect(): Promise<void>;
+    getCharacteristicByName(characteristicName: string): Characteristic;
+    subscribeToCharacteristic({ characteristicName, manageNotifications }: SubscribeOptions): Observable<any>;
+    readCharacteristic(characteristicName: string, parse?: boolean): Promise<any>;
+    writeCharacteristic(characteristicName: string, data: string): Promise<void>;
+    _addPendingAction(actionId: number): void;
+    _removePendingAction(actionId: number): void;
+    _autoToggleActionNotifications(selectedDevice$: Observable<DeviceInfo>): Promise<void>;
+    dispatchAction({ characteristicName, action }: ActionOptions): Promise<any>;
+}
+export {};