@neurosity/sdk 6.2.1-next.2 → 6.2.2

package/dist/{api → cjs/api}/bluetooth/BluetoothClient.d.ts

@@ -8,12 +8,12 @@ import { Epoch } from "../../types/epoch";
 import { BLUETOOTH_CONNECTION } from "./types";
 import { DeviceNicknameOrPeripheral } from "./BluetoothTransport";
 import { Peripheral } from "./react-native/types/BleManagerTypes";
-export type BluetoothTransport = WebBluetoothTransport | ReactNativeTransport;
-type IsAuthenticated = boolean;
-type ExpiresIn = number;
-type IsAuthenticatedResponse = [IsAuthenticated, ExpiresIn];
-type CreateBluetoothToken = () => Promise<string>;
-type Options = {
+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;

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

@@ -0,0 +1,310 @@
+"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$);
+        // Multicast metrics (share)
+        this._focus$ = this._subscribeWhileAuthenticated("focus");
+        this._calm$ = this._subscribeWhileAuthenticated("calm");
+        this._accelerometer$ = this._subscribeWhileAuthenticated("accelerometer");
+        this._brainwavesRaw$ = this._subscribeWhileAuthenticated("raw");
+        this._brainwavesRawUnfiltered$ =
+            this._subscribeWhileAuthenticated("rawUnfiltered");
+        this._brainwavesPSD$ = this._subscribeWhileAuthenticated("psd");
+        this._brainwavesPowerByBand$ =
+            this._subscribeWhileAuthenticated("powerByBand");
+        this._signalQuality$ = this._subscribeWhileAuthenticated("signalQuality");
+        this._status$ = this._subscribeWhileAuthenticated("status");
+        this._settings$ = this._subscribeWhileAuthenticated("settings");
+        this._wifiNearbyNetworks$ =
+            this._subscribeWhileAuthenticated("wifiNearbyNetworks");
+        this._wifiConnections$ =
+            this._subscribeWhileAuthenticated("wifiConnections");
+    }
+    _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`);
+                }
+            })))));
+    }
+    enableAutoConnect(autoConnect) {
+        this.transport.enableAutoConnect(autoConnect);
+    }
+    _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))), (0, operators_1.share)());
+    }
+    focus() {
+        return this._focus$;
+    }
+    calm() {
+        return this._calm$;
+    }
+    accelerometer() {
+        return this._accelerometer$;
+    }
+    brainwaves(label) {
+        switch (label) {
+            default:
+            case "raw":
+                return (0, rxjs_1.defer)(() => this.getInfo()).pipe((0, operators_1.switchMap)((deviceInfo) => this._brainwavesRaw$.pipe((0, csvBufferToEpoch_1.csvBufferToEpoch)(deviceInfo))));
+            case "rawUnfiltered":
+                return (0, rxjs_1.defer)(() => this.getInfo()).pipe((0, operators_1.switchMap)((deviceInfo) => this._brainwavesRawUnfiltered$.pipe((0, csvBufferToEpoch_1.csvBufferToEpoch)(deviceInfo))));
+            case "psd":
+                return this._brainwavesPSD$;
+            case "powerByBand":
+                return this._brainwavesPowerByBand$;
+        }
+    }
+    signalQuality() {
+        return this._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"
+            })));
+        });
+    }
+    status() {
+        return this._status$;
+    }
+    dispatchAction(action) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._withAuthentication(() => this.transport.dispatchAction({
+                characteristicName: "actions",
+                action
+            }));
+        });
+    }
+    settings() {
+        return this._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._wifiNearbyNetworks$,
+            connections: () => this._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,33 @@
+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>;
+    enableAutoConnect?(value: boolean): void;
+    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.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.js

@@ -0,0 +1,21 @@
+"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);
+__exportStar(require("./types/index"), exports);

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

@@ -8,21 +8,21 @@ import { Peripheral } from "./types/BleManagerTypes";
 import { NativeEventEmitter } from "./types/ReactNativeTypes";
 import { PlatformOSType } from "./types/ReactNativeTypes";
 import { DeviceInfo } from "../../../types/deviceInfo";
-type Characteristic = {
+declare type Characteristic = {
     characteristicUUID: string;
     serviceUUID: string;
     peripheralId: string;
 };
-type CharacteristicsByName = {
+declare type CharacteristicsByName = {
     [name: string]: Characteristic;
 };
-type Options = {
+declare type Options = {
     BleManager: BleManager;
     bleManagerEmitter: NativeEventEmitter;
     platform: PlatformOSType;
     autoConnect?: boolean;
 };
-type BleManagerEvents = {
+declare type BleManagerEvents = {
     stopScan$: Observable<void>;
     discoverPeripheral$: Observable<Peripheral>;
     connectPeripheral$: Observable<void>;