simplejsble 0.0.4 → 0.0.6

package/simpleble/src/backends/linux_legacy/src/interfaces/GattCharacteristic1.cpp

@@ -0,0 +1,118 @@
+#include "simplebluezlegacy/interfaces/GattCharacteristic1.h"
+
+using namespace SimpleBluezLegacy;
+
+const SimpleDBusLegacy::AutoRegisterInterface<GattCharacteristic1> GattCharacteristic1::registry{
+    "org.bluez.GattCharacteristic1",
+    // clang-format off
+    [](std::shared_ptr<SimpleDBusLegacy::Connection> conn, const std::string& bus_name, const std::string& path, const SimpleDBusLegacy::Holder& options) -> std::shared_ptr<SimpleDBusLegacy::Interface> {
+        return std::static_pointer_cast<SimpleDBusLegacy::Interface>(std::make_shared<GattCharacteristic1>(conn, path));
+    }
+    // clang-format on
+};
+
+GattCharacteristic1::GattCharacteristic1(std::shared_ptr<SimpleDBusLegacy::Connection> conn, std::string path)
+    : SimpleDBusLegacy::Interface(conn, "org.bluez", path, "org.bluez.GattCharacteristic1") {}
+
+GattCharacteristic1::~GattCharacteristic1() { OnValueChanged.unload(); }
+
+void GattCharacteristic1::StartNotify() {
+    auto msg = create_method_call("StartNotify");
+    _conn->send_with_reply_and_block(msg);
+}
+
+void GattCharacteristic1::StopNotify() {
+    auto msg = create_method_call("StopNotify");
+    _conn->send_with_reply_and_block(msg);
+}
+
+void GattCharacteristic1::WriteValue(const ByteArray& value, WriteType type) {
+    SimpleDBusLegacy::Holder value_data = SimpleDBusLegacy::Holder::create_array();
+    for (size_t i = 0; i < value.size(); i++) {
+        value_data.array_append(SimpleDBusLegacy::Holder::create_byte(value[i]));
+    }
+
+    SimpleDBusLegacy::Holder options = SimpleDBusLegacy::Holder::create_dict();
+    if (type == WriteType::REQUEST) {
+        options.dict_append(SimpleDBusLegacy::Holder::Type::STRING, "type", SimpleDBusLegacy::Holder::create_string("request"));
+    } else if (type == WriteType::COMMAND) {
+        options.dict_append(SimpleDBusLegacy::Holder::Type::STRING, "type", SimpleDBusLegacy::Holder::create_string("command"));
+    }
+
+    auto msg = create_method_call("WriteValue");
+    msg.append_argument(value_data, "ay");
+    msg.append_argument(options, "a{sv}");
+    _conn->send_with_reply_and_block(msg);
+}
+
+ByteArray GattCharacteristic1::ReadValue() {
+    auto msg = create_method_call("ReadValue");
+
+    // NOTE: ReadValue requires an additional argument, which currently is not supported
+    SimpleDBusLegacy::Holder options = SimpleDBusLegacy::Holder::create_dict();
+    msg.append_argument(options, "a{sv}");
+
+    SimpleDBusLegacy::Message reply_msg = _conn->send_with_reply_and_block(msg);
+    SimpleDBusLegacy::Holder value = reply_msg.extract();
+    update_value(value);
+
+    return Value();
+}
+
+std::string GattCharacteristic1::UUID() {
+    // As the UUID property doesn't change, we can cache it
+    std::scoped_lock lock(_property_update_mutex);
+    return _uuid;
+}
+
+ByteArray GattCharacteristic1::Value() {
+    std::scoped_lock lock(_property_update_mutex);
+    return _value;
+}
+
+std::vector<std::string> GattCharacteristic1::Flags() {
+    std::scoped_lock lock(_property_update_mutex);
+
+    std::vector<std::string> flags;
+    for (SimpleDBusLegacy::Holder& flag : _properties["Flags"].get_array()) {
+        flags.push_back(flag.get_string());
+    }
+
+    return flags;
+}
+
+uint16_t GattCharacteristic1::MTU() {
+    std::scoped_lock lock(_property_update_mutex);
+    return _properties["MTU"].get_uint16();
+}
+
+bool GattCharacteristic1::Notifying(bool refresh) {
+    if (refresh) {
+        property_refresh("Notifying");
+    }
+
+    std::scoped_lock lock(_property_update_mutex);
+    return _properties["Notifying"].get_boolean();
+}
+
+void GattCharacteristic1::property_changed(std::string option_name) {
+    if (option_name == "UUID") {
+        std::scoped_lock lock(_property_update_mutex);
+        _uuid = _properties["UUID"].get_string();
+    } else if (option_name == "Value") {
+        update_value(_properties["Value"]);
+        OnValueChanged();
+    }
+}
+
+void GattCharacteristic1::update_value(SimpleDBusLegacy::Holder& new_value) {
+    std::scoped_lock lock(_property_update_mutex);
+    auto value_array = new_value.get_array();
+
+    char* value_data = new char[value_array.size()];
+    for (std::size_t i = 0; i < value_array.size(); i++) {
+        value_data[i] = value_array[i].get_byte();
+    }
+    _value = ByteArray(value_data, value_array.size());
+    delete[] value_data;
+}

package/simpleble/src/backends/linux_legacy/src/interfaces/GattDescriptor1.cpp

@@ -0,0 +1,78 @@
+#include "simplebluezlegacy/interfaces/GattDescriptor1.h"
+
+using namespace SimpleBluezLegacy;
+
+const SimpleDBusLegacy::AutoRegisterInterface<GattDescriptor1> GattDescriptor1::registry{
+    "org.bluez.GattDescriptor1",
+    // clang-format off
+    [](std::shared_ptr<SimpleDBusLegacy::Connection> conn, const std::string& bus_name, const std::string& path, const SimpleDBusLegacy::Holder& options) -> std::shared_ptr<SimpleDBusLegacy::Interface> {
+        return std::static_pointer_cast<SimpleDBusLegacy::Interface>(std::make_shared<GattDescriptor1>(conn, path));
+    }
+    // clang-format on
+};
+
+GattDescriptor1::GattDescriptor1(std::shared_ptr<SimpleDBusLegacy::Connection> conn, std::string path)
+    : SimpleDBusLegacy::Interface(conn, "org.bluez", path, "org.bluez.GattDescriptor1") {}
+
+GattDescriptor1::~GattDescriptor1() { OnValueChanged.unload(); }
+
+void GattDescriptor1::WriteValue(const ByteArray& value) {
+    SimpleDBusLegacy::Holder value_data = SimpleDBusLegacy::Holder::create_array();
+    for (size_t i = 0; i < value.size(); i++) {
+        value_data.array_append(SimpleDBusLegacy::Holder::create_byte(value[i]));
+    }
+
+    SimpleDBusLegacy::Holder options = SimpleDBusLegacy::Holder::create_dict();
+
+    auto msg = create_method_call("WriteValue");
+    msg.append_argument(value_data, "ay");
+    msg.append_argument(options, "a{sv}");
+    _conn->send_with_reply_and_block(msg);
+}
+
+ByteArray GattDescriptor1::ReadValue() {
+    auto msg = create_method_call("ReadValue");
+
+    // NOTE: ReadValue requires an additional argument, which currently is not supported
+    SimpleDBusLegacy::Holder options = SimpleDBusLegacy::Holder::create_dict();
+    msg.append_argument(options, "a{sv}");
+
+    SimpleDBusLegacy::Message reply_msg = _conn->send_with_reply_and_block(msg);
+    SimpleDBusLegacy::Holder value = reply_msg.extract();
+    update_value(value);
+
+    return Value();
+}
+
+std::string GattDescriptor1::UUID() {
+    // As the UUID property doesn't change, we can cache it
+    std::scoped_lock lock(_property_update_mutex);
+    return _uuid;
+}
+
+ByteArray GattDescriptor1::Value() {
+    std::scoped_lock lock(_property_update_mutex);
+    return _value;
+}
+
+void GattDescriptor1::property_changed(std::string option_name) {
+    if (option_name == "UUID") {
+        std::scoped_lock lock(_property_update_mutex);
+        _uuid = _properties["UUID"].get_string();
+    } else if (option_name == "Value") {
+        update_value(_properties["Value"]);
+        OnValueChanged();
+    }
+}
+
+void GattDescriptor1::update_value(SimpleDBusLegacy::Holder& new_value) {
+    std::scoped_lock lock(_property_update_mutex);
+    auto value_array = new_value.get_array();
+
+    char* value_data = new char[value_array.size()];
+    for (std::size_t i = 0; i < value_array.size(); i++) {
+        value_data[i] = value_array[i].get_byte();
+    }
+    _value = ByteArray(value_data, value_array.size());
+    delete[] value_data;
+}

package/simpleble/src/backends/linux_legacy/src/interfaces/GattService1.cpp

@@ -0,0 +1,28 @@
+#include "simplebluezlegacy/interfaces/GattService1.h"
+
+using namespace SimpleBluezLegacy;
+
+const SimpleDBusLegacy::AutoRegisterInterface<GattService1> GattService1::registry{
+    "org.bluez.GattService1",
+    // clang-format off
+    [](std::shared_ptr<SimpleDBusLegacy::Connection> conn, const std::string& bus_name, const std::string& path, const SimpleDBusLegacy::Holder& options) -> std::shared_ptr<SimpleDBusLegacy::Interface> {
+        return std::static_pointer_cast<SimpleDBusLegacy::Interface>(std::make_shared<GattService1>(conn, path));
+    }
+    // clang-format on
+};
+
+GattService1::GattService1(std::shared_ptr<SimpleDBusLegacy::Connection> conn, std::string path)
+    : SimpleDBusLegacy::Interface(conn, "org.bluez", path, "org.bluez.GattService1") {}
+
+std::string GattService1::UUID() {
+    // As the UUID property doesn't change, we can cache it
+    std::scoped_lock lock(_property_update_mutex);
+    return _uuid;
+}
+
+void GattService1::property_changed(std::string option_name) {
+    if (option_name == "UUID") {
+        std::scoped_lock lock(_property_update_mutex);
+        _uuid = _properties["UUID"].get_string();
+    }
+}

package/simpleble/src/backends/linux_legacy/src/interfaces/ObjectManager.cpp

@@ -0,0 +1,58 @@
+#include <simpledbuslegacy/interfaces/ObjectManager.h>
+
+using namespace SimpleDBusLegacy;
+
+const AutoRegisterInterface<ObjectManager> ObjectManager::registry{
+    "org.freedesktop.DBus.ObjectManager",
+    // clang-format off
+    [](std::shared_ptr<Connection> conn, const std::string& bus_name, const std::string& path, const Holder& options) -> std::shared_ptr<SimpleDBusLegacy::Interface> {
+        return std::static_pointer_cast<SimpleDBusLegacy::Interface>(std::make_shared<ObjectManager>(conn, bus_name, path));
+    }
+    // clang-format on
+};
+
+ObjectManager::ObjectManager(std::shared_ptr<Connection> conn, std::string bus_name, std::string path)
+    : Interface(conn, bus_name, path, "org.freedesktop.DBus.ObjectManager") {}
+
+Holder ObjectManager::GetManagedObjects(bool use_callbacks) {
+    Message query_msg = Message::create_method_call(_bus_name, _path, _interface_name, "GetManagedObjects");
+    Message reply_msg = _conn->send_with_reply_and_block(query_msg);
+    Holder managed_objects = reply_msg.extract();
+    // TODO: Remove immediate callback support.
+    if (use_callbacks) {
+        auto managed_object = managed_objects.get_dict_object_path();
+        for (auto& [path, options] : managed_object) {
+            if (InterfacesAdded) {
+                InterfacesAdded(path, options);
+            }
+        }
+    }
+    return managed_objects;
+}
+
+void ObjectManager::message_handle(Message& msg) {
+    if (msg.is_signal(_interface_name, "InterfacesAdded")) {
+        std::string path = msg.extract().get_string();
+        msg.extract_next();
+        Holder options = msg.extract();
+        if (InterfacesAdded) {
+            InterfacesAdded(path, options);
+        }
+    } else if (msg.is_signal(_interface_name, "InterfacesRemoved")) {
+        std::string path = msg.extract().get_string();
+        msg.extract_next();
+        Holder options = msg.extract();
+        if (InterfacesRemoved) {
+            InterfacesRemoved(path, options);
+        }
+        // TODO: Make a call directly to the proxy to do this?
+
+    } else if (msg.is_method_call(_interface_name, "GetManagedObjects")) {
+        // TODO: Implement this.
+        // SimpleDBus::Holder result = _proxy->path_collect();
+
+        // SimpleDBus::Message reply = SimpleDBus::Message::create_method_return(msg);
+        // reply.append_argument(result, "a{oa{sa{sv}}}");
+        // _conn->send(reply);
+    }
+}

package/simpleble/src/backends/macos/AdapterBaseMacOS.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#import <CoreBluetooth/CoreBluetooth.h>
+#import <Foundation/Foundation.h>
+
+#include <functional>
+#import "AdapterMac.h"
+
+@interface AdapterBaseMacOS : NSObject<CBCentralManagerDelegate>
+
+@property NSString* uuid;
+
+- (bool)isBluetoothEnabled;
+
+- (instancetype)init:(SimpleBLE::AdapterMac*)adapter;
+
+- (void*)underlying;
+
+- (void)powerOn;
+- (void)powerOff;
+- (bool)isPowered;
+
+- (void)scanStart;
+- (void)scanStop;
+- (bool)scanIsActive;
+
+- (NSString*)address;
+
+@end

package/simpleble/src/backends/macos/AdapterBaseMacOS.mm

@@ -0,0 +1,235 @@
+#import "AdapterBaseMacOS.h"
+#import "TargetConditionals.h"
+
+#import <fmt/core.h>
+#import <simpleble/Exceptions.h>
+#import "LoggingInternal.h"
+#import "Utils.h"
+
+#define WAIT_UNTIL_FALSE(obj, var)                \
+    do {                                          \
+        BOOL _tmpVar = YES;                       \
+        while (_tmpVar) {                         \
+            [NSThread sleepForTimeInterval:0.01]; \
+            @synchronized(obj) {                  \
+                _tmpVar = (var);                  \
+            }                                     \
+        }                                         \
+    } while (0)
+
+#define WAIT_UNTIL_FALSE_WITH_TIMEOUT(obj, var, timeout)                              \
+    do {                                                                              \
+        BOOL _tmpVar = YES;                                                           \
+        NSDate* endDate = [NSDate dateWithTimeInterval:timeout sinceDate:NSDate.now]; \
+        while (_tmpVar && [NSDate.now compare:endDate] == NSOrderedAscending) {       \
+            [NSThread sleepForTimeInterval:0.01];                                     \
+            @synchronized(obj) {                                                      \
+                _tmpVar = (var);                                                      \
+            }                                                                         \
+        }                                                                             \
+    } while (0)
+
+#if TARGET_OS_OSX
+extern "C" {
+// Credit to the Chromium project for finding and documenting this undocumented API.
+//
+// Undocumented IOBluetooth Preference API [1]. Used by `blueutil` [2] and
+// `Karabiner` [3] to programmatically control the Bluetooth state. Calling the
+// method with `1` powers the adapter on, calling it with `0` powers it off.
+// Using this API has the same effect as turning Bluetooth on or off using the
+// macOS System Preferences [4], and will effect all adapters.
+//
+// [1] https://goo.gl/Gbjm1x
+// [2] http://www.frederikseiffert.de/blueutil/
+// [3] https://pqrs.org/osx/karabiner/
+// [4] https://support.apple.com/kb/PH25091
+void IOBluetoothPreferenceSetControllerPowerState(int state);
+}
+#endif
+@interface AdapterBaseMacOS () {
+}
+
+// Private properties
+@property() SimpleBLE::AdapterMac* adapter;
+@property(strong) dispatch_queue_t centralManagerQueue;
+@property(strong) CBCentralManager* centralManager;
+
+@end
+
+@implementation AdapterBaseMacOS
+
+- (bool)isBluetoothEnabled {
+    return CBCentralManager.authorization == CBManagerAuthorizationAllowedAlways && _centralManager.state == CBManagerStatePoweredOn;
+}
+
+- (instancetype)init:(SimpleBLE::AdapterMac*)adapter {
+    self = [super init];
+    if (self) {
+        _adapter = adapter;
+        _uuid = @"39a76676-2788-46c9-afa0-f0c0c31e6fd9";
+
+        // Use a high-priority queue to ensure that events are processed immediately.
+        dispatch_queue_attr_t qos = dispatch_queue_attr_make_with_qos_class(DISPATCH_QUEUE_SERIAL, QOS_CLASS_USER_INITIATED, -1);
+        _centralManagerQueue = dispatch_queue_create("AdapterBaseMacOS.centralManagerQueue", qos);
+        _centralManager = [[CBCentralManager alloc] initWithDelegate:self queue:_centralManagerQueue options:nil];
+
+        // Wait for the central manager state to be updated for up to 5 seconds.
+        NSDate* endDate = [NSDate dateWithTimeInterval:5.0 sinceDate:NSDate.now];
+        while (_centralManager.state == CBManagerStateUnknown && [NSDate.now compare:endDate] == NSOrderedAscending) {
+            [NSThread sleepForTimeInterval:0.01];
+        }
+    }
+    return self;
+}
+
+- (void*)underlying {
+    return (__bridge void*)self.centralManager;
+}
+
+- (void)powerOn {
+#if TARGET_OS_OSX
+    IOBluetoothPreferenceSetControllerPowerState(1);
+
+    // Wait for the central manager state to be updated for up to 5 seconds.
+    NSDate* endDate = [NSDate dateWithTimeInterval:5.0 sinceDate:NSDate.now];
+    while (_centralManager.state != CBManagerStatePoweredOn && [NSDate.now compare:endDate] == NSOrderedAscending) {
+        [NSThread sleepForTimeInterval:0.01];
+    }
+#endif
+}
+
+- (void)powerOff {
+#if TARGET_OS_OSX
+    IOBluetoothPreferenceSetControllerPowerState(0);
+
+    // Wait for the central manager state to be updated for up to 5 seconds.
+    NSDate* endDate = [NSDate dateWithTimeInterval:5.0 sinceDate:NSDate.now];
+    while (_centralManager.state != CBManagerStatePoweredOff && [NSDate.now compare:endDate] == NSOrderedAscending) {
+        [NSThread sleepForTimeInterval:0.01];
+    }
+#endif
+}
+
+- (bool)isPowered {
+    return self.centralManager.state == CBManagerStatePoweredOn;
+}
+
+- (void)scanStart {
+    [self.centralManager scanForPeripheralsWithServices:nil options:@{CBCentralManagerScanOptionAllowDuplicatesKey : @YES}];
+}
+
+- (void)scanStop {
+    [self.centralManager stopScan];
+}
+
+- (bool)scanIsActive {
+    return [self.centralManager isScanning];
+}
+
+- (NSString*)address {
+    return self.uuid;
+}
+
+#pragma mark - CBCentralManagerDelegate
+
+- (void)centralManagerDidUpdateState:(CBCentralManager*)central {
+    switch (central.state) {
+        case CBManagerStateUnknown:
+            // NSLog(@"CBManagerStateUnknown!\n");
+            break;
+        case CBManagerStateResetting:
+            // NSLog(@"CBManagerStateResetting!\n");
+            break;
+        case CBManagerStateUnsupported:
+            // NSLog(@"CBManagerStateUnsupported!\n");
+            break;
+        case CBManagerStateUnauthorized:
+            // NSLog(@"CBManagerStateUnauthorized!\n");
+            break;
+        case CBManagerStatePoweredOff:
+            // NSLog(@"CBManagerStatePoweredOff!\n");
+            // NOTE: Notify the user that the Bluetooth adapter is turned off.
+            break;
+        case CBManagerStatePoweredOn:
+            // NSLog(@"CBManagerStatePoweredOn!\n");
+            // NOTE: This state is required to be able to operate CoreBluetooth.
+            break;
+    }
+}
+
+- (void)centralManager:(CBCentralManager*)central
+    didDiscoverPeripheral:(CBPeripheral*)peripheral
+        advertisementData:(NSDictionary<NSString*, id>*)advertisementData
+                     RSSI:(NSNumber*)RSSI {
+    SimpleBLE::advertising_data_t advertisingData;
+
+    // Parse advertisementData to extract all relevant information
+
+    // TODO: Do we need to extract the name as well?
+    // NSString* advertisingName = advertisementData[CBAdvertisementDataLocalNameKey];
+
+    // Check if the peripheral is connectable
+    NSNumber* isConnectable = advertisementData[CBAdvertisementDataIsConnectable];
+    advertisingData.connectable = isConnectable != nil && isConnectable.boolValue == YES;
+
+    // Extract RSSI
+    advertisingData.rssi = [RSSI shortValue];
+
+    // Extract Tx Power
+    NSNumber* txPower = [advertisementData objectForKey:CBAdvertisementDataTxPowerLevelKey];
+    if (txPower == nil) {
+        advertisingData.tx_power = INT16_MIN;
+    } else {
+        advertisingData.tx_power = [txPower shortValue];
+    }
+
+    // Extract Manufacturer Data
+    NSData* rawManufacturerData = advertisementData[CBAdvertisementDataManufacturerDataKey];
+    if (rawManufacturerData != nil) {
+        const char* manufacturerDataBytes = (const char*)rawManufacturerData.bytes;
+
+        uint16_t manufacturerID = *((uint16_t*)manufacturerDataBytes);
+        SimpleBLE::ByteArray manufacturerData = SimpleBLE::ByteArray(&manufacturerDataBytes[2], (size_t)(rawManufacturerData.length - 2));
+        advertisingData.manufacturer_data[manufacturerID] = manufacturerData;
+    }
+
+    // Extract Service Data
+    NSDictionary* rawServiceDataDict = advertisementData[CBAdvertisementDataServiceDataKey];
+    for (CBUUID* serviceUuid in rawServiceDataDict) {
+        NSData* rawServiceData = rawServiceDataDict[serviceUuid];
+        const char* rawServiceDataBytes = (const char*)rawServiceData.bytes;
+        size_t rawServiceDataLength = (size_t)rawServiceData.length;
+        SimpleBLE::ByteArray serviceData = SimpleBLE::ByteArray(rawServiceDataBytes, rawServiceDataLength);
+        advertisingData.service_data[uuidToSimpleBLE(serviceUuid)] = serviceData;
+    }
+
+    // Extract Service UUIDs
+    NSArray* services = advertisementData[CBAdvertisementDataServiceUUIDsKey];
+    if (services != nil) {
+        for (CBUUID* serviceUuid in services) {
+            advertisingData.service_data[uuidToSimpleBLE(serviceUuid)] = SimpleBLE::ByteArray();
+        }
+    }
+
+    _adapter->delegate_did_discover_peripheral((__bridge void*)peripheral, (__bridge void*)self.centralManager, advertisingData);
+}
+
+- (void)centralManager:(CBCentralManager*)central didConnectPeripheral:(CBPeripheral*)peripheral {
+    _adapter->delegate_did_connect_peripheral((__bridge void*)peripheral);
+}
+
+- (void)centralManager:(CBCentralManager*)central didDisconnectPeripheral:(CBPeripheral*)peripheral error:(NSError*)error {
+    // NSLog(@"didDisconnectPeripheral (A): %@, error: %@", peripheral, error);
+    _adapter->delegate_did_disconnect_peripheral((__bridge void*)peripheral, (__bridge void*)error);
+}
+
+- (void)centralManager:(CBCentralManager*)central didFailToConnectPeripheral:(CBPeripheral*)peripheral error:(NSError*)error {
+    _adapter->delegate_did_fail_to_connect_peripheral((__bridge void*)peripheral, (__bridge void*)error);
+}
+
+- (void)centralManager:(CBCentralManager*)central didDisconnectPeripheral:(CBPeripheral*)peripheral timestamp:(CFAbsoluteTime)timestamp isReconnecting:(BOOL)isReconnecting error:(NSError*)error {
+    // NSLog(@"didDisconnectPeripheral (B): %@, error: %@", peripheral, error);
+    _adapter->delegate_did_disconnect_peripheral((__bridge void*)peripheral, (__bridge void*)error);
+}
+
+@end

package/simpleble/src/backends/macos/AdapterMac.h

@@ -0,0 +1,78 @@
+#pragma once
+
+#include <simpleble/Exceptions.h>
+#include <simpleble/Types.h>
+
+#include "AdapterBase.h"
+#include "AdapterBaseTypes.h"
+
+#include <kvn_safe_callback.hpp>
+
+#include <functional>
+#include <map>
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace SimpleBLE {
+
+class Peripheral;
+class PeripheralBase;
+class PeripheralMac;
+
+/**
+  This class definition acts as an abstraction layer between C++ and Objective-C.
+  If Objective-C headers are included here, everything blows up.
+ */
+class AdapterMac : public AdapterBase {
+  public:
+    AdapterMac();
+    virtual ~AdapterMac();
+
+    virtual void* underlying() const override;
+
+    virtual std::string identifier() override;
+    virtual BluetoothAddress address() override;
+
+    virtual void power_on() override;
+    virtual void power_off() override;
+    virtual bool is_powered() override;
+
+    virtual void scan_start() override;
+    virtual void scan_stop() override;
+    virtual void scan_for(int timeout_ms) override;
+    virtual bool scan_is_active() override;
+    virtual std::vector<std::shared_ptr<PeripheralBase>> scan_get_results() override;
+
+    virtual std::vector<std::shared_ptr<PeripheralBase>> get_paired_peripherals() override;
+
+    virtual bool bluetooth_enabled() override;
+
+    void delegate_did_discover_peripheral(void* opaque_peripheral, void* opaque_adapter,
+                                          advertising_data_t advertising_data);
+    void delegate_did_connect_peripheral(void* opaque_peripheral);
+    void delegate_did_fail_to_connect_peripheral(void* opaque_peripheral, void* opaque_error);
+    void delegate_did_disconnect_peripheral(void* opaque_peripheral, void* opaque_error);
+
+  protected:
+    /**
+     * Holds a pointer to the Objective-C representation of this object.
+     */
+    void* opaque_internal_;
+
+    /**
+     * Holds a map of objective-c peripheral objects to their corresponding C++ objects.
+     *
+     * Whenever some sort of event happens on a peripheral, we need to find
+     * the corresponding PeripheralBase object. The PeripheralBase objects
+     * can be wrapped in disposable Peripheral objects, so there is no need
+     * be careful with them.
+     */
+    std::map<void*, std::shared_ptr<PeripheralMac>> peripherals_;
+    std::map<void*, std::shared_ptr<PeripheralMac>> seen_peripherals_;
+
+  private:
+    BluetoothAddress address() const;
+};
+
+}  // namespace SimpleBLE