@psdk/device-ble-taro 0.2.44 → 0.2.45

package/build/connected.d.ts

@@ -0,0 +1,27 @@
+import { ConnectedDevice, ConnectionState, ReadOptions } from "@psdk/frame-father";
+import Taro from "@tarojs/taro";
+export declare class TaroBleConnectedDevice implements ConnectedDevice {
+    private device;
+    private scpair;
+    private _connectionState;
+    private dataOfRead;
+    constructor(options: {
+        device: Taro.onBluetoothDeviceFound.CallbackResultBlueToothDevice;
+        scpair: ServiceCharacteristicPair;
+    });
+    private doListen;
+    private realRead;
+    connectionState(): ConnectionState;
+    deviceName(): string;
+    disconnect(): Promise<void>;
+    canRead(): boolean;
+    read(options?: ReadOptions): Promise<Uint8Array>;
+    write(data: Uint8Array): Promise<void>;
+    flush(): void;
+}
+export interface ServiceCharacteristicPair {
+    service: Taro.getBLEDeviceServices.BLEService;
+    write: Taro.getBLEDeviceCharacteristics.BLECharacteristic;
+    read?: Taro.getBLEDeviceCharacteristics.BLECharacteristic;
+}
+//# sourceMappingURL=connected.d.ts.map

package/build/connected.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connected.d.ts","sourceRoot":"","sources":["../src/connected.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,eAAe,EAAE,eAAe,EAAE,WAAW,EAAC,MAAM,oBAAoB,CAAC;AAEjF,OAAO,IAAI,MAAM,cAAc,CAAC;AAEhC,qBAAa,sBAAuB,YAAW,eAAe;IAC5D,OAAO,CAAC,MAAM,CAA4D;IAC1E,OAAO,CAAC,MAAM,CAA4B;IAE1C,OAAO,CAAC,gBAAgB,CAAkB;IAC1C,OAAO,CAAC,UAAU,CAA4D;gBAE3D,OAAO,EAAE;QAC1B,MAAM,EAAE,IAAI,CAAC,sBAAsB,CAAC,6BAA6B,CAAC;QAClE,MAAM,EAAE,yBAAyB,CAAC;KACnC;IAQD,OAAO,CAAC,QAAQ;YAkBF,QAAQ;IAuBtB,eAAe,IAAI,eAAe;IAIlC,UAAU,IAAI,MAAM;IAId,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAejC,OAAO,IAAI,OAAO;IAIZ,IAAI,CAAC,OAAO,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,UAAU,CAAC;IAsBhD,KAAK,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;IAqB5C,KAAK,IAAI,IAAI;CAId;AAED,MAAM,WAAW,yBAAyB;IACxC,OAAO,EAAE,IAAI,CAAC,oBAAoB,CAAC,UAAU,CAAC;IAC9C,KAAK,EAAE,IAAI,CAAC,2BAA2B,CAAC,iBAAiB,CAAC;IAC1D,IAAI,CAAC,EAAE,IAAI,CAAC,2BAA2B,CAAC,iBAAiB,CAAC;CAC3D"}

package/build/connected.js

@@ -0,0 +1,143 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaroBleConnectedDevice = void 0;
+const frame_father_1 = require("@psdk/frame-father");
+const await_timeout_1 = __importDefault(require("await-timeout"));
+const taro_1 = __importDefault(require("@tarojs/taro"));
+class TaroBleConnectedDevice {
+    constructor(options) {
+        this.device = options.device;
+        this.scpair = options.scpair;
+        this._connectionState = frame_father_1.ConnectionState.CONNECTED;
+        this.dataOfRead = [];
+        this.doListen();
+    }
+    doListen() {
+        taro_1.default.onBLECharacteristicValueChange(value => {
+            this.dataOfRead.push(value);
+        });
+        taro_1.default.onBLEConnectionStateChange(value => {
+            this._connectionState = value.connected ? frame_father_1.ConnectionState.CONNECTED : frame_father_1.ConnectionState.DISCONNECTED;
+        });
+        // Taro.notifyBLECharacteristicValueChange({
+        //   deviceId: this.device.deviceId,
+        //   serviceId: this.readPair.service.uuid,
+        //   characteristicId: this.readPair.characteristic.uuid,
+        //   state: true,
+        //   success: result => console.log(result),
+        //   // @ts-ignore
+        //   fail: (e) => console.error(e),
+        // });
+    }
+    realRead() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                if (this.scpair.read == null) {
+                    reject(`the connect device not support read operation: service id: [${this.scpair.service.uuid}]`);
+                    return;
+                }
+                taro_1.default.readBLECharacteristicValue({
+                    deviceId: this.device.deviceId,
+                    serviceId: this.scpair.service.uuid,
+                    characteristicId: this.scpair.read.uuid,
+                    success: result => {
+                        if (result.errMsg.indexOf('ok') == -1) {
+                            reject(result.errMsg);
+                            return;
+                        }
+                        resolve();
+                    },
+                    // @ts-ignore
+                    fail: (e) => reject(e),
+                });
+            });
+        });
+    }
+    connectionState() {
+        return this._connectionState;
+    }
+    deviceName() {
+        return this.device.localName || this.device.name || 'NONE';
+    }
+    disconnect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                taro_1.default.closeBLEConnection({
+                    deviceId: this.device.deviceId,
+                    success: () => {
+                        this.device = null;
+                        this.scpair = null;
+                        resolve();
+                    },
+                    // @ts-ignore
+                    fail: (e) => reject(e),
+                });
+            });
+        });
+    }
+    canRead() {
+        return this.scpair.read != null;
+    }
+    read(options) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.dataOfRead.length > 0) {
+                this.dataOfRead.splice(0, this.dataOfRead.length);
+            }
+            yield this.realRead();
+            const timeout = ((_a = options === null || options === void 0 ? void 0 : options.timeout) !== null && _a !== void 0 ? _a : 5000);
+            const startTime = +new Date();
+            while (true) {
+                const now = +new Date();
+                if (now - startTime > timeout) {
+                    return new Uint8Array([]);
+                }
+                if (this.dataOfRead.length == 0) {
+                    yield await_timeout_1.default.set(100);
+                    continue;
+                }
+                const data = this.dataOfRead.pop();
+                const value = data.value;
+                return new Uint8Array(value);
+            }
+        });
+    }
+    write(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                taro_1.default.writeBLECharacteristicValue({
+                    deviceId: this.device.deviceId,
+                    serviceId: this.scpair.service.uuid,
+                    characteristicId: this.scpair.write.uuid,
+                    // @ts-ignore
+                    value: data.buffer,
+                    success: result => {
+                        if (result.errMsg.indexOf('ok') == -1) {
+                            reject(result.errMsg);
+                            return;
+                        }
+                        resolve();
+                    },
+                    // @ts-ignore
+                    fail: (e) => reject(e)
+                });
+            });
+        });
+    }
+    flush() {
+        this.dataOfRead.splice(0, this.dataOfRead.length);
+    }
+}
+exports.TaroBleConnectedDevice = TaroBleConnectedDevice;

package/build/index.d.ts

@@ -1,24 +1,3 @@
-import { ConnectedDevice, ConnectionState, ReadOptions } from "@psdk/frame-father";
-import Taro from "@tarojs/taro";
-export declare class TaroBleConnectedDevice implements ConnectedDevice {
-    private readonly device;
-    private readonly service;
-    private readonly characteristic;
-    private _connectionState;
-    private dataOfRead;
-    constructor(options: {
-        device: Taro.getBluetoothDevices.SuccessCallbackResultBlueToothDevice;
-        service: Taro.getBLEDeviceServices.BLEService;
-        characteristic: Taro.getBLEDeviceCharacteristics.BLECharacteristic;
-    });
-    private doListen;
-    private realRead;
-    connectionState(): ConnectionState;
-    deviceName(): string;
-    disconnect(): Promise<void>;
-    canRead(): boolean;
-    read(options?: ReadOptions): Promise<Uint8Array>;
-    write(data: Uint8Array): Promise<void>;
-    flush(): void;
-}
+export * from './connected';
+export * from './provider';
 //# sourceMappingURL=index.d.ts.map

package/build/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,eAAe,EAAE,eAAe,EAAE,WAAW,EAAC,MAAM,oBAAoB,CAAC;AACjF,OAAO,IAAI,MAAM,cAAc,CAAC;AAGhC,qBAAa,sBAAuB,YAAW,eAAe;IAC5D,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAgE;IACvF,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAuC;IAC/D,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAqD;IAEpF,OAAO,CAAC,gBAAgB,CAAkB;IAC1C,OAAO,CAAC,UAAU,CAA4D;gBAE3D,OAAO,EAAE;QAC1B,MAAM,EAAE,IAAI,CAAC,mBAAmB,CAAC,oCAAoC,CAAC;QACtE,OAAO,EAAE,IAAI,CAAC,oBAAoB,CAAC,UAAU,CAAC;QAC9C,cAAc,EAAE,IAAI,CAAC,2BAA2B,CAAC,iBAAiB,CAAC;KACpE;IAQD,OAAO,CAAC,QAAQ;YASF,QAAQ;IAYtB,eAAe,IAAI,eAAe;IAIlC,UAAU,IAAI,MAAM;IAId,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAGjC,OAAO,IAAI,OAAO;IAIZ,IAAI,CAAC,OAAO,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,UAAU,CAAC;IAsBhD,KAAK,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;IAgB5C,KAAK,IAAI,IAAI;CAKd"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,cAAc,aAAa,CAAA;AAC3B,cAAc,YAAY,CAAA"}

package/build/index.js

@@ -1,106 +1,18 @@
 "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());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+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 });
-exports.TaroBleConnectedDevice = void 0;
-const frame_father_1 = require("@psdk/frame-father");
-const taro_1 = __importDefault(require("@tarojs/taro"));
-const await_timeout_1 = __importDefault(require("await-timeout"));
-class TaroBleConnectedDevice {
-    constructor(options) {
-        this.device = options.device;
-        this.service = options.service;
-        this.characteristic = options.characteristic;
-        this._connectionState = frame_father_1.ConnectionState.CONNECTED;
-        this.doListen();
-    }
-    doListen() {
-        taro_1.default.onBLECharacteristicValueChange(value => {
-            this.dataOfRead.push(value);
-        });
-        taro_1.default.onBLEConnectionStateChange(value => {
-            this._connectionState = value.connected ? frame_father_1.ConnectionState.CONNECTED : frame_father_1.ConnectionState.DISCONNECTED;
-        });
-    }
-    realRead() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return new Promise((resolve, reject) => {
-                taro_1.default.readBLECharacteristicValue({
-                    deviceId: this.device.deviceId,
-                    serviceId: this.service.uuid,
-                    characteristicId: this.characteristic.uuid,
-                    success: res => resolve(),
-                    fail: res => reject(),
-                });
-            });
-        });
-    }
-    connectionState() {
-        return this._connectionState;
-    }
-    deviceName() {
-        return this.device.localName || this.device.name || 'NONE';
-    }
-    disconnect() {
-        return __awaiter(this, void 0, void 0, function* () {
-        });
-    }
-    canRead() {
-        return true;
-    }
-    read(options) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.dataOfRead.length > 0) {
-                this.dataOfRead.splice(0, this.dataOfRead.length);
-            }
-            yield this.realRead();
-            const timeout = ((_a = options === null || options === void 0 ? void 0 : options.timeout) !== null && _a !== void 0 ? _a : 3) * 1000;
-            const startTime = +new Date();
-            while (true) {
-                const now = +new Date();
-                if (now - startTime > timeout) {
-                    return new Uint8Array([]);
-                }
-                if (this.dataOfRead.length == 0) {
-                    yield await_timeout_1.default.set(50);
-                    continue;
-                }
-                const data = this.dataOfRead.pop();
-                const value = data.value;
-                return new Uint8Array(value);
-            }
-        });
-    }
-    write(data) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return new Promise((resolve, reject) => {
-                taro_1.default.writeBLECharacteristicValue({
-                    deviceId: this.device.deviceId,
-                    serviceId: this.service.uuid,
-                    characteristicId: this.characteristic.uuid,
-                    value: data.buffer,
-                    success: res => resolve(),
-                    fail: res => {
-                        console.error('Failed to write data:', res.errMsg);
-                        reject(res.errMsg);
-                    }
-                });
-            });
-        });
-    }
-    flush() {
-        this.dataOfRead.splice(0, this.dataOfRead.length);
-    }
-}
-exports.TaroBleConnectedDevice = TaroBleConnectedDevice;
+__exportStar(require("./connected"), exports);
+__exportStar(require("./provider"), exports);

package/build/provider.d.ts

@@ -0,0 +1,24 @@
+import { BasicMessage, BluetoothAdapterState, ConnectOptions, Jluetooth, JluetoothDevice, ProviderOptions } from "@psdk/device-bluetooth-traits";
+import { ConnectedDevice } from "@psdk/frame-father";
+import Taro from "@tarojs/taro";
+export declare class TaroBleBluetooth extends Jluetooth<Taro.onBluetoothDeviceFound.CallbackResultBlueToothDevice> {
+    private readonly options?;
+    private discoveredCallback?;
+    private connectedDevice?;
+    constructor(options?: ProviderOptions);
+    isConnected(): boolean;
+    bluetoothAdapterState(): Promise<BluetoothAdapterState>;
+    connect(device: JluetoothDevice<Taro.onBluetoothDeviceFound.CallbackResultBlueToothDevice>, options?: ConnectOptions): Promise<ConnectedDevice>;
+    discovered(callback: (devices: Array<JluetoothDevice<Taro.onBluetoothDeviceFound.CallbackResultBlueToothDevice>>) => Promise<void>): void;
+    startDiscovery(): Promise<void>;
+    stopDiscovery(): Promise<BasicMessage>;
+    private openBluetoothAdapter;
+    private closeBluetoothAdapter;
+    private onBluetoothDeviceFound;
+    private createBLEConnection;
+    private getBLEDeviceServices;
+    private getBLEDeviceCharacteristics;
+    private requestLocation;
+    private findSCPair;
+}
+//# sourceMappingURL=provider.d.ts.map

package/build/provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider.d.ts","sourceRoot":"","sources":["../src/provider.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EACZ,qBAAqB,EACrB,cAAc,EACd,SAAS,EACT,eAAe,EACf,eAAe,EAEhB,MAAM,+BAA+B,CAAC;AACvC,OAAO,EAAC,eAAe,EAAkB,MAAM,oBAAoB,CAAC;AAGpE,OAAO,IAAI,MAAM,cAAc,CAAC;AAEhC,qBAAa,gBAAiB,SAAQ,SAAS,CAAC,IAAI,CAAC,sBAAsB,CAAC,6BAA6B,CAAC;IAExG,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAkB;IAG3C,OAAO,CAAC,kBAAkB,CAAC,CAAgH;IAC3I,OAAO,CAAC,eAAe,CAAC,CAAyB;gBAErC,OAAO,CAAC,EAAE,eAAe;IAMrC,WAAW,IAAI,OAAO;IAMhB,qBAAqB,IAAI,OAAO,CAAC,qBAAqB,CAAC;IAUvD,OAAO,CACX,MAAM,EAAE,eAAe,CAAC,IAAI,CAAC,sBAAsB,CAAC,6BAA6B,CAAC,EAClF,OAAO,CAAC,EAAE,cAAc,GACvB,OAAO,CAAC,eAAe,CAAC;IA2B3B,UAAU,CACR,QAAQ,EAAE,CAAC,OAAO,EAAE,KAAK,CAAC,eAAe,CAAC,IAAI,CAAC,sBAAsB,CAAC,6BAA6B,CAAC,CAAC,KAChG,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI;IAIrB,cAAc,IAAI,OAAO,CAAC,IAAI,CAAC;IA0B/B,aAAa,IAAI,OAAO,CAAC,YAAY,CAAC;YAY9B,oBAAoB;YAgBpB,qBAAqB;IAgBnC,OAAO,CAAC,sBAAsB;YA0BhB,mBAAmB;YAYnB,oBAAoB;YAkBpB,2BAA2B;YAmB3B,eAAe;YAgBf,UAAU;CAwGzB"}

package/build/provider.js

@@ -0,0 +1,341 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaroBleBluetooth = void 0;
+const device_bluetooth_traits_1 = require("@psdk/device-bluetooth-traits");
+const frame_father_1 = require("@psdk/frame-father");
+const await_timeout_1 = __importDefault(require("await-timeout"));
+const connected_1 = require("./connected");
+const taro_1 = __importDefault(require("@tarojs/taro"));
+class TaroBleBluetooth extends device_bluetooth_traits_1.Jluetooth {
+    constructor(options) {
+        super();
+        this.options = options;
+        this.onBluetoothDeviceFound();
+    }
+    isConnected() {
+        if (!this.connectedDevice)
+            return false;
+        return this.connectedDevice.connectionState() === frame_father_1.ConnectionState.CONNECTED;
+    }
+    bluetoothAdapterState() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                taro_1.default.getBluetoothAdapterState({
+                    success: (r) => resolve(r),
+                    // @ts-ignore
+                    fail: (e) => reject(e)
+                });
+            });
+        });
+    }
+    connect(device, options) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.isConnected()) {
+                if (!((_a = options === null || options === void 0 ? void 0 : options.autoSwitchDevice) !== null && _a !== void 0 ? _a : false)) {
+                    return this.connectedDevice;
+                }
+                yield this.connectedDevice.disconnect();
+            }
+            const origin = device.origin;
+            yield this.createBLEConnection({ deviceId: origin.deviceId, timeout: options === null || options === void 0 ? void 0 : options.timeout, });
+            yield await_timeout_1.default.set(500);
+            const services = yield this.getBLEDeviceServices({ deviceId: origin.deviceId });
+            const scpair = yield this.findSCPair({
+                deviceId: origin.deviceId,
+                services,
+            });
+            if (!scpair) {
+                return Promise.reject(`Can not get write characteristic by device: ${device.name}`);
+            }
+            this.connectedDevice = new connected_1.TaroBleConnectedDevice({
+                device: origin,
+                scpair,
+            });
+            yield this.stopDiscovery();
+            return Promise.resolve(this.connectedDevice);
+        });
+    }
+    discovered(callback) {
+        this.discoveredCallback = callback;
+    }
+    startDiscovery() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.requestLocation();
+            yield this.closeBluetoothAdapter();
+            yield await_timeout_1.default.set(300);
+            yield this.openBluetoothAdapter();
+            const state = yield this.bluetoothAdapterState();
+            if (!state.available) {
+                yield await_timeout_1.default.set(500);
+            }
+            if (state.discovering) {
+                yield this.stopDiscovery();
+                yield await_timeout_1.default.set(500);
+            }
+            return new Promise((resolve, reject) => {
+                taro_1.default.startBluetoothDevicesDiscovery({
+                    // services: this.allowServices,
+                    allowDuplicatesKey: false,
+                    interval: 0,
+                    success: () => resolve(),
+                    // @ts-ignore
+                    fail: (e) => reject(e),
+                    // complete: () => resolve(),
+                });
+            });
+        });
+    }
+    stopDiscovery() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                taro_1.default.stopBluetoothDevicesDiscovery({
+                    success: (result) => resolve(result),
+                    // @ts-ignore
+                    fail: (e) => reject(e),
+                });
+            });
+        });
+    }
+    // ### inner function
+    openBluetoothAdapter() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                taro_1.default.openBluetoothAdapter({
+                    success: (ret) => {
+                        if (ret.errMsg && ret.errMsg.indexOf('ok') == -1) {
+                            reject(ret);
+                            return;
+                        }
+                        resolve();
+                    },
+                    // @ts-ignore
+                    fail: (e) => reject(e)
+                });
+            });
+        });
+    }
+    closeBluetoothAdapter() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                taro_1.default.closeBluetoothAdapter({
+                    success: (ret) => {
+                        if (ret.errMsg && ret.errMsg.indexOf('ok') == -1) {
+                            reject(ret);
+                            return;
+                        }
+                        resolve();
+                    },
+                    // @ts-ignore
+                    fail: (e) => reject(e)
+                });
+            });
+        });
+    }
+    onBluetoothDeviceFound() {
+        taro_1.default.onBluetoothDeviceFound((result) => __awaiter(this, void 0, void 0, function* () {
+            const foundDevices = result.devices;
+            if (!foundDevices.length) {
+                return;
+            }
+            const devices = foundDevices
+                .filter(item => {
+                var _a, _b;
+                const name = item.name || item.localName;
+                if (name)
+                    return true;
+                return (_b = (_a = this.options) === null || _a === void 0 ? void 0 : _a.allowNoName) !== null && _b !== void 0 ? _b : true;
+            })
+                .map(item => new device_bluetooth_traits_1.JluetoothDevice({
+                origin: item,
+                name: item.name || item.localName,
+                deviceId: item.deviceId,
+            }));
+            if (!devices.length) {
+                return;
+            }
+            if (this.discoveredCallback) {
+                yield this.discoveredCallback(devices);
+            }
+        }));
+    }
+    createBLEConnection(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                taro_1.default.createBLEConnection({
+                    deviceId: options.deviceId,
+                    timeout: options.timeout,
+                    success: () => resolve(),
+                    // @ts-ignore
+                    fail: (e) => reject(e),
+                });
+            });
+        });
+    }
+    getBLEDeviceServices(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                taro_1.default.getBLEDeviceServices({
+                    deviceId: options.deviceId,
+                    success: (result) => {
+                        if (result.errMsg.indexOf('ok') == -1) {
+                            reject(result.errMsg);
+                            return;
+                        }
+                        resolve(result.services);
+                    },
+                    // @ts-ignore
+                    fail: (e) => reject(e),
+                });
+            });
+        });
+    }
+    getBLEDeviceCharacteristics(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                taro_1.default.getBLEDeviceCharacteristics({
+                    deviceId: options.deviceId,
+                    serviceId: options.serviceId,
+                    success: (result) => {
+                        if (result.errMsg.indexOf('ok') == -1) {
+                            reject(result.errMsg);
+                            return;
+                        }
+                        resolve(result.characteristics);
+                    },
+                    // @ts-ignore
+                    fail: (e) => reject(e),
+                });
+            });
+        });
+    }
+    requestLocation() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                // Taro.authorize({
+                //   scope: 'scope.userLocation',
+                //   success: () => resolve(),
+                //   // @ts-ignore
+                //   fail: (e) => reject(e),
+                // });
+                taro_1.default.getLocation({
+                    success: () => resolve(),
+                    // @ts-ignore
+                    fail: (e) => reject(e),
+                });
+            });
+        });
+    }
+    findSCPair(options) {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        return __awaiter(this, void 0, void 0, function* () {
+            // fill data
+            const _characteristicsMap = new Map();
+            for (const service of options.services) {
+                const characteristics = yield this.getBLEDeviceCharacteristics({
+                    deviceId: options.deviceId,
+                    serviceId: service.uuid,
+                });
+                _characteristicsMap.set(service.uuid, characteristics);
+            }
+            // use special first
+            if ((_a = this.options) === null || _a === void 0 ? void 0 : _a.allowCharacteristic) {
+                for (const service of options.services) {
+                    if (!device_bluetooth_traits_1.TBluetoothHelpers.isAllowServices(service.uuid, (_b = this.options) === null || _b === void 0 ? void 0 : _b.allowServices)) {
+                        continue;
+                    }
+                    const characteristics = _characteristicsMap.get(service.uuid);
+                    for (const characteristic of characteristics) {
+                        if (((_c = this.options) === null || _c === void 0 ? void 0 : _c.allowCharacteristic) != characteristic.uuid)
+                            continue;
+                        const properties = characteristic.properties;
+                        return {
+                            service,
+                            write: characteristic,
+                            read: properties.read ? characteristic : null,
+                        };
+                    }
+                }
+            }
+            // choose best characteristic
+            for (const service of options.services) {
+                if (!device_bluetooth_traits_1.TBluetoothHelpers.isAllowServices(service.uuid, (_d = this.options) === null || _d === void 0 ? void 0 : _d.allowServices)) {
+                    continue;
+                }
+                const characteristics = _characteristicsMap.get(service.uuid);
+                // let readCharacteristic: GetBLEDeviceCharacteristicsSuccessData;
+                // let writeCharacteristic: GetBLEDeviceCharacteristicsSuccessData;
+                const pickedCharacteristic = characteristics.find(characteristic => {
+                    const properties = characteristic.properties;
+                    // @ts-ignore
+                    return (properties.writeNoResponse || properties.write) && (properties.read);
+                });
+                if (pickedCharacteristic) {
+                    return {
+                        service,
+                        write: pickedCharacteristic,
+                        read: pickedCharacteristic,
+                    };
+                }
+            }
+            if ((_f = (_e = this.options) === null || _e === void 0 ? void 0 : _e.allowDetectDifferentCharacteristic) !== null && _f !== void 0 ? _f : false) {
+                // choose different characteristic with write and read properties
+                for (const service of options.services) {
+                    if (!device_bluetooth_traits_1.TBluetoothHelpers.isAllowServices(service.uuid, (_g = this.options) === null || _g === void 0 ? void 0 : _g.allowServices)) {
+                        continue;
+                    }
+                    const characteristics = _characteristicsMap.get(service.uuid);
+                    const writeCharacteristic = characteristics.find(characteristic => {
+                        const properties = characteristic.properties;
+                        // @ts-ignore
+                        return (properties.writeNoResponse || properties.write);
+                    });
+                    const readCharacteristic = characteristics.find(characteristic => {
+                        const properties = characteristic.properties;
+                        return (properties.read);
+                    });
+                    if (writeCharacteristic && readCharacteristic) {
+                        return {
+                            service,
+                            write: writeCharacteristic,
+                            read: readCharacteristic,
+                        };
+                    }
+                }
+            }
+            else {
+                // only write
+                for (const service of options.services) {
+                    if (!device_bluetooth_traits_1.TBluetoothHelpers.isAllowServices(service.uuid, (_h = this.options) === null || _h === void 0 ? void 0 : _h.allowServices)) {
+                        continue;
+                    }
+                    const characteristics = _characteristicsMap.get(service.uuid);
+                    const writeCharacteristic = characteristics.find(characteristic => {
+                        const properties = characteristic.properties;
+                        // @ts-ignore
+                        return (properties.writeNoResponse || properties.write);
+                    });
+                    if (writeCharacteristic) {
+                        return {
+                            service,
+                            write: writeCharacteristic,
+                        };
+                    }
+                }
+            }
+        });
+    }
+}
+exports.TaroBleBluetooth = TaroBleBluetooth;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@psdk/device-ble-taro",
-  "version": "0.2.44",
+  "version": "0.2.45",
   "description": "psdk",
   "main": "build/index.js",
   "types": "build/index.d.ts",
@@ -46,12 +46,12 @@
     "webpack-cli": "^4.9.2"
   },
   "dependencies": {
-    "@psdk/frame-father": "0.2.44",
+    "@psdk/frame-father": "0.2.45",
     "await-timeout": "^1.1.1"
   },
   "files": [
     "build",
     "!build/browser/psdk*"
   ],
-  "gitHead": "56736889db619264d2931a1e24041a3c831f68a2"
+  "gitHead": "f50371b7b1d1f3888c493e86bba5dbf8224a8d91"
 }