@stoprocent/bleno 0.7.0

package/lib/mac/src/objc_cpp.mm

@@ -0,0 +1,144 @@
+//
+//  objc_cpp.mm
+//  bleno-mac-native
+//
+//  Created by Georg Vienna on 30.08.18.
+//
+#include "objc_cpp.h"
+
+#if defined(MAC_OS_X_VERSION_10_13)
+//#pragma clang diagnostic push
+//#pragma clang diagnostic ignored "-Wunguarded-availability"
+//std::string stateToString(CBManagerState state)
+//{
+//    switch(state) {
+//        case CBManagerStatePoweredOff:
+//            return "poweredOff";
+//        case CBManagerStatePoweredOn:
+//            return "poweredOn";
+//        case CBManagerStateResetting:
+//            return "resetting";
+//        case CBManagerStateUnauthorized:
+//            return "unauthorized";
+//        case CBManagerStateUnknown:
+//            return "unknown";
+//        case CBManagerStateUnsupported:
+//            return "unsupported";
+//    }
+//    return "unknown";
+//}
+//#pragma clang diagnostic pop
+
+// In the 10.13 SDK, CBPeripheral became a subclass of CBPeer, which defines
+// -[CBPeer identifier] as partially available. Pretend it still exists on
+// CBPeripheral. At runtime the implementation on CBPeer will be invoked.
+@interface CBPeripheral (HighSierraSDK)
+@property(readonly, nonatomic) NSUUID* identifier;
+@end
+#else
+std::string stateToString(CBCentralManagerState state)
+{
+    switch(state) {
+        case CBCentralManagerStatePoweredOff:
+            return "poweredOff";
+        case CBCentralManagerStatePoweredOn:
+            return "poweredOn";
+        case CBCentralManagerStateResetting:
+            return "resetting";
+        case CBCentralManagerStateUnauthorized:
+            return "unauthorized";
+        case CBCentralManagerStateUnknown:
+            return "unknown";
+        case CBCentralManagerStateUnsupported:
+            return "unsupported";
+    }
+    return "unknown";
+}
+#endif
+
+std::string StringFromCBPeripheralState(CBManagerState state) {
+    switch(state) {
+        case CBManagerStatePoweredOff:
+            return "poweredOff";
+        case CBManagerStatePoweredOn:
+            return "poweredOn";
+        case CBManagerStateUnauthorized:
+            return "unauthorized";
+        case CBManagerStateUnsupported:
+            return "unsupported";
+        case CBManagerStateResetting:
+            return "resetting";
+        case CBManagerStateUnknown:
+        default:
+            return "unknown";
+    }
+}
+
+NSString* getNSUuid(CBPeripheral* peripheral) {
+    return peripheral.identifier.UUIDString;
+}
+
+std::string getUuid(CBPeripheral* peripheral) {
+    return std::string([peripheral.identifier.UUIDString UTF8String]);
+}
+
+std::string getAddress(std::string uuid, AddressType* addressType) {
+    NSString* deviceUuid = [[NSString alloc] initWithCString:uuid.c_str() encoding:NSASCIIStringEncoding];
+    IF(NSDictionary*, plist, [NSDictionary dictionaryWithContentsOfFile:@"/Library/Preferences/com.apple.Bluetooth.plist"]) {
+        IF(NSDictionary*, cache, [plist objectForKey:@"CoreBluetoothCache"]) {
+            IF(NSDictionary*, entry, [cache objectForKey:deviceUuid]) {
+                IF(NSNumber*, type, [entry objectForKey:@"DeviceAddressType"]) {
+                    *addressType = [type boolValue] ? RANDOM : PUBLIC;
+                }
+                IF(NSString*, address, [entry objectForKey:@"DeviceAddress"]) {
+                    return [address UTF8String];
+                }
+            }
+        }
+    }
+    return "";
+}
+
+std::vector<std::string> getServices(NSArray<CBService*>* services) {
+    std::vector<std::string> result;
+    if(services) {
+        for (CBService* service in services) {
+            result.push_back([[service.UUID UUIDString] UTF8String]);
+        }
+    }
+    return result;
+}
+
+#define TEST_PROP(type, str) if((characteristic.properties & type) == type) { properties.push_back(str); }
+
+std::vector<std::pair<std::string, std::vector<std::string>>> getCharacteristics(NSArray<CBCharacteristic*>* characteristics) {
+    std::vector<std::pair<std::string, std::vector<std::string>>> result;
+    if(characteristics) {
+        for (CBCharacteristic* characteristic in characteristics) {
+            auto uuid = [[characteristic.UUID UUIDString] UTF8String];
+            auto properties = std::vector<std::string>();
+            TEST_PROP(CBCharacteristicPropertyBroadcast, "broadcast");
+            TEST_PROP(CBCharacteristicPropertyRead, "read");
+            TEST_PROP(CBCharacteristicPropertyWriteWithoutResponse, "writeWithoutResponse");
+            TEST_PROP(CBCharacteristicPropertyWrite, "write");
+            TEST_PROP(CBCharacteristicPropertyNotify, "notify");
+            TEST_PROP(CBCharacteristicPropertyIndicate, "indicate");
+            TEST_PROP(CBCharacteristicPropertyAuthenticatedSignedWrites, "authenticatedSignedWrites");
+            TEST_PROP(CBCharacteristicPropertyExtendedProperties, "extendedProperties");
+            TEST_PROP(CBCharacteristicPropertyNotifyEncryptionRequired, "notifyEncryptionRequired");
+            TEST_PROP(CBCharacteristicPropertyIndicateEncryptionRequired, "indicateEncryptionRequired");
+            result.push_back(std::make_pair(uuid, properties));
+        }
+    }
+    return result;
+}
+
+std::vector<std::string> getDescriptors(NSArray<CBDescriptor*>* descriptors) {
+    std::vector<std::string> result;
+    if(descriptors) {
+        for (CBDescriptor* descriptor in descriptors) {
+            result.push_back([[descriptor.UUID UUIDString] UTF8String]);
+        }
+    }
+    return result;
+}

package/lib/mac/src/peripheral.h

@@ -0,0 +1,23 @@
+#pragma once
+
+using Data = std::vector<uint8_t>;
+
+enum AddressType {
+    PUBLIC,
+    RANDOM,
+    UNKNOWN,
+};
+
+class Peripheral {
+public:
+    Peripheral() : address("unknown"), addressType(UNKNOWN), connectable(false) {
+    }
+    std::string address;
+    AddressType addressType;
+    bool connectable;
+    std::string name;
+    int txPowerLevel;
+    Data manufacturerData;
+    std::vector<std::pair<std::string, Data>> serviceData;
+    std::vector<std::string> serviceUuids;
+};

package/lib/primary-service.js

@@ -0,0 +1,19 @@
+const { EventEmitter } = require('events');
+const UuidUtil = require('./uuid-util');
+
+class PrimaryService extends EventEmitter {
+  constructor (options) {
+    super();
+    this.uuid = UuidUtil.removeDashes(options.uuid);
+    this.characteristics = options.characteristics || [];
+  }
+
+  toString () {
+    return JSON.stringify({
+      uuid: this.uuid,
+      characteristics: this.characteristics
+    });
+  }
+}
+
+module.exports = PrimaryService;

package/lib/resolve-bindings.js

@@ -0,0 +1,19 @@
+const os = require('os');
+
+module.exports = function (options = {}) {
+  const platform = os.platform();
+
+  if (
+    platform === 'linux' ||
+    platform === 'freebsd' ||
+    platform === 'win32' ||
+    platform === 'android' ||
+    process.env.BLUETOOTH_HCI_SOCKET_UART_PORT ||
+    process.env.BLUETOOTH_HCI_SOCKET_FORCE_UART) {
+    return new (require('./hci-socket/bindings'))(options);
+  } else if (platform === 'darwin') {
+    return new (require('./mac/bindings'))(options);
+  } else {
+    throw new Error('Unsupported platform ' + platform);
+  }
+};

package/lib/uuid-util.js

@@ -0,0 +1,7 @@
+module.exports.removeDashes = function (uuid) {
+  if (uuid) {
+    uuid = uuid.replace(/-/g, '');
+  }
+
+  return uuid;
+};

package/package.json

@@ -0,0 +1,77 @@
+{
+  "name": "@stoprocent/bleno",
+  "version": "0.7.0",
+  "description": "A Node.js module for implementing BLE (Bluetooth Low Energy) peripherals",
+  "main": "./index.js",
+  "types": "./index.d.ts",
+  "engines": {
+    "node": ">=14"
+  },
+  "os": [
+    "darwin",
+    "linux",
+    "android",
+    "freebsd",
+    "win32"
+  ],
+  "scripts": {
+    "install": "node-gyp-build",
+    "lint": "eslint \"**/*.js\"",
+    "lint-fix": "eslint \"**/*.js\" --fix",
+    "prebuildify": "prebuildify --napi --target 14.0.0 --force --strip --verbose",
+    "prebuildify-cross": "prebuildify-cross --napi --target 14.0.0 --force --strip --verbose",
+    "semantic-release": "semantic-release",
+    "pretest": "npm run rebuild",
+    "rebuild": "node-gyp rebuild",
+    "coverage": "nyc npm test && nyc report --reporter=text-lcov > .nyc_output/lcov.info",
+    "test": "cross-env NODE_ENV=test mocha --recursive \"test/*.test.js\" \"test/**/*.test.js\" --exit"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/stoprocent/bleno"
+  },
+  "keywords": [
+    "BLE",
+    "Bluetooth",
+    "Bluetooth Low Energy",
+    "Bluetooth Smart",
+    "peripheral"
+  ],
+  "author": "Sandeep Mistry <sandeep.mistry@gmail.com>",
+  "maintainers": [
+    "Marek Serafin <marek@serafin.email>"
+  ],
+  "license": "MIT",
+  "readmeFilename": "README.md",
+  "devDependencies": {
+    "@semantic-release/exec": "^6.0.3",
+    "cross-env": "^7.0.3",
+    "jshint": "~2.13.6",
+    "eslint": "^8.31.0",
+    "eslint-config-semistandard": "^17.0.0",
+    "eslint-config-standard": "^17.0.0",
+    "eslint-plugin-import": "^2.26.0",
+    "eslint-plugin-n": "^15.6.0",
+    "eslint-plugin-promise": "^6.1.1",
+    "mocha": "~10.2.0",
+    "node-blink1": "~0.5.1",
+    "nyc": "^15.1.0",
+    "prebuildify": "^5.0.1",
+    "prebuildify-cross": "5.0.0",
+    "should": "~13.2.3"
+  },
+  "dependencies": {
+    "debug": "^4.3.4",
+    "napi-thread-safe-callback": "^0.0.6",
+    "node-addon-api": "^4.3.0",
+    "node-gyp-build": "^4.5.0"
+  },
+  "optionalDependencies": {
+    "@stoprocent/bluetooth-hci-socket": "^1.1.3",
+    "bplist-parser": "0.3.2",
+    "xpc-connect": "^3.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/test/characteristic.test.js

@@ -0,0 +1,174 @@
+/* jshint mocha: true */
+
+const should = require('should');
+
+const Characteristic = require('../lib/characteristic');
+
+describe('Characteristic', function () {
+  const mockUuid = 'mockuuid';
+  const mockProperties = ['property1', 'property2', 'property3'];
+  const mockSecure = ['secure1', 'secure2', 'secure3'];
+  const mockValue = Buffer.from('mock value');
+  const mockDescriptors = [{}, {}, {}];
+
+  const mockOnReadRequest = function () {};
+  const mockOnWriteRequest = function () {};
+  const mockOnSubscribe = function () {};
+  const mockOnUnsubscribe = function () {};
+  const mockOnNotify = function () {};
+  const mockOnIndicate = function () {};
+
+  const mockMaxValueSize = 20;
+  const mockUpdateValueCallback = function () {};
+
+  it('should create with uuid option', function () {
+    const characteristic = new Characteristic({
+      uuid: mockUuid
+    });
+
+    characteristic.uuid.should.equal(mockUuid);
+
+    Array.isArray(characteristic.properties).should.equal(true);
+    characteristic.properties.length.should.equal(0);
+
+    Array.isArray(characteristic.secure).should.equal(true);
+    characteristic.secure.length.should.equal(0);
+
+    should(characteristic.value).equal(null);
+
+    Array.isArray(characteristic.descriptors).should.equal(true);
+    characteristic.descriptors.length.should.equal(0);
+  });
+
+  it('should create with properties option', function () {
+    const characteristic = new Characteristic({
+      properties: mockProperties
+    });
+
+    characteristic.properties.should.equal(mockProperties);
+  });
+
+  it('should create with secure option', function () {
+    const characteristic = new Characteristic({
+      secure: mockSecure
+    });
+
+    characteristic.secure.should.equal(mockSecure);
+  });
+
+  it('should create with value option', function () {
+    const characteristic = new Characteristic({
+      properties: ['read'],
+      value: mockValue
+    });
+
+    characteristic.value.should.equal(mockValue);
+  });
+
+  it('should not create with value option and non-read properties', function () {
+    (function () {
+      // eslint-disable-next-line no-unused-vars
+      const characteristic = new Characteristic({
+        properties: ['write'],
+        value: mockValue
+      });
+    }).should.throw();
+  });
+
+  it('should create with descriptors option', function () {
+    const characteristic = new Characteristic({
+      descriptors: mockDescriptors
+    });
+
+    characteristic.descriptors.should.equal(mockDescriptors);
+  });
+
+  it('should create with onReadRequest option', function () {
+    const characteristic = new Characteristic({
+      onReadRequest: mockOnReadRequest
+    });
+
+    characteristic.onReadRequest.should.equal(mockOnReadRequest);
+  });
+
+  it('should create with onWriteRequest option', function () {
+    const characteristic = new Characteristic({
+      onWriteRequest: mockOnWriteRequest
+    });
+
+    characteristic.onWriteRequest.should.equal(mockOnWriteRequest);
+  });
+
+  it('should create with onSubscribe option', function () {
+    const characteristic = new Characteristic({
+      onSubscribe: mockOnSubscribe
+    });
+
+    characteristic.onSubscribe.should.equal(mockOnSubscribe);
+  });
+
+  it('should create with onUnsubscribe option', function () {
+    const characteristic = new Characteristic({
+      onUnsubscribe: mockOnUnsubscribe
+    });
+
+    characteristic.onUnsubscribe.should.equal(mockOnUnsubscribe);
+  });
+
+  it('should create with onNotify option', function () {
+    const characteristic = new Characteristic({
+      onNotify: mockOnNotify
+    });
+
+    characteristic.onNotify.should.equal(mockOnNotify);
+  });
+
+  it('should create with onIndicate option', function () {
+    const characteristic = new Characteristic({
+      onIndicate: mockOnIndicate
+    });
+
+    characteristic.onIndicate.should.equal(mockOnIndicate);
+  });
+
+  it('should toString', function () {
+    const characteristic = new Characteristic({
+      uuid: mockUuid
+    });
+
+    characteristic.toString().should.equal('{"uuid":"mockuuid","properties":[],"secure":[],"value":null,"descriptors":[]}');
+  });
+
+  it('should handle read request', function (done) {
+    const characteristic = new Characteristic({});
+
+    characteristic.emit('readRequest', 0, function (result, data) {
+      result.should.equal(0x0e);
+      should(data).equal(null);
+
+      done();
+    });
+  });
+
+  it('should handle write request', function (done) {
+    const characteristic = new Characteristic({});
+
+    characteristic.emit('writeRequest', Buffer.alloc(0), 0, false, function (result) {
+      result.should.equal(0x0e);
+
+      done();
+    });
+  });
+
+  it('should handle unsubscribe', function () {
+    const characteristic = new Characteristic({});
+
+    characteristic.maxValueSize = mockMaxValueSize;
+    characteristic.updateValueCallback = mockUpdateValueCallback;
+
+    characteristic.emit('unsubscribe');
+
+    should(characteristic.maxValueSize).equal(null);
+    should(characteristic.updateValueCallback).equal(null);
+  });
+});

package/test/descriptor.test.js

@@ -0,0 +1,46 @@
+/* jshint mocha: true */
+const Descriptor = require('../lib/descriptor');
+
+describe('Descriptor', function () {
+  const mockUuid = 'mockuuid';
+  const mockValue = Buffer.from('mock value');
+
+  it('should create with uuid option', function () {
+    const descriptor = new Descriptor({
+      uuid: mockUuid
+    });
+
+    descriptor.uuid.should.equal(mockUuid);
+
+    Buffer.isBuffer(descriptor.value).should.equal(true);
+    descriptor.value.length.should.equal(0);
+  });
+
+  it('should create with value option', function () {
+    const descriptor = new Descriptor({
+      value: mockValue
+    });
+
+    descriptor.value.should.equal(mockValue);
+  });
+
+  describe('toString', function () {
+    it('should hex buffer value', function () {
+      const descriptor = new Descriptor({
+        uuid: mockUuid,
+        value: mockValue
+      });
+
+      descriptor.toString().should.equal('{"uuid":"mockuuid","value":"6d6f636b2076616c7565"}');
+    });
+
+    it('should leave non-buffer value alone', function () {
+      const descriptor = new Descriptor({
+        uuid: mockUuid,
+        value: 'mock value'
+      });
+
+      descriptor.toString().should.equal('{"uuid":"mockuuid","value":"mock value"}');
+    });
+  });
+});

package/with-bindings.js

@@ -0,0 +1,5 @@
+const Bleno = require('./lib/bleno');
+
+module.exports = function (bindings) {
+  return new Bleno(bindings);
+};

package/with-custom-binding.js

@@ -0,0 +1,6 @@
+module.exports = function (options) {
+  const Bleno = require('./lib/bleno');
+  const bindings = require('./lib/resolve-bindings')(options);
+
+  return new Bleno(bindings);
+};