@alexgyver/ble 1.0.0 → 1.0.2

package/.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+    "liveServer.settings.port": 5501
+}

package/README.md

@@ -4,7 +4,11 @@
 - Буферизация отправки
 - Буферизация приёма, разделение текста по разделителю
 
-> npm i @alexgyver/ble
+[demo](https://gyverlibs.github.io/BLE.js/test/)
+
+> **Browser**: https://gyverlibs.github.io/BLE.js/BLE.min.js
+
+> **Node**: npm i @alexgyver/ble
 
 ## Дока
 ```js

package/ble2.js

@@ -0,0 +1,192 @@
+import { sleep, ShiftBuffer, StreamSplitter } from "@alexgyver/utils";
+
+export default class BLEJS {
+    static State = {
+        Closed: 'closed',
+        Opening: 'opening',
+        Open: 'open',
+        Closing: 'closing',
+    };
+
+    //#region handlers
+    onbin = null;
+    ontext = null;
+
+    onopen() { }
+    onclose() { }
+    onchange(s) { }
+    onselect(name) { }
+    onerror(e) { }
+
+    //#region constructor
+    constructor(params = {}) {
+        const def = {
+            eol: /\r?\n/,
+            serviceUUID: '0000ffe0-0000-1000-8000-00805f9b34fb',
+            rxUUID: '0000ffe1-0000-1000-8000-00805f9b34fb',
+            txUUID: '0000ffe2-0000-1000-8000-00805f9b34fb',
+            auto_open: false,
+            max_tx: 20,
+            reconnect: 1000,
+        };
+        this.cfg = { ...def, ...params };
+
+        this.splitter = new StreamSplitter(this.cfg.eol);
+        this.splitter.ontext = (t) => this.ontext && this.ontext(t);
+    }
+
+    //#region methods
+    config(params = {}) {
+        this.cfg = { ...this.cfg, ...params };
+        this.splitter.eol = this.cfg.eol;
+    }
+
+    static supported() {
+        return 'bluetooth' in navigator;
+    }
+
+    opened() {
+        return this._state === BLEJS.State.Open;
+    }
+
+    selected() {
+        return !!this._device;
+    }
+
+    getName() {
+        return this._device ? this._device.name : null;
+    }
+
+    async select() {
+        try {
+            await this.close();
+            if (this._device) this._device.removeEventListener('gattserverdisconnected', this._disconnect_h);
+            this._device = await navigator.bluetooth.requestDevice({
+                filters: [{ services: [this.cfg.serviceUUID] }],
+                optionalServices: [this.cfg.serviceUUID]
+            });
+            this._device.addEventListener("gattserverdisconnected", this._disconnect_h);
+        } catch (e) {
+            this._error(e);
+            this._device = null;
+        }
+        this.onselect(this.getName());
+        if (this.cfg.auto_open) this.open();
+        return this.selected();
+    }
+
+    async open() {
+        if (!this._device) return;
+        if (this.opened()) return;
+
+        if (this.cfg.reconnect) this.retry = true;
+        await this._open();
+    }
+
+    async _open() {
+        if (this._state != BLEJS.State.Closed) return;
+
+        this._change(BLEJS.State.Opening);
+        try {
+            const server = await this._device.gatt.connect();
+            const service = await server.getPrimaryService(this.cfg.serviceUUID);
+
+            this._rx = await service.getCharacteristic(this.cfg.rxUUID);
+            this._tx = await service.getCharacteristic(this.cfg.txUUID);
+
+            await this._tx.startNotifications();
+            this._tx.addEventListener("characteristicvaluechanged", this._data_h);
+
+            this._buffer.clear();
+            this._change(BLEJS.State.Open);
+            this._decoder = new TextDecoder();
+            this.splitter.reset();
+        } catch (e) {
+            this._error(e);
+            this._change(BLEJS.State.Closed);
+            if (this.retry) sleep(this.cfg.reconnect).then(() => this._open());
+        }
+    }
+
+    async close() {
+        this.retry = false;
+        if (this._device?.gatt?.connected) await this._close();
+    }
+
+    async _close() {
+        this._change(BLEJS.State.Closing);
+        try {
+            if (this._device?.gatt?.connected) this._device.gatt.disconnect();
+            else this._disconnect();
+        } catch (e) {
+            this._error(e);
+        }
+    }
+
+    async sendText(text) {
+        await this.sendBin((new TextEncoder()).encode(text));
+    }
+
+    async sendBin(data) {
+        this._buffer.push(data);
+        this._send();
+    }
+
+    //#region private    
+    _device = null;
+    _rx = null;
+    _tx = null;
+    _state = BLEJS.State.Closed;
+    _buffer = new ShiftBuffer();
+    _decoder = new TextDecoder();
+
+    async _disconnect(e) {
+        this._change(BLEJS.State.Closed);
+        if (this._tx) this._tx.removeEventListener('characteristicvaluechanged', this._data_h);
+
+        this._rx = null;
+        this._tx = null;
+
+        if (this.retry) sleep(this.cfg.reconnect).then(() => this._open());
+        await sleep(50);
+    }
+    _disconnect_h = this._disconnect.bind(this);
+
+    _data(e) {
+        const dv = e.target.value;
+        const value = new Uint8Array(dv.buffer, dv.byteOffset, dv.byteLength);
+        if (this.onbin) this.onbin(value);
+        if (this.ontext) this.splitter.write(this._decoder.decode(value, { stream: true }));
+    }
+    _data_h = this._data.bind(this);
+
+    async _send() {
+        if (this._busy) return;
+        this._busy = true;
+
+        while (this._buffer.length && this._rx) {
+            let d = this._buffer.shift(this.cfg.max_tx);
+
+            try {
+                if (d.length) await this._rx.writeValueWithoutResponse(d);
+                // await this._rx.writeValueWithResponse(d);
+            } catch (e) {
+                this._error(e);
+            }
+        }
+
+        this._busy = false;
+    }
+
+    _error(e) {
+        this.onerror('[BLE] ' + e);
+    }
+    _change(s) {
+        this._state = s;
+        this.onchange(s);
+        switch (s) {
+            case BLEJS.State.Open: this.onopen(); break;
+            case BLEJS.State.Closed: this.onclose(); break;
+        }
+    }
+}

package/ble2light.js

@@ -0,0 +1,253 @@
+import { sleep, SerialExecutor } from "@alexgyver/utils";
+
+export default class BLEJS {
+    static State = {
+        Closed: 'closed',
+        Opening: 'opening',
+        Open: 'open',
+        Closing: 'closing',
+    };
+
+    onbin(b) { }
+    onopen() { }
+    onclose() { }
+    onchange(s) { }
+    onselect(name) { }
+    onerror(e) { }
+
+    constructor(params = {}) {
+        const def = {
+            serviceUUID: '0000ffe0-0000-1000-8000-00805f9b34fb',
+            rxUUID: '0000ffe1-0000-1000-8000-00805f9b34fb',
+            txUUID: '0000ffe2-0000-1000-8000-00805f9b34fb',
+            auto_open: false,
+            reconnect: 1000,
+        };
+
+        this.cfg = { ...def, ...params };
+    }
+
+    config(params = {}) {
+        this.cfg = { ...this.cfg, ...params };
+    }
+
+    static supported() {
+        return 'bluetooth' in navigator;
+    }
+
+    opened() {
+        return this._state === BLEJS.State.Open;
+    }
+
+    selected() {
+        return !!this._device;
+    }
+
+    getName() {
+        return this._device ? this._device.name : null;
+    }
+
+    async select() {
+        try {
+            await this.close();
+
+            if (this._device) {
+                this._device.removeEventListener(
+                    'gattserverdisconnected',
+                    this._disconnect_h
+                );
+            }
+
+            this._device = await navigator.bluetooth.requestDevice({
+                filters: [{ services: [this.cfg.serviceUUID] }],
+                optionalServices: [this.cfg.serviceUUID],
+            });
+
+            this._device.addEventListener(
+                'gattserverdisconnected',
+                this._disconnect_h
+            );
+        } catch (e) {
+            this._error(e);
+            this._device = null;
+        }
+
+        this.onselect(this.getName());
+
+        if (this.cfg.auto_open) this.open();
+
+        return this.selected();
+    }
+
+    async open() {
+        return this._lifecycle.runNothrow(async () => {
+            if (!this._device) {
+                this._error('No device');
+                return false;
+            }
+
+            if (this.opened()) return true;
+
+            if (this.cfg.reconnect) this.retry = true;
+
+            await this._open();
+
+            return this.opened();
+        });
+    }
+
+    async _open() {
+        if (this._state !== BLEJS.State.Closed) return;
+
+        this._change(BLEJS.State.Opening);
+
+        try {
+            const server = await this._device.gatt.connect();
+            const service = await server.getPrimaryService(this.cfg.serviceUUID);
+
+            this._rx = await service.getCharacteristic(this.cfg.rxUUID);
+            this._tx = await service.getCharacteristic(this.cfg.txUUID);
+
+            await this._tx.startNotifications();
+            this._tx.addEventListener(
+                'characteristicvaluechanged',
+                this._data_h
+            );
+
+            this._sender.reset();
+            this._change(BLEJS.State.Open);
+        } catch (e) {
+            this._error(e);
+            this._sender.reset();
+            this._change(BLEJS.State.Closed);
+
+            if (this.retry) {
+                sleep(this.cfg.reconnect).then(() => {
+                    this._lifecycle.runNothrow(() => this._open());
+                });
+            }
+        }
+    }
+
+    async close() {
+        return this._lifecycle.runNothrow(async () => {
+            this.retry = false;
+            this._sender.reset();
+
+            if (this._state !== BLEJS.State.Closed) {
+                await this._close();
+            }
+
+            return true;
+        });
+    }
+
+    async _close() {
+        if (this._state === BLEJS.State.Closed) return;
+
+        this._change(BLEJS.State.Closing);
+
+        try {
+            if (this._device?.gatt?.connected) {
+                this._device.gatt.disconnect();
+            } else {
+                await this._disconnect();
+            }
+        } catch (e) {
+            this._error(e);
+            await this._disconnect();
+        }
+    }
+
+    async sendBin(data, fast = true) {
+        if (!this.opened() || !this._rx) return false;
+
+        return this._sender.runNothrow(async () => {
+            if (!this.opened() || !this._rx) return false;
+
+            if (fast) {
+                await this._rx.writeValueWithoutResponse(data);
+            } else {
+                await this._rx.writeValueWithResponse(data);
+            }
+
+            return true;
+        });
+    }
+
+    _state = BLEJS.State.Closed;
+    _device = null;
+    _rx = null;
+    _tx = null;
+
+    retry = false;
+
+    _sender = new SerialExecutor();
+    _lifecycle = new SerialExecutor();
+
+    async _disconnect(e) {
+        this._sender.reset();
+
+        if (this._tx) {
+            try {
+                this._tx.removeEventListener(
+                    'characteristicvaluechanged',
+                    this._data_h
+                );
+            } catch (e) { }
+        }
+
+        this._rx = null;
+        this._tx = null;
+
+        this._change(BLEJS.State.Closed);
+
+        if (this.retry) {
+            sleep(this.cfg.reconnect).then(() => {
+                this._lifecycle.runNothrow(() => this._open());
+            });
+        }
+
+        await sleep(50);
+    }
+
+    _disconnect_h = this._disconnect.bind(this);
+
+    _data(e) {
+        try {
+            const dv = e.target.value;
+            const value = new Uint8Array(
+                dv.buffer,
+                dv.byteOffset,
+                dv.byteLength
+            );
+
+            this.onbin(value);
+        } catch (e) {
+            this._error(e);
+        }
+    }
+
+    _data_h = this._data.bind(this);
+
+    _error(e) {
+        this.onerror('[BLE] ' + e);
+    }
+
+    _change(s) {
+        if (this._state === s) return;
+
+        this._state = s;
+        this.onchange(s);
+
+        switch (s) {
+            case BLEJS.State.Open:
+                this.onopen();
+                break;
+
+            case BLEJS.State.Closed:
+                this.onclose();
+                break;
+        }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alexgyver/ble",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Web BLE Serial",
   "main": "./ble.js",
   "module": "./ble.js",
@@ -14,14 +14,15 @@
     "url": "git+https://github.com/GyverLibs/ble.js.git"
   },
   "devDependencies": {
-    "webpack": "^5.103.0",
-    "webpack-cli": "^6.0.1",
-    "webpack-dev-server": "^5.2.2",
-    "html-webpack-plugin": "^5.6.5"
+    "css-loader": "^7.1.4",
+    "style-loader": "^4.0.0",
+    "webpack": "^5.106.2",
+    "webpack-cli": "^7.0.2",
+    "webpack-dev-server": "^5.2.4"
   },
   "dependencies": {
-    "@alexgyver/utils": "^1.2.4"
+    "@alexgyver/utils": "^1.2.6"
   },
   "author": "AlexGyver <alex@alexgyver.ru>",
   "license": "MIT"
-}
+}

package/test/index.html

@@ -3,8 +3,7 @@
 
 <head>
   <meta charset="UTF-8">
-  <meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=no">
-  <script src="script.js" type="module" defer="defer"></script>
+  <script src="./script.js" type="module"></script>
   <title>BLE test</title>
 </head>
 

package/test/script.js

@@ -1,17 +1,25 @@
 import BLEJS from "https://gyverlibs.github.io/BLE.js/ble.min.js";
+// import BLEJS from "../ble2light.js";
 
 let i = 0;
-let ble = new BLEJS({ auto_open: true, eol: '' });
+let ble = new BLEJS({ auto_open: true });
 
 // control
 select_b.onclick = () => ble.select();
 open_b.onclick = () => ble.open();
 close_b.onclick = () => ble.close();
-send_b.onclick = () => ble.sendText('Hello ' + i++);
+send_b.onclick = async () => {
+    ble.sendBin(new TextEncoder().encode('Hello ' + i++));
+}
+
+async function send(hex) {
+    const data = new Uint8Array(hex.trim().split(/\s+/).map(x => parseInt(x, 16)));
+    await ble.sendBin(data);
+}
 
 // read
-// ble.onbin = b => console.log(b);
-ble.ontext = t => console.log(t);
+ble.onbin = b => console.log(new TextDecoder().decode(b));
+// ble.ontext = t => console.log(t);
 
 // state
 // ble.onopen = () => {

package/webpack.dev.config.js

@@ -1,39 +1,24 @@
 const path = require('path');
-const PACKAGE = require('./package.json');
-const HtmlWebpackPlugin = require('html-webpack-plugin');
 
 module.exports = {
-    entry: {
-        index: './test_dev/script.js',
-    },
-
+    entry: './test/script.js',
     output: {
         filename: 'script.js',
-        path: path.resolve(__dirname, 'dev'),
-        clean: true,
+        path: path.resolve(__dirname, 'test'),
+        clean: false,
+    },
+    module: {
+        rules: [
+            {
+                test: /\.css$/,
+                use: ['style-loader', 'css-loader'],
+            }
+        ]
     },
-
-    plugins: [
-        new HtmlWebpackPlugin({
-            template: `./test_dev/index.html`,
-            filename: `index.html`,
-            inject: true,
-            minify: false,
-            version: PACKAGE.version,
-            title: PACKAGE.title,
-        }),
-    ],
-
     devServer: {
-        watchFiles: ['test_dev/*.html'],
-        static: path.resolve(__dirname, './dev'),
+        static: path.resolve(__dirname, 'test'),
         hot: true,
         open: true,
     },
-
-    watchOptions: {
-        poll: 1000,
-    },
-
     mode: 'development',
 };

package/test_dev/index.html

@@ -1,18 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-
-<head>
-  <meta charset="UTF-8">
-  <meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=no">
-  <script src="script.js" type="module" defer="defer"></script>
-  <title>BLE test</title>
-</head>
-
-<body>
-  <button id="select_b">select</button>
-  <button id="open_b">open</button>
-  <button id="close_b">close</button>
-  <button id="send_b">send</button>
-</body>
-
-</html>

package/test_dev/script.js

@@ -1,31 +0,0 @@
-import BLEJS from "../ble";
-
-let i = 0;
-let ble = new BLEJS({ auto_open: true, eol: '' });
-
-// control
-select_b.onclick = () => ble.select();
-open_b.onclick = () => ble.open();
-close_b.onclick = () => ble.close();
-send_b.onclick = () => ble.sendText('Hello ' + i++);
-
-// read
-// ble.onbin = b => console.log(b);
-ble.ontext = t => console.log(t);
-
-// state
-// ble.onopen = () => {
-//     console.log('Opened', ble.getName());
-// }
-// ble.onclose = () => {
-//     console.log('Closed');
-// }
-ble.onchange = s => {
-    console.log(s);
-}
-ble.onerror = e => {
-    console.log(e);
-}
-ble.onselect = (d) => {
-    console.log('select', d);
-}