Decouple BLE observers from nordic

Issue #36

ble::profile::connectable: add gatts, gattc classes

     struct ble::profile::connectable::gatts
     Aggregates ble::gatts::event_observer
                ble::gatts::operations.

     struct ble::profile::connectable::gattc
     Aggregates ble::gatts::event_observer,
                ble::gatts::operations,
                ble::gattc::service_builder.

Instead of registering each observer, wrapped in a
nordic observer template, with each nodic BLE event
observable register just the object
ble::profile::connectable with the BLE stack events.

ble/gap_connection.cc

@@ -15,14 +15,14 @@ namespace gap
                              uint8_t                    peer_address_id)
     {
         this->set_handle(connection_handle);
-        this->get_connecteable()->connection().get_negotiation_state().clear_all_pending();
+        this->get_connecteable()->gap.get_negotiation_state().clear_all_pending();
     }
 
     void connection::disconnect(uint16_t                connection_handle,
                                 ble::hci::error_code    error_code)
     {
         this->set_handle(ble::gap::handle_invalid);
-        this->get_connecteable()->connection().get_negotiation_state().clear_all_pending();
+        this->get_connecteable()->gap.get_negotiation_state().clear_all_pending();
     }
 
 } // namespace gap

ble/gap_event_logger.h

@@ -24,7 +24,7 @@ class event_logger: public ble::gap::event_observer
 public:
     logger::level log_level;
 
-    virtual ~event_logger() override               = default;
+    virtual ~event_logger() override              = default;
 
     event_logger(event_logger const&)             = delete;
     event_logger(event_logger &&)                 = delete;

ble/gap_event_observable.h

@@ -0,0 +1,65 @@
+/**
+ * @file ble/gap_event_observable.h
+ * @copyright (c) 2018, natersoz. Distributed under the Apache 2.0 license.
+ */
+
+#pragma once
+
+#include "ble/gap_event_observer.h"
+
+namespace ble
+{
+namespace gap
+{
+
+class event_observable
+{
+    virtual ~event_observable()                           = default;
+
+    event_observable()                                    = default;
+    event_observable(event_observable const&)             = delete;
+    event_observable(event_observable &&)                 = delete;
+    event_observable& operator=(event_observable const&)  = delete;
+    event_observable& operator=(event_observable&&)       = delete;
+
+    void attach(event_observer& observer)
+    {
+        if (not observer.hook.is_linked())
+        {
+            this->observer_list.push_back(observer);
+        }
+    }
+
+    void attach_first(event_observer& observer)
+    {
+        if (not observer.hook.is_linked())
+        {
+            this->observer_list.push_front(observer);
+        }
+    }
+
+    void detach(event_observer& observer)
+    {
+        if (observer.hook.is_linked())
+        {
+            observer.hook.unlink();
+        }
+    }
+
+private:
+    using list_type = boost::intrusive::list<
+        event_observer,
+        boost::intrusive::constant_time_size<false>,
+        boost::intrusive::member_hook<
+            event_observer,
+            typename event_observer::list_hook_type,
+            &event_observer::hook>
+    >;
+
+    list_type observer_list;
+};
+
+} // namespace gap
+} // namespace ble
+
+

ble/gatts_event_observer.cc

@@ -41,7 +41,7 @@ void event_observer::write(uint16_t            conection_handle,
         return;
     }
 
-    if (connectable->connection().get_connection_handle() != conection_handle)
+    if (connectable->gap.get_connection_handle() != conection_handle)
     {
         /// This GATTS request is from a different connection.
         /// @todo Is it normal for this connection to get notified of other
@@ -52,7 +52,7 @@ void event_observer::write(uint16_t            conection_handle,
     }
 
     ble::gatt::characteristic *characteristic =
-        connectable->service_container().find_characteristic(attribute_handle);
+        connectable->service_container.find_characteristic(attribute_handle);
     if (not characteristic)
     {
         logger.warn("GATTS write(0x%04x, 0x%04x): invalid handle",
@@ -92,7 +92,7 @@ void event_observer::write_cancel(uint16_t          conection_handle,
         return;
     }
 
-    if (connectable->connection().get_connection_handle() != conection_handle)
+    if (connectable->gap.get_connection_handle() != conection_handle)
     {
         // This GATTS request is from a different connection.
         return;
@@ -113,7 +113,7 @@ void event_observer::read_authorization_request(uint16_t      conection_handle,
         return;
     }
 
-    if (connectable->connection().get_connection_handle() != conection_handle)
+    if (connectable->gap.get_connection_handle() != conection_handle)
     {
         // This GATTS request is from a different connection.
         return;
@@ -123,13 +123,14 @@ void event_observer::read_authorization_request(uint16_t      conection_handle,
 }
 
 // BLE_GATTS_EVT_RW_AUTHORIZE_REQUEST
-void event_observer::write_authorization_request(uint16_t      conection_handle,
-                                                 uint16_t      attribute_handle,
-                                                 att::op_code  write_operation_type,
-                                                 bool          authorization_required,
-                                                 att::length_t offset,
-                                                 att::length_t length,
-                                                 void const*   data)
+void event_observer::write_authorization_request(
+    uint16_t      conection_handle,
+    uint16_t      attribute_handle,
+    att::op_code  write_operation_type,
+    bool          authorization_required,
+    att::length_t offset,
+    att::length_t length,
+    void const*   data)
 {
     ble::profile::connectable* connectable = this->get_connecteable();
     if (not connectable)
@@ -138,7 +139,7 @@ void event_observer::write_authorization_request(uint16_t      conection_handle,
         return;
     }
 
-    if (connectable->connection().get_connection_handle() != conection_handle)
+    if (connectable->gap.get_connection_handle() != conection_handle)
     {
         // This GATTS request is from a different connection.
         return;
@@ -175,19 +176,20 @@ void event_observer::exchange_mtu_request(uint16_t      conection_handle,
         return;
     }
 
-    if (connectable->connection().get_connection_handle() != conection_handle)
+    if (connectable->gap.get_connection_handle() != conection_handle)
     {
         // This GATTS request is from a different connection.
         return;
     }
 
     ble::att::length_t const att_mtu_length_maximum =
-        connectable->ble_stack().get_constraints().att_mtu_maximum_length;
+        connectable->stack.get_constraints().att_mtu_maximum_length;
 
     client_rx_mtu_size = std::min(client_rx_mtu_size, att_mtu_length_maximum);
     client_rx_mtu_size = std::max(client_rx_mtu_size, att::mtu_length_minimum);
 
-    connectable->gatts()->exchange_mtu_reply(conection_handle, client_rx_mtu_size);
+    connectable->gatts.operations->exchange_mtu_reply(conection_handle,
+                                                      client_rx_mtu_size);
 }
 
 // BLE_GATTS_EVT_TIMEOUT, // always BLE_GATT_TIMEOUT_SRC_PROTOCOL (0)
@@ -200,7 +202,7 @@ void event_observer::timeout(uint16_t conection_handle, uint8_t timeout_source)
         return;
     }
 
-    if (connectable->connection().get_connection_handle() != conection_handle)
+    if (connectable->gap.get_connection_handle() != conection_handle)
     {
         // This GATTS request is from a different connection.
         return;
@@ -211,8 +213,8 @@ void event_observer::timeout(uint16_t conection_handle, uint8_t timeout_source)
 }
 
 // BLE_GATTS_EVT_HVN_TX_COMPLETE
-void event_observer::handle_value_notifications_tx_completed(uint16_t conection_handle,
-                                                             uint8_t  count)
+void event_observer::handle_value_notifications_tx_completed(
+    uint16_t conection_handle, uint8_t  count)
 {
     ble::profile::connectable* connectable = this->get_connecteable();
     if (not connectable)
@@ -221,7 +223,7 @@ void event_observer::handle_value_notifications_tx_completed(uint16_t conection_
         return;
     }
 
-    if (connectable->connection().get_connection_handle() != conection_handle)
+    if (connectable->gap.get_connection_handle() != conection_handle)
     {
         // This GATTS request is from a different connection.
         return;

ble/nordic_ble_common_event_observable.cc

@@ -3,56 +3,35 @@
  * @copyright (c) 2018, natersoz. Distributed under the Apache 2.0 license.
  */
 
-#include "ble/nordic_ble_event_observable.h"
 #include "ble/nordic_ble_event_observer.h"
-
 #include "logger.h"
 
 namespace nordic
 {
 
-template<>
-void ble_event_observable<ble_common_event_observer>::notify(
-    ble_common_event_observer::event_enum_t event_type,
-    ble_common_event_observer::event_data_t const&  event_data)
+void ble_common_event_notify(ble::common::event_observer&   observer,
+                             enum BLE_COMMON_EVTS           event_type,
+                             ble_common_evt_t const&        event_data)
 {
-    for (auto observer_iter  = this->observer_list_.begin();
-              observer_iter != this->observer_list_.end(); )
+    auto const memory_type = static_cast<ble::common::memory_type>(
+        event_data.params.user_mem_request.type);
+
+    switch (event_type)
     {
-        logger &logger = logger::instance();
+    case BLE_EVT_USER_MEM_REQUEST:
+        observer.memory_request(event_data.conn_handle, memory_type, 0u, 1u);
+        break;
 
-        // Increment the iterator prior to using it.
-        // If the client removes itself during the completion callback
-        // then the iterator will be valid and can continue.
-        auto &observer = *observer_iter;
-        ++observer_iter;
+    case BLE_EVT_USER_MEM_RELEASE:
+        observer.memory_release(event_data.conn_handle,
+                                memory_type,
+                                event_data.params.user_mem_release.mem_block.p_mem,
+                                event_data.params.user_mem_release.mem_block.len);
+        break;
 
-        switch (event_type)
-        {
-        case BLE_EVT_USER_MEM_REQUEST:
-            // User Memory request. @ref ble_evt_user_mem_request_t
-            {
-                observer.interface_reference.memory_request(
-                    event_data.conn_handle,
-                    static_cast<ble::common::memory_type>(event_data.params.user_mem_request.type),
-                    0u,
-                    1u);
-            }
-            break;
-        case  BLE_EVT_USER_MEM_RELEASE:
-            // User Memory release. @ref ble_evt_user_mem_release_t
-            {
-                observer.interface_reference.memory_release(
-                    event_data.conn_handle,
-                    static_cast<ble::common::memory_type>(event_data.params.user_mem_release.type),
-                    event_data.params.user_mem_release.mem_block.p_mem,
-                    event_data.params.user_mem_release.mem_block.len);
-            }
-            break;
-        default:
-            logger.warn("unhandled Nordic common event: %u", event_type);
-            break;
-        }
+    default:
+        logger::instance().warn("unhandled Nordic common event: %u", event_type);
+        break;
     }
 }