inav-configurator/js/connection/connectionBle.js

'use strict'

// BLE 20 bytes buffer
const BLE_WRITE_BUFFER_LENGTH = 20;

const BleDevices = [
    {
        name: "CC2541 based",
        serviceUuid:        '0000ffe0-0000-1000-8000-00805f9b34fb',
        writeCharateristic: '0000ffe1-0000-1000-8000-00805f9b34fb', 
        readCharateristic:  '0000ffe1-0000-1000-8000-00805f9b34fb',
        delay:              30,
    },
    {
        name: "Nordic Semiconductor NRF",
        serviceUuid:        '6e400001-b5a3-f393-e0a9-e50e24dcca9e',
        writeCharateristic: '6e400003-b5a3-f393-e0a9-e50e24dcca9e', 
        readCharateristic:  '6e400002-b5a3-f393-e0a9-e50e24dcca9e',
        delay:              30,
    },
    {
        name: "SpeedyBee Type 2",
        serviceUuid:        '0000abf0-0000-1000-8000-00805f9b34fb',
        writeCharateristic: '0000abf1-0000-1000-8000-00805f9b34fb', 
        readCharateristic:  '0000abf2-0000-1000-8000-00805f9b34fb',
        delay:              0,
    },
    {
        name: "SpeedyBee Type 1",
        serviceUuid:        '00001000-0000-1000-8000-00805f9b34fb',
        writeCharateristic: '00001001-0000-1000-8000-00805f9b34fb', 
        readCharateristic:  '00001002-0000-1000-8000-00805f9b34fb',
        delay:              0,
    }
];

class ConnectionBle extends Connection {
    
    constructor() {
        super();
        
        this._readCharacteristic    = false;
        this._writeCharacteristic   = false;
        this._device                = false;
        this._deviceDescription     = false;
        this._onCharateristicValueChangedListeners = [];
        this._onDisconnectListeners   = [];
        this._reconnects = 0;
        this._handleOnCharateristicValueChanged = false;
        this._handleDisconnect = false;
    }

    get deviceDescription() {
        return this._deviceDescription;
    }

    async connectImplementation(path, options, callback) {      
        console.log("Request BLE Device");    
        await this.openDevice()
            .then(() => {
                this.addOnReceiveErrorListener(error => {
                    GUI.log(chrome.i18n.getMessage('connectionBleInterrupted'));
                    this.abort();
                });

                if (callback) {
                    callback({
                        // Dummy values
                        connectionId: 0xff,
                        bitrate: 115200 
                    });
                }
            }).catch(error => {
                GUI.log(chrome.i18n.getMessage('connectionBleError', [error]));
                if (callback) {
                    callback(false);
                }
            });

        return Promise.resolve();
    }

    async openDevice(){
        await this.request()
            .then(device => this.connectBle(device))
            .then(() => this.startNotification());

        return Promise.resolve();
    };

    request() {
        var ids = [];
        BleDevices.forEach(device => {
            ids.push(device.serviceUuid)
        });
        
        return navigator.bluetooth.requestDevice({
            acceptAllDevices: true,
            optionalServices: ids
        }).then(device => {
            console.log("Found BLE device: " + device.name);
            this._device = device;
            this._handleDisconnect = event => {
                this._onDisconnectListeners.forEach(listener => {
                    listener("disconnected");
                });      
            };

            this._device.addEventListener('gattserverdisconnected', this._handleDisconnect);
            return this._device;
        });
    }

    connectBle(device) {
        if (device.gatt.connected && this._readCharacteristic && this._writeCharacteristic) {
            return Promise.resolve();
        }

        return device.gatt.connect()
            .then(server => {
                console.log("Connect to: " + device.name);
                GUI.log(chrome.i18n.getMessage('connectionConnected', [device.name]));
                return server.getPrimaryServices();
            }).then(services => {
                let connectedService = services.find(service => {
                    this._deviceDescription = BleDevices.find(device => device.serviceUuid == service.uuid);
                    return this._deviceDescription;
                });

                if (!this._deviceDescription) {
                    throw new Error("Unsupported device (service UUID mismatch).");
                }

                GUI.log(chrome.i18n.getMessage('connectionBleType', [this._deviceDescription.name]));
                return connectedService.getCharacteristics();
            }).then(characteristics => {
                characteristics.forEach(characteristic => {
                    if (characteristic.uuid == this._deviceDescription.writeCharateristic) {
                        this._writeCharacteristic = characteristic;
                    }

                    if (characteristic.uuid == this._deviceDescription.readCharateristic) {
                        this._readCharacteristic = characteristic;
                    }

                    return this._writeCharacteristic && this._readCharacteristic;
                });

                if (!this._writeCharacteristic) {
                    throw new Error("No or unexpected write charateristic found (should be " +  this._deviceDescription.writeCharateristic + ")");
                }

                if (!this._readCharacteristic) {
                    throw new Error("No or unexpected read charateristic found (should be " +  this._deviceDescription.readCharateristic + ")");
                }
                
                this._handleOnCharateristicValueChanged = event => {
                    let buffer = new Uint8Array(event.target.value.byteLength);
                    for (var i = 0; i < event.target.value.byteLength; i++) {
                        buffer[i] = event.target.value.getUint8(i);
                    }

                    this._onCharateristicValueChangedListeners.forEach(listener => {
                        listener({
                            connectionId: 0xFF,
                            data: buffer
                        });
                    });
                };

                this._readCharacteristic.addEventListener('characteristicvaluechanged', this._handleOnCharateristicValueChanged)
                return Promise.resolve();
            });          
    }

    startNotification() {
        if (!this._readCharacteristic) {
            throw new Error("No read charateristic");
        }

        if (!this._readCharacteristic.properties.notify) {
            throw new Error("Read charateristic can't notify.");
        }

        return this._readCharacteristic.startNotifications()
            .then(() => {
                console.log("BLE notifications started.");
        });
    }

    disconnectImplementation(callback) {
        if (this._device) {
            this._device.removeEventListener('gattserverdisconnected', this._handleDisconnect);
            this._readCharacteristic.removeEventListener('characteristicvaluechanged', this._handleOnCharateristicValueChanged);

            if (this._device.gatt.connected) {
                this._device.gatt.disconnect();
            }        
            this._device = false;
            this._writeCharacteristic = false; 
            this._readCharacteristic = false;
            this._deviceDescription = false; 
        }

        if (callback) {
            callback(true);
        }
    }

    async sendImplementation (data, callback) {;
        if (!this._writeCharacteristic) {
            return;
        }
        
        let sent = 0;
        let dataBuffer = new Uint8Array(data);
        for (var i = 0; i < dataBuffer.length; i += BLE_WRITE_BUFFER_LENGTH) {
            var length = BLE_WRITE_BUFFER_LENGTH;

            if (i + BLE_WRITE_BUFFER_LENGTH > dataBuffer.length) {
                length = dataBuffer.length % BLE_WRITE_BUFFER_LENGTH;
            }

            var outBuffer = dataBuffer.subarray(i, i + length);
            sent += outBuffer.length;
            await this._writeCharacteristic.writeValue(outBuffer);   
        }

        if (callback) {
            callback({
                bytesSent: sent,
                resultCode: 0
            });
        }
        
    }

    addOnReceiveCallback(callback){
        this._onCharateristicValueChangedListeners.push(callback);
    }

    removeOnReceiveCallback(callback){
        this._onCharateristicValueChangedListeners = this._onCharateristicValueChangedListeners.filter(listener => listener !== callback);
    }

    addOnReceiveErrorCallback(callback) {
        this._onDisconnectListeners.push(callback);
    }

    removeOnReceiveErrorCallback(callback) {
        this._onDisconnectListeners = this._onDisconnectListeners.filter(listener => listener !== callback);
    }
}