@onekeyfe/hd-transport-react-native 0.0.1

package/README.md

@@ -0,0 +1,11 @@
+# `hd-transport-react-native`
+
+> TODO: description
+
+## Usage
+
+```
+const hdTransportReactNative = require('hd-transport-react-native');
+
+// TODO: DEMONSTRATE API
+```

package/dist/BleManager.d.ts

@@ -0,0 +1,11 @@
+export declare const initializeBleManager: () => void;
+export declare const getConnectedDeviceIds: (serviceUuids: string[]) => Promise<{
+    isConnectable?: boolean | undefined;
+    localName?: string | undefined;
+    manufacturerData?: any;
+    serviceUUIDs?: string[] | undefined;
+    txPowerLevel?: number | undefined;
+    id: string;
+    name: string | undefined;
+}[]>;
+//# sourceMappingURL=BleManager.d.ts.map

package/dist/BleManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BleManager.d.ts","sourceRoot":"","sources":["../src/BleManager.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,oBAAoB,YAEhC,CAAC;AAOF,eAAO,MAAM,qBAAqB,iBAAwB,MAAM,EAAE;;;;;;;;IAMjE,CAAC"}

package/dist/BleTransport.d.ts

@@ -0,0 +1,11 @@
+import { Device, Characteristic } from 'react-native-ble-plx';
+export default class BleTransport {
+    id: string;
+    device: Device;
+    mtuSize: number;
+    writeCharacteristic: Characteristic;
+    notifyCharacteristic: Characteristic;
+    nofitySubscription?: () => void;
+    constructor(device: Device, writeCharacteristic: Characteristic, notifyCharacteristic: Characteristic);
+}
+//# sourceMappingURL=BleTransport.d.ts.map

package/dist/BleTransport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BleTransport.d.ts","sourceRoot":"","sources":["../src/BleTransport.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAE9D,MAAM,CAAC,OAAO,OAAO,YAAY;IAC/B,EAAE,EAAE,MAAM,CAAC;IAEX,MAAM,EAAE,MAAM,CAAC;IAEf,OAAO,SAAM;IAEb,mBAAmB,EAAE,cAAc,CAAC;IAEpC,oBAAoB,EAAE,cAAc,CAAC;IAErC,kBAAkB,CAAC,EAAE,MAAM,IAAI,CAAC;gBAG9B,MAAM,EAAE,MAAM,EACd,mBAAmB,EAAE,cAAc,EACnC,oBAAoB,EAAE,cAAc;CAQvC"}

package/dist/constants.d.ts

@@ -0,0 +1,8 @@
+export declare const isOnekeyDevice: (name: string | null, id?: string | undefined) => boolean;
+export declare const getBluetoothServiceUuids: () => string[];
+export declare const getInfosForServiceUuid: (serviceUuid: string, deviceType: 'classic') => {
+    serviceUuid: string;
+    writeUuid?: string | undefined;
+    notifyUuid?: string | undefined;
+} | null;
+//# sourceMappingURL=constants.d.ts.map

package/dist/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,cAAc,SAAU,MAAM,GAAG,IAAI,8BAAgB,OAYjE,CAAC;AA8BF,eAAO,MAAM,wBAAwB,gBAA0B,CAAC;AAChE,eAAO,MAAM,sBAAsB,gBAAiB,MAAM,cAAc,SAAS;iBA1BhE,MAAM;;;QAoCtB,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,39 @@
+import transport from '@onekeyfe/hd-transport';
+import { Device, Characteristic } from 'react-native-ble-plx';
+
+declare type Deferred<T, I = any, D = any> = {
+    id?: I;
+    data?: D;
+    promise: Promise<T>;
+    resolve: (t: T) => void;
+    reject: (e: Error) => void;
+};
+
+declare type TransportOptions = {
+    scanTimeout?: number;
+};
+declare type BleAcquireInput = {
+    uuid: string;
+};
+
+declare class ReactNativeBleTransport {
+    _messages: ReturnType<typeof transport.parseConfigure> | undefined;
+    configured: boolean;
+    stopped: boolean;
+    scanTimeout: number;
+    runPromise: Deferred<any> | null;
+    constructor(options: TransportOptions);
+    init(): void;
+    configure(signedData: any): void;
+    listen(): void;
+    enumerate(): Promise<Device[]>;
+    acquire(input: BleAcquireInput): Promise<{
+        uuid: string;
+    }>;
+    _monitorCharacteristic(characteristic: Characteristic): () => void;
+    release(uuid: string): Promise<boolean>;
+    call(uuid: string, name: string, data: Record<string, unknown>): Promise<any>;
+    stop(): void;
+}
+
+export { ReactNativeBleTransport as default };

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,SAAS,MAAM,wBAAwB,CAAC;AAC/C,OAAO,EAEL,MAAM,EAEN,cAAc,EAEf,MAAM,sBAAsB,CAAC;AAI9B,OAAO,EAAE,QAAQ,EAA4B,MAAM,kBAAkB,CAAC;AAItE,OAAO,KAAK,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAqBjE,MAAM,CAAC,OAAO,OAAO,uBAAuB;IAC1C,SAAS,EAAE,UAAU,CAAC,OAAO,SAAS,CAAC,cAAc,CAAC,GAAG,SAAS,CAAC;IAEnE,UAAU,UAAS;IAEnB,OAAO,UAAS;IAEhB,WAAW,SAAQ;IAEnB,UAAU,EAAE,QAAQ,CAAC,GAAG,CAAC,GAAG,IAAI,CAAQ;gBAE5B,OAAO,EAAE,gBAAgB;IAIrC,IAAI;IAIJ,SAAS,CAAC,UAAU,EAAE,GAAG;IAMzB,MAAM;IASA,SAAS;IA2DT,OAAO,CAAC,KAAK,EAAE,eAAe;;;IAiJpC,sBAAsB,CAAC,cAAc,EAAE,cAAc;IA8C/C,OAAO,CAAC,IAAI,EAAE,MAAM;IAepB,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IA0DpE,IAAI;CAGL"}

package/dist/index.js

@@ -0,0 +1,487 @@
+'use strict';
+
+var buffer = require('buffer');
+var transport = require('@onekeyfe/hd-transport');
+var reactNativeBlePlx = require('react-native-ble-plx');
+var BleManager = require('react-native-ble-manager');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var transport__default = /*#__PURE__*/_interopDefaultLegacy(transport);
+var BleManager__default = /*#__PURE__*/_interopDefaultLegacy(BleManager);
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+
+function __awaiter(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());
+    });
+}
+
+const initializeBleManager = () => {
+    BleManager__default["default"].start({ showAlert: false });
+};
+const getConnectedDeviceIds = (serviceUuids) => __awaiter(void 0, void 0, void 0, function* () {
+    const connectedPeripherals = yield BleManager__default["default"].getConnectedPeripherals(serviceUuids);
+    return connectedPeripherals.map(peripheral => {
+        const { id, name, advertising = {} } = peripheral;
+        return Object.assign({ id, name }, advertising);
+    });
+});
+
+const timer = process.env.NODE_ENV === 'development'
+    ? {
+        timeout: (fn, ms) => {
+            const startTime = Date.now();
+            const interval = setInterval(() => {
+                if (Date.now() - startTime >= ms) {
+                    clearInterval(interval);
+                    fn();
+                }
+            }, 100);
+            return () => {
+                clearInterval(interval);
+            };
+        },
+    }
+    : {
+        timeout: (fn, ms) => {
+            const timeout = setTimeout(fn, ms);
+            return () => clearTimeout(timeout);
+        },
+    };
+
+const subscribeBleOn = (bleManager, ms = 3000) => new Promise((resolve, reject) => {
+    let done = false;
+    let lastState = 'Unknown';
+    const subscription = bleManager.onStateChange(state => {
+        lastState = state;
+        console.log('ble state -> ', state);
+        if (state === 'PoweredOn') {
+            if (done)
+                return;
+            clearTimeout();
+            done = true;
+            subscription.remove();
+            resolve();
+        }
+    }, true);
+    const clearTimeout = timer.timeout(() => {
+        if (done)
+            return;
+        subscription.remove();
+        reject(new Error(`Bluetooth required to be turned ${lastState}`));
+    }, ms);
+});
+
+const isOnekeyDevice = (name, id) => {
+    var _a;
+    if ((_a = id === null || id === void 0 ? void 0 : id.startsWith) === null || _a === void 0 ? void 0 : _a.call(id, 'MI')) {
+        return true;
+    }
+    const re = /(BixinKey\d{10})|(K\d{4})/i;
+    if (name && re.exec(name)) {
+        return true;
+    }
+    return false;
+};
+const ClassicServiceUUID = '00000001-0000-1000-8000-00805f9b34fb';
+const OneKeyServices = {
+    classic: {
+        [ClassicServiceUUID]: {
+            serviceUuid: ClassicServiceUUID,
+            writeUuid: '00000002-0000-1000-8000-00805f9b34fb',
+            notifyUuid: '00000003-0000-1000-8000-00805f9b34fb',
+        },
+    },
+};
+const bluetoothServices = [];
+for (const deviceType of Object.keys(OneKeyServices)) {
+    const services = OneKeyServices[deviceType];
+    bluetoothServices.push(...Object.keys(services));
+}
+const getBluetoothServiceUuids = () => bluetoothServices;
+const getInfosForServiceUuid = (serviceUuid, deviceType) => {
+    const services = OneKeyServices[deviceType];
+    if (!services) {
+        return null;
+    }
+    const service = services[serviceUuid];
+    if (!service) {
+        return null;
+    }
+    return service;
+};
+
+function create(arg, data) {
+    let localResolve = (_t) => { };
+    let localReject = (_e) => { };
+    let id;
+    const promise = new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+        localResolve = resolve;
+        localReject = reject;
+        if (typeof arg === 'function') {
+            try {
+                yield arg();
+            }
+            catch (error) {
+                reject(error);
+            }
+        }
+        if (typeof arg === 'string')
+            id = arg;
+    }));
+    return {
+        id,
+        data,
+        resolve: localResolve,
+        reject: localReject,
+        promise,
+    };
+}
+
+const isHeaderChunk = (chunk) => {
+    if (chunk.length < 9)
+        return false;
+    const [MagicQuestionMark, sharp1, sharp2] = chunk;
+    if (String.fromCharCode(MagicQuestionMark) === String.fromCharCode(transport.MESSAGE_TOP_CHAR) &&
+        String.fromCharCode(sharp1) === String.fromCharCode(transport.MESSAGE_HEADER_BYTE) &&
+        String.fromCharCode(sharp2) === String.fromCharCode(transport.MESSAGE_HEADER_BYTE)) {
+        return true;
+    }
+    return false;
+};
+
+class BleTransport {
+    constructor(device, writeCharacteristic, notifyCharacteristic) {
+        this.mtuSize = 20;
+        this.id = device.id;
+        this.device = device;
+        this.writeCharacteristic = writeCharacteristic;
+        this.notifyCharacteristic = notifyCharacteristic;
+        console.log(`BleTransport(${String(this.id)}) new instance`);
+    }
+}
+
+const { check, buildBuffer, receiveOne, parseConfigure } = transport__default["default"];
+const blePlxManager = new reactNativeBlePlx.BleManager();
+const transportCache = {};
+let connectOptions = {
+    requestMTU: 1500,
+    timeout: 3000,
+};
+const tryToGetConfiguration = (device) => {
+    if (!device || !device.serviceUUIDs)
+        return null;
+    const [serviceUUID] = device.serviceUUIDs;
+    const infos = getInfosForServiceUuid(serviceUUID, 'classic');
+    if (!infos)
+        return null;
+    return infos;
+};
+class ReactNativeBleTransport {
+    constructor(options) {
+        var _a;
+        this.configured = false;
+        this.stopped = false;
+        this.scanTimeout = 3000;
+        this.runPromise = null;
+        this.scanTimeout = (_a = options.scanTimeout) !== null && _a !== void 0 ? _a : 3000;
+    }
+    init() {
+        initializeBleManager();
+    }
+    configure(signedData) {
+        const messages = parseConfigure(signedData);
+        this.configured = true;
+        this._messages = messages;
+    }
+    listen() {
+    }
+    enumerate() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve) => __awaiter(this, void 0, void 0, function* () {
+                const deviceList = [];
+                try {
+                    yield subscribeBleOn(blePlxManager);
+                }
+                catch (error) {
+                    console.log('subscribeBleOn error: ', error);
+                    resolve([]);
+                    return;
+                }
+                blePlxManager.startDeviceScan(null, {
+                    scanMode: reactNativeBlePlx.ScanMode.LowLatency,
+                }, (error, device) => {
+                    var _a;
+                    if (error) {
+                        console.log('ble scan manager: ', blePlxManager);
+                        console.log('ble scan error: ', error);
+                        return;
+                    }
+                    if (isOnekeyDevice((_a = device === null || device === void 0 ? void 0 : device.name) !== null && _a !== void 0 ? _a : null, device === null || device === void 0 ? void 0 : device.id)) {
+                        console.log('search device start ======================');
+                        const { name, localName, id } = device !== null && device !== void 0 ? device : {};
+                        console.log(`device name: ${name !== null && name !== void 0 ? name : ''}\nlocalName: ${localName !== null && localName !== void 0 ? localName : ''}\nid: ${id !== null && id !== void 0 ? id : ''}`);
+                        addDevice(device);
+                        console.log('search device end ======================\n');
+                    }
+                });
+                getConnectedDeviceIds(getBluetoothServiceUuids()).then(devices => {
+                    for (const device of devices) {
+                        console.log('search connected peripheral: ', device.id);
+                        addDevice(device);
+                    }
+                });
+                const addDevice = (device) => {
+                    if (deviceList.every(d => d.id !== device.id)) {
+                        deviceList.push(device);
+                    }
+                };
+                timer.timeout(() => {
+                    blePlxManager.stopDeviceScan();
+                    resolve(deviceList);
+                }, this.scanTimeout);
+            }));
+        });
+    }
+    acquire(input) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { uuid } = input;
+            if (!uuid) {
+                throw new Error('uuid is required');
+            }
+            let device;
+            if (transportCache[uuid]) {
+                console.log('@onekey/hd-ble-sdk transport not be released, will release: ', uuid);
+                yield this.release(uuid);
+            }
+            try {
+                yield subscribeBleOn(blePlxManager);
+            }
+            catch (error) {
+                console.log('subscribeBleOn error: ', error);
+                throw error;
+            }
+            if (!device) {
+                const devices = yield blePlxManager.devices([uuid]);
+                [device] = devices;
+            }
+            if (!device) {
+                const connectedDevice = yield blePlxManager.connectedDevices(getBluetoothServiceUuids());
+                const deviceFilter = connectedDevice.filter(device => device.id === uuid);
+                console.log(`found connected device count: ${deviceFilter.length}`);
+                [device] = deviceFilter;
+            }
+            if (!device) {
+                console.log('try to connect to device: ', uuid);
+                try {
+                    device = yield blePlxManager.connectToDevice(uuid, connectOptions);
+                }
+                catch (e) {
+                    console.log('try to connect to device has error: ', e);
+                    if (e.errorCode === reactNativeBlePlx.BleErrorCode.DeviceMTUChangeFailed ||
+                        e.errorCode === reactNativeBlePlx.BleErrorCode.OperationCancelled) {
+                        connectOptions = {};
+                        device = yield blePlxManager.connectToDevice(uuid);
+                    }
+                    else {
+                        throw e;
+                    }
+                }
+            }
+            if (!device) {
+                throw new Error('unable to connect to device');
+            }
+            if (!(yield device.isConnected())) {
+                console.log('not connected, try to connect to device: ', uuid);
+                try {
+                    yield device.connect(connectOptions);
+                }
+                catch (e) {
+                    console.log('try to connect to device has error: ', e);
+                    if (e.errorCode === reactNativeBlePlx.BleErrorCode.DeviceMTUChangeFailed ||
+                        e.errorCode === reactNativeBlePlx.BleErrorCode.OperationCancelled) {
+                        connectOptions = {};
+                        yield device.connect();
+                    }
+                    else {
+                        throw e;
+                    }
+                }
+            }
+            yield device.discoverAllServicesAndCharacteristics();
+            let infos = tryToGetConfiguration(device);
+            let characteristics;
+            if (!infos) {
+                for (const serviceUuid of getBluetoothServiceUuids()) {
+                    try {
+                        characteristics = yield device.characteristicsForService(serviceUuid);
+                        infos = getInfosForServiceUuid(serviceUuid, 'classic');
+                        break;
+                    }
+                    catch (e) {
+                    }
+                }
+            }
+            if (!infos) {
+                throw new Error('BLEServiceNotFound: service not found');
+            }
+            const { serviceUuid, writeUuid, notifyUuid } = infos;
+            if (!characteristics) {
+                characteristics = yield device.characteristicsForService(serviceUuid);
+            }
+            if (!characteristics) {
+                throw new Error('BLEServiceNotFound: characteristics not found');
+            }
+            let writeCharacteristic;
+            let notifyCharacteristic;
+            for (const c of characteristics) {
+                if (c.uuid === writeUuid) {
+                    writeCharacteristic = c;
+                }
+                else if (c.uuid === notifyUuid) {
+                    notifyCharacteristic = c;
+                }
+            }
+            if (!writeCharacteristic) {
+                throw new Error('BLECharacteristicNotFound: write characteristic not found');
+            }
+            if (!notifyCharacteristic) {
+                throw new Error('BLECharacteristicNotFound: notify characteristic not found');
+            }
+            if (!writeCharacteristic.isWritableWithResponse) {
+                throw new Error('BLECharacteristicNotWritable: write characteristic not writable');
+            }
+            if (!notifyCharacteristic.isNotifiable) {
+                throw new Error('BLECharacteristicNotNotifiable: notify characteristic not notifiable');
+            }
+            const transport = new BleTransport(device, writeCharacteristic, notifyCharacteristic);
+            transport.nofitySubscription = this._monitorCharacteristic(transport.notifyCharacteristic);
+            transportCache[uuid] = transport;
+            device.onDisconnected(() => {
+                this.release(uuid);
+            });
+            return { uuid };
+        });
+    }
+    _monitorCharacteristic(characteristic) {
+        let bufferLength = 0;
+        let buffer$1 = [];
+        const subscription = characteristic.monitor((error, c) => {
+            var _a, _b;
+            if (error) {
+                console.log(`error monitor ${characteristic.uuid}: ${error}`);
+                return;
+            }
+            if (!c) {
+                throw new Error('Monitor Error: characteristic not found');
+            }
+            try {
+                const data = buffer.Buffer.from(c.value, 'base64');
+                if (isHeaderChunk(data)) {
+                    bufferLength = data.readInt32BE(5);
+                    buffer$1 = [...data.subarray(3)];
+                }
+                else {
+                    buffer$1 = buffer$1.concat([...data]);
+                }
+                if (buffer$1.length >= bufferLength) {
+                    const value = buffer.Buffer.from(buffer$1);
+                    console.log('[hd-transport-react-native] Received a complete packet of data, resolve Promise, this.runPromise: ', this.runPromise, 'buffer: ', value);
+                    bufferLength = 0;
+                    buffer$1 = [];
+                    (_a = this.runPromise) === null || _a === void 0 ? void 0 : _a.resolve(value.toString('hex'));
+                }
+            }
+            catch (error) {
+                console.log('monitor data error: ', error);
+                (_b = this.runPromise) === null || _b === void 0 ? void 0 : _b.reject(error);
+            }
+        });
+        return () => {
+            console.log('remove characteristic monitor: ', characteristic.uuid);
+            subscription.remove();
+        };
+    }
+    release(uuid) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const transport = transportCache[uuid];
+            if (transport) {
+                delete transportCache[uuid];
+                (_a = transport.nofitySubscription) === null || _a === void 0 ? void 0 : _a.call(transport);
+            }
+            return Promise.resolve(true);
+        });
+    }
+    call(uuid, name, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.stopped) {
+                return Promise.reject('Transport stopped.');
+            }
+            if (this._messages == null) {
+                throw new Error('Transport not configured.');
+            }
+            if (this.runPromise) {
+                throw new Error('Transport_CallInProgress');
+            }
+            const transport = transportCache[uuid];
+            if (!transport) {
+                throw new Error('Transport not found.');
+            }
+            this.runPromise = create();
+            const messages = this._messages;
+            console.log('transport-react-native', 'call-', 'messages: ', messages, ' name: ', name, ' data: ', data);
+            const o = buildBuffer(messages, name, data);
+            console.log('@onekey/hd-ble-sdk send hex strting: ', o.toString('hex'));
+            const outData = o.toString('base64');
+            try {
+                yield transport.writeCharacteristic.writeWithResponse(outData);
+            }
+            catch (e) {
+                this.runPromise = null;
+                console.log('writeCharacteristic write error: ', e);
+                return;
+            }
+            try {
+                const response = yield this.runPromise.promise;
+                if (typeof response !== 'string') {
+                    throw new Error('Returning data is not string.');
+                }
+                console.log('@onekey/hd-ble-sdk receive data: ', response);
+                const jsonData = receiveOne(messages, response);
+                return check.call(jsonData);
+            }
+            catch (e) {
+                console.log('call error: ', e);
+                return e;
+            }
+            finally {
+                this.runPromise = null;
+            }
+        });
+    }
+    stop() {
+        this.stopped = true;
+    }
+}
+
+module.exports = ReactNativeBleTransport;

package/dist/subscribeBleOn.d.ts

@@ -0,0 +1,3 @@
+import { BlePlxManager } from './types';
+export declare const subscribeBleOn: (bleManager: BlePlxManager, ms?: number) => Promise<void>;
+//# sourceMappingURL=subscribeBleOn.d.ts.map

package/dist/subscribeBleOn.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subscribeBleOn.d.ts","sourceRoot":"","sources":["../src/subscribeBleOn.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAGxC,eAAO,MAAM,cAAc,eAAgB,aAAa,kBAAc,QAAQ,IAAI,CAwB9E,CAAC"}

package/dist/types.d.ts

@@ -0,0 +1,8 @@
+export type { BleManager as BlePlxManager } from 'react-native-ble-plx';
+export declare type TransportOptions = {
+    scanTimeout?: number;
+};
+export declare type BleAcquireInput = {
+    uuid: string;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,UAAU,IAAI,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAExE,oBAAY,gBAAgB,GAAG;IAC7B,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF,oBAAY,eAAe,GAAG;IAC5B,IAAI,EAAE,MAAM,CAAC;CACd,CAAC"}

package/dist/utils/deferred.d.ts

@@ -0,0 +1,9 @@
+export declare type Deferred<T, I = any, D = any> = {
+    id?: I;
+    data?: D;
+    promise: Promise<T>;
+    resolve: (t: T) => void;
+    reject: (e: Error) => void;
+};
+export declare function create<T, I = any, D = any>(arg?: I, data?: D): Deferred<T, I, D>;
+//# sourceMappingURL=deferred.d.ts.map

package/dist/utils/deferred.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deferred.d.ts","sourceRoot":"","sources":["../../src/utils/deferred.ts"],"names":[],"mappings":"AAAA,oBAAY,QAAQ,CAAC,CAAC,EAAE,CAAC,GAAG,GAAG,EAAE,CAAC,GAAG,GAAG,IAAI;IAC1C,EAAE,CAAC,EAAE,CAAC,CAAC;IACP,IAAI,CAAC,EAAE,CAAC,CAAC;IACT,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC;IACpB,OAAO,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,IAAI,CAAC;IACxB,MAAM,EAAE,CAAC,CAAC,EAAE,KAAK,KAAK,IAAI,CAAC;CAC5B,CAAC;AAEF,wBAAgB,MAAM,CAAC,CAAC,EAAE,CAAC,GAAG,GAAG,EAAE,CAAC,GAAG,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,EAAE,IAAI,CAAC,EAAE,CAAC,GAAG,QAAQ,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CA0BhF"}

package/dist/utils/timer.d.ts

@@ -0,0 +1,5 @@
+declare const timer: {
+    timeout: (fn: (...args: Array<any>) => any, ms: number) => () => void;
+};
+export default timer;
+//# sourceMappingURL=timer.d.ts.map

package/dist/utils/timer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timer.d.ts","sourceRoot":"","sources":["../../src/utils/timer.ts"],"names":[],"mappings":"AAAA,QAAA,MAAM,KAAK;4BAGqB,MAAM,GAAG,CAAC,KAAK,GAAG,MAAM,MAAM;CAkBvD,CAAC;AAER,eAAe,KAAK,CAAC"}

package/dist/utils/validateNotify.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="node" />
+export declare const isHeaderChunk: (chunk: Buffer) => boolean;
+//# sourceMappingURL=validateNotify.d.ts.map

package/dist/utils/validateNotify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validateNotify.d.ts","sourceRoot":"","sources":["../../src/utils/validateNotify.ts"],"names":[],"mappings":";AAEA,eAAO,MAAM,aAAa,UAAW,MAAM,KAAG,OAa7C,CAAC"}

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@onekeyfe/hd-transport-react-native",
+  "version": "0.0.1",
+  "homepage": "https://github.com/OneKeyHQ/hardware-js-sdk#readme",
+  "license": "MIT",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/OneKeyHQ/hardware-js-sdk.git"
+  },
+  "scripts": {
+    "test": "echo \"Error: run tests from root\" && exit 1",
+    "build": "rimraf dist && rollup -c ../../build/rollup.config.js",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix"
+  },
+  "dependencies": {
+    "@onekeyfe/hd-transport": "^0.0.1",
+    "react-native-ble-manager": "^8.1.0",
+    "react-native-ble-plx": "^2.0.3"
+  },
+  "gitHead": "af17c6b173176bd015b5c9dad3b1d20a734dd49b"
+}

package/src/BleManager.ts

@@ -0,0 +1,18 @@
+import BleManager from 'react-native-ble-manager';
+
+export const initializeBleManager = () => {
+  BleManager.start({ showAlert: false });
+};
+
+/**
+ * get the device basic info of connected devices
+ * @param serviceUuids
+ * @returns {Promise<[string[]]>}
+ */
+export const getConnectedDeviceIds = async (serviceUuids: string[]) => {
+  const connectedPeripherals = await BleManager.getConnectedPeripherals(serviceUuids);
+  return connectedPeripherals.map(peripheral => {
+    const { id, name, advertising = {} } = peripheral;
+    return { id, name, ...advertising };
+  });
+};

package/src/BleTransport.ts

@@ -0,0 +1,27 @@
+import { Device, Characteristic } from 'react-native-ble-plx';
+
+export default class BleTransport {
+  id: string;
+
+  device: Device;
+
+  mtuSize = 20;
+
+  writeCharacteristic: Characteristic;
+
+  notifyCharacteristic: Characteristic;
+
+  nofitySubscription?: () => void;
+
+  constructor(
+    device: Device,
+    writeCharacteristic: Characteristic,
+    notifyCharacteristic: Characteristic
+  ) {
+    this.id = device.id;
+    this.device = device;
+    this.writeCharacteristic = writeCharacteristic;
+    this.notifyCharacteristic = notifyCharacteristic;
+    console.log(`BleTransport(${String(this.id)}) new instance`);
+  }
+}

package/src/constants.ts

@@ -0,0 +1,54 @@
+export const isOnekeyDevice = (name: string | null, id?: string): boolean => {
+  if (id?.startsWith?.('MI')) {
+    return true;
+  }
+
+  // 过滤 BixinKeyxxx 和 Kxxxx
+  // i 忽略大小写模式
+  const re = /(BixinKey\d{10})|(K\d{4})/i;
+  if (name && re.exec(name)) {
+    return true;
+  }
+  return false;
+};
+
+type BluetoothServices = Record<
+  string,
+  {
+    serviceUuid: string;
+    writeUuid?: string;
+    notifyUuid?: string;
+  }
+>;
+
+const ClassicServiceUUID = '00000001-0000-1000-8000-00805f9b34fb';
+
+const OneKeyServices: Record<string, BluetoothServices> = {
+  classic: {
+    [ClassicServiceUUID]: {
+      serviceUuid: ClassicServiceUUID,
+      writeUuid: '00000002-0000-1000-8000-00805f9b34fb',
+      notifyUuid: '00000003-0000-1000-8000-00805f9b34fb',
+    },
+  },
+};
+
+const bluetoothServices: string[] = [];
+
+for (const deviceType of Object.keys(OneKeyServices)) {
+  const services = OneKeyServices[deviceType];
+  bluetoothServices.push(...Object.keys(services));
+}
+
+export const getBluetoothServiceUuids = () => bluetoothServices;
+export const getInfosForServiceUuid = (serviceUuid: string, deviceType: 'classic') => {
+  const services = OneKeyServices[deviceType];
+  if (!services) {
+    return null;
+  }
+  const service = services[serviceUuid];
+  if (!service) {
+    return null;
+  }
+  return service;
+};

package/src/index.ts

@@ -0,0 +1,398 @@
+import { Buffer } from 'buffer';
+import transport from '@onekeyfe/hd-transport';
+import {
+  BleManager as BlePlxManager,
+  Device,
+  BleErrorCode,
+  Characteristic,
+  ScanMode,
+} from 'react-native-ble-plx';
+import { initializeBleManager, getConnectedDeviceIds } from './BleManager';
+import { subscribeBleOn } from './subscribeBleOn';
+import { isOnekeyDevice, getBluetoothServiceUuids, getInfosForServiceUuid } from './constants';
+import { Deferred, create as createDeferred } from './utils/deferred';
+import { isHeaderChunk } from './utils/validateNotify';
+import BleTransport from './BleTransport';
+import timer from './utils/timer';
+import type { BleAcquireInput, TransportOptions } from './types';
+
+const { check, buildBuffer, receiveOne, parseConfigure } = transport;
+
+const blePlxManager = new BlePlxManager();
+
+const transportCache: Record<string, any> = {};
+
+let connectOptions: Record<string, unknown> = {
+  requestMTU: 1500,
+  timeout: 3000,
+};
+
+const tryToGetConfiguration = (device: Device) => {
+  if (!device || !device.serviceUUIDs) return null;
+  const [serviceUUID] = device.serviceUUIDs;
+  const infos = getInfosForServiceUuid(serviceUUID, 'classic');
+  if (!infos) return null;
+  return infos;
+};
+
+export default class ReactNativeBleTransport {
+  _messages: ReturnType<typeof transport.parseConfigure> | undefined;
+
+  configured = false;
+
+  stopped = false;
+
+  scanTimeout = 3000;
+
+  runPromise: Deferred<any> | null = null;
+
+  constructor(options: TransportOptions) {
+    this.scanTimeout = options.scanTimeout ?? 3000;
+  }
+
+  init() {
+    initializeBleManager();
+  }
+
+  configure(signedData: any) {
+    const messages = parseConfigure(signedData);
+    this.configured = true;
+    this._messages = messages;
+  }
+
+  listen() {
+    // empty
+  }
+
+  /**
+   * 获取设备列表
+   * 在搜索超过超时时间或设备数量大于 5 台时，返回 OneKey 设备，
+   * @returns
+   */
+  async enumerate() {
+    // eslint-disable-next-line no-async-promise-executor
+    return new Promise<Device[]>(async resolve => {
+      const deviceList: Device[] = [];
+
+      try {
+        await subscribeBleOn(blePlxManager);
+      } catch (error) {
+        console.log('subscribeBleOn error: ', error);
+        resolve([]);
+        return;
+      }
+
+      blePlxManager.startDeviceScan(
+        null,
+        {
+          scanMode: ScanMode.LowLatency,
+        },
+        (error, device) => {
+          if (error) {
+            console.log('ble scan manager: ', blePlxManager);
+            console.log('ble scan error: ', error);
+            return;
+          }
+
+          if (isOnekeyDevice(device?.name ?? null, device?.id)) {
+            console.log('search device start ======================');
+
+            const { name, localName, id } = device ?? {};
+            console.log(
+              `device name: ${name ?? ''}\nlocalName: ${localName ?? ''}\nid: ${id ?? ''}`
+            );
+            addDevice(device as unknown as Device);
+
+            console.log('search device end ======================\n');
+          }
+        }
+      );
+
+      getConnectedDeviceIds(getBluetoothServiceUuids()).then(devices => {
+        for (const device of devices) {
+          console.log('search connected peripheral: ', device.id);
+          addDevice(device as unknown as Device);
+        }
+      });
+
+      const addDevice = (device: Device) => {
+        if (deviceList.every(d => d.id !== device.id)) {
+          deviceList.push(device);
+        }
+      };
+
+      timer.timeout(() => {
+        blePlxManager.stopDeviceScan();
+        resolve(deviceList);
+      }, this.scanTimeout);
+    });
+  }
+
+  async acquire(input: BleAcquireInput) {
+    const { uuid } = input;
+
+    if (!uuid) {
+      throw new Error('uuid is required');
+    }
+
+    let device;
+
+    if (transportCache[uuid]) {
+      /**
+       * If the transport is not released due to an exception operation
+       * it will be handled again here
+       */
+      console.log('@onekey/hd-ble-sdk transport not be released, will release: ', uuid);
+      await this.release(uuid);
+    }
+
+    try {
+      await subscribeBleOn(blePlxManager);
+    } catch (error) {
+      console.log('subscribeBleOn error: ', error);
+      throw error;
+    }
+
+    if (!device) {
+      const devices = await blePlxManager.devices([uuid]);
+      [device] = devices;
+    }
+
+    if (!device) {
+      const connectedDevice = await blePlxManager.connectedDevices(getBluetoothServiceUuids());
+      const deviceFilter = connectedDevice.filter(device => device.id === uuid);
+      console.log(`found connected device count: ${deviceFilter.length}`);
+      [device] = deviceFilter;
+    }
+
+    if (!device) {
+      console.log('try to connect to device: ', uuid);
+      try {
+        device = await blePlxManager.connectToDevice(uuid, connectOptions);
+      } catch (e) {
+        console.log('try to connect to device has error: ', e);
+        if (
+          e.errorCode === BleErrorCode.DeviceMTUChangeFailed ||
+          e.errorCode === BleErrorCode.OperationCancelled
+        ) {
+          connectOptions = {};
+          device = await blePlxManager.connectToDevice(uuid);
+        } else {
+          throw e;
+        }
+      }
+    }
+
+    if (!device) {
+      throw new Error('unable to connect to device');
+    }
+
+    if (!(await device.isConnected())) {
+      console.log('not connected, try to connect to device: ', uuid);
+
+      try {
+        await device.connect(connectOptions);
+      } catch (e) {
+        console.log('try to connect to device has error: ', e);
+        if (
+          e.errorCode === BleErrorCode.DeviceMTUChangeFailed ||
+          e.errorCode === BleErrorCode.OperationCancelled
+        ) {
+          connectOptions = {};
+          await device.connect();
+        } else {
+          throw e;
+        }
+      }
+    }
+
+    await device.discoverAllServicesAndCharacteristics();
+    let infos = tryToGetConfiguration(device);
+    let characteristics;
+
+    if (!infos) {
+      for (const serviceUuid of getBluetoothServiceUuids()) {
+        try {
+          characteristics = await device.characteristicsForService(serviceUuid);
+          infos = getInfosForServiceUuid(serviceUuid, 'classic');
+          break;
+        } catch (e) {
+          // empty
+        }
+      }
+    }
+
+    if (!infos) {
+      throw new Error('BLEServiceNotFound: service not found');
+    }
+
+    const { serviceUuid, writeUuid, notifyUuid } = infos;
+
+    if (!characteristics) {
+      characteristics = await device.characteristicsForService(serviceUuid);
+    }
+
+    if (!characteristics) {
+      throw new Error('BLEServiceNotFound: characteristics not found');
+    }
+
+    let writeCharacteristic;
+    let notifyCharacteristic;
+    for (const c of characteristics) {
+      if (c.uuid === writeUuid) {
+        writeCharacteristic = c;
+      } else if (c.uuid === notifyUuid) {
+        notifyCharacteristic = c;
+      }
+    }
+
+    if (!writeCharacteristic) {
+      throw new Error('BLECharacteristicNotFound: write characteristic not found');
+    }
+
+    if (!notifyCharacteristic) {
+      throw new Error('BLECharacteristicNotFound: notify characteristic not found');
+    }
+
+    if (!writeCharacteristic.isWritableWithResponse) {
+      throw new Error('BLECharacteristicNotWritable: write characteristic not writable');
+    }
+
+    if (!notifyCharacteristic.isNotifiable) {
+      throw new Error('BLECharacteristicNotNotifiable: notify characteristic not notifiable');
+    }
+
+    const transport = new BleTransport(device, writeCharacteristic, notifyCharacteristic);
+    transport.nofitySubscription = this._monitorCharacteristic(transport.notifyCharacteristic);
+    transportCache[uuid] = transport;
+
+    device.onDisconnected(() => {
+      this.release(uuid);
+    });
+
+    return { uuid };
+  }
+
+  _monitorCharacteristic(characteristic: Characteristic) {
+    let bufferLength = 0;
+    let buffer: any[] = [];
+    const subscription = characteristic.monitor((error, c) => {
+      if (error) {
+        console.log(`error monitor ${characteristic.uuid}: ${error as unknown as string}`);
+        return;
+      }
+
+      if (!c) {
+        throw new Error('Monitor Error: characteristic not found');
+      }
+
+      try {
+        const data = Buffer.from(c.value as string, 'base64');
+        if (isHeaderChunk(data)) {
+          bufferLength = data.readInt32BE(5);
+          buffer = [...data.subarray(3)];
+        } else {
+          buffer = buffer.concat([...data]);
+        }
+
+        if (buffer.length >= bufferLength) {
+          const value = Buffer.from(buffer);
+          console.log(
+            '[hd-transport-react-native] Received a complete packet of data, resolve Promise, this.runPromise: ',
+            this.runPromise,
+            'buffer: ',
+            value
+          );
+          bufferLength = 0;
+          buffer = [];
+          this.runPromise?.resolve(value.toString('hex'));
+        }
+      } catch (error) {
+        console.log('monitor data error: ', error);
+        this.runPromise?.reject(error);
+      }
+    });
+
+    return () => {
+      console.log('remove characteristic monitor: ', characteristic.uuid);
+      subscription.remove();
+    };
+  }
+
+  async release(uuid: string) {
+    const transport = transportCache[uuid];
+
+    if (transport) {
+      delete transportCache[uuid];
+      transport.nofitySubscription?.();
+    }
+
+    /**
+     * The current strategy does not require disconnection
+     */
+    // await blePlxManager.cancelDeviceConnection(uuid);
+    return Promise.resolve(true);
+  }
+
+  async call(uuid: string, name: string, data: Record<string, unknown>) {
+    if (this.stopped) {
+      // eslint-disable-next-line prefer-promise-reject-errors
+      return Promise.reject('Transport stopped.');
+    }
+    if (this._messages == null) {
+      throw new Error('Transport not configured.');
+    }
+
+    if (this.runPromise) {
+      throw new Error('Transport_CallInProgress');
+    }
+
+    const transport = transportCache[uuid] as BleTransport;
+    if (!transport) {
+      throw new Error('Transport not found.');
+    }
+
+    this.runPromise = createDeferred();
+    const messages = this._messages;
+    console.log(
+      'transport-react-native',
+      'call-',
+      'messages: ',
+      messages,
+      ' name: ',
+      name,
+      ' data: ',
+      data
+    );
+    const o = buildBuffer(messages, name, data);
+    console.log('@onekey/hd-ble-sdk send hex strting: ', o.toString('hex'));
+    const outData = o.toString('base64');
+    try {
+      await transport.writeCharacteristic.writeWithResponse(outData);
+    } catch (e) {
+      this.runPromise = null;
+      console.log('writeCharacteristic write error: ', e);
+      return;
+    }
+    try {
+      const response = await this.runPromise.promise;
+
+      if (typeof response !== 'string') {
+        throw new Error('Returning data is not string.');
+      }
+
+      console.log('@onekey/hd-ble-sdk receive data: ', response);
+      const jsonData = receiveOne(messages, response);
+      return check.call(jsonData);
+    } catch (e) {
+      console.log('call error: ', e);
+      return e;
+    } finally {
+      this.runPromise = null;
+    }
+  }
+
+  stop() {
+    this.stopped = true;
+  }
+}

package/src/subscribeBleOn.ts

@@ -0,0 +1,28 @@
+import { BlePlxManager } from './types';
+import timer from './utils/timer';
+
+export const subscribeBleOn = (bleManager: BlePlxManager, ms = 3000): Promise<void> =>
+  new Promise((resolve, reject) => {
+    let done = false;
+    let lastState = 'Unknown';
+
+    const subscription = bleManager.onStateChange(state => {
+      lastState = state;
+
+      console.log('ble state -> ', state);
+
+      if (state === 'PoweredOn') {
+        if (done) return;
+        clearTimeout();
+        done = true;
+        subscription.remove();
+        resolve();
+      }
+    }, true);
+
+    const clearTimeout = timer.timeout(() => {
+      if (done) return;
+      subscription.remove();
+      reject(new Error(`Bluetooth required to be turned ${lastState}`));
+    }, ms);
+  });

package/src/types.ts

@@ -0,0 +1,9 @@
+export type { BleManager as BlePlxManager } from 'react-native-ble-plx';
+
+export type TransportOptions = {
+  scanTimeout?: number;
+};
+
+export type BleAcquireInput = {
+  uuid: string;
+};

package/src/utils/deferred.ts

@@ -0,0 +1,35 @@
+export type Deferred<T, I = any, D = any> = {
+  id?: I;
+  data?: D;
+  promise: Promise<T>;
+  resolve: (t: T) => void;
+  reject: (e: Error) => void;
+};
+
+export function create<T, I = any, D = any>(arg?: I, data?: D): Deferred<T, I, D> {
+  let localResolve: (t: T) => void = (_t: T) => {};
+  let localReject: (e?: Error) => void = (_e?: Error) => {};
+  let id: I | undefined;
+
+  // eslint-disable-next-line no-async-promise-executor
+  const promise: Promise<T> = new Promise(async (resolve, reject) => {
+    localResolve = resolve;
+    localReject = reject;
+    if (typeof arg === 'function') {
+      try {
+        await arg();
+      } catch (error) {
+        reject(error);
+      }
+    }
+    if (typeof arg === 'string') id = arg;
+  });
+
+  return {
+    id,
+    data,
+    resolve: localResolve,
+    reject: localReject,
+    promise,
+  };
+}

package/src/utils/timer.ts

@@ -0,0 +1,24 @@
+const timer =
+  process.env.NODE_ENV === 'development'
+    ? {
+        timeout: (fn: (...args: Array<any>) => any, ms: number) => {
+          const startTime = Date.now();
+          const interval = setInterval(() => {
+            if (Date.now() - startTime >= ms) {
+              clearInterval(interval);
+              fn();
+            }
+          }, 100);
+          return () => {
+            clearInterval(interval);
+          };
+        },
+      }
+    : {
+        timeout: (fn: (...args: Array<any>) => any, ms: number) => {
+          const timeout = setTimeout(fn, ms);
+          return () => clearTimeout(timeout);
+        },
+      };
+
+export default timer;

package/src/utils/validateNotify.ts

@@ -0,0 +1,16 @@
+import { MESSAGE_TOP_CHAR, MESSAGE_HEADER_BYTE } from '@onekeyfe/hd-transport';
+
+export const isHeaderChunk = (chunk: Buffer): boolean => {
+  if (chunk.length < 9) return false;
+  const [MagicQuestionMark, sharp1, sharp2] = chunk;
+
+  if (
+    String.fromCharCode(MagicQuestionMark) === String.fromCharCode(MESSAGE_TOP_CHAR) &&
+    String.fromCharCode(sharp1) === String.fromCharCode(MESSAGE_HEADER_BYTE) &&
+    String.fromCharCode(sharp2) === String.fromCharCode(MESSAGE_HEADER_BYTE)
+  ) {
+    return true;
+  }
+
+  return false;
+};

package/tsconfig.json

@@ -0,0 +1,7 @@
+{
+  "extends": "../../tsconfig.lib.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+  },
+  "include": ["./src"]
+}