@stoprocent/noble 1.9.2-16

package/lib/mac/src/objc_cpp.h

@@ -0,0 +1,26 @@
+#pragma once
+
+#include <string>
+#include <vector>
+#import <Foundation/Foundation.h>
+#import <CoreBluetooth/CoreBluetooth.h>
+#include "peripheral.h"
+
+#define IF(type, var, code) type var = code; if(var)
+
+#if defined(MAC_OS_X_VERSION_10_13)
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wunguarded-availability"
+    std::string stateToString(CBManagerState state);
+#pragma clang diagnostic pop
+#else
+    std::string stateToString(CBCentralManagerState state);
+#endif
+
+
+NSString* getNSUuid(CBPeripheral* peripheral);
+std::string getUuid(CBPeripheral* peripheral);
+std::string getAddress(std::string uuid, AddressType* addressType);
+std::vector<std::string> getServices(NSArray<CBService*>* services);
+std::vector<std::pair<std::string, std::vector<std::string>>> getCharacteristics(NSArray<CBCharacteristic*>* characteristics);
+std::vector<std::string> getDescriptors(NSArray<CBDescriptor*>* descriptors);

package/lib/mac/src/objc_cpp.mm

@@ -0,0 +1,126 @@
+//
+//  objc_cpp.mm
+//  noble-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
+
+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::pair<std::string, bool> name;
+    std::pair<int, bool> txPowerLevel;
+    std::pair<Data, bool> manufacturerData;
+    std::pair<std::vector<std::pair<std::string, Data>>, bool> serviceData;
+    std::pair<std::vector<std::string>, bool> serviceUuids;
+};

package/lib/manufacture.js

@@ -0,0 +1,48 @@
+const path = require('path');
+
+const tryRequire = modulePath => {
+  try {
+    return require(modulePath);
+  } catch (e) {
+    console.error(`ERROR:\tCould not load manufacturer list from "${modulePath}".`);
+    console.error(`\tPlease see "${path.join(__dirname, '..', 'scripts', 'manufactures', 'README.md')}" for instructions.`);
+    return {};
+  }
+};
+
+const hexValues = tryRequire('./manufactures-hex.json');
+const decValues = tryRequire('./manufactures-dec.json');
+
+function Manufacture (noble, data) {
+  this._noble = noble;
+
+  this.name = null;
+  this.data = data;
+
+  try {
+    const tmp = JSON.parse(JSON.stringify(data)).data;
+
+    if (Array.isArray(tmp)) {
+      this.name = decValues[tmp[0]];
+    }
+  } catch (e) {
+    console.error(e);
+  }
+}
+
+Manufacture.prototype.toString = function () {
+  return JSON.stringify({
+    name: this.name,
+    data: JSON.parse(JSON.stringify(this.data))
+  });
+};
+
+Manufacture.nameFromHex = function (hexValue) {
+  return hexValues[hexValue] || undefined;
+};
+
+Manufacture.nameFromDec = function (decValue) {
+  return decValues[decValue] || undefined;
+};
+
+module.exports = Manufacture;