Add written and subscribed API's to BleCharacteristic, pass central into BleCharacteristic even handers, remove BleAck event for now

Author: sandeepmistry

libraries/CurieBle/examples/AutomationIO/AutomationIO.ino

@@ -156,7 +156,7 @@ void blePeripheralDisconnectedEventCb(BleCentral &bleCentral)
 }
 
 /* This function will be called when a connected remote peer sets a new value for a digital output characteristic */
-void digitalOutputCharWrittenEventCb(BleCharacteristic &characteristic)
+void digitalOutputCharWrittenEventCb(BleCentral &central, BleCharacteristic &characteristic)
 {
   for(unsigned int i = 0; i < ARRAY_SIZE(digitalOutputPins); i++) {
     if (&digitalOutputPins[i].characteristic == &characteristic) {
@@ -172,7 +172,7 @@ void digitalOutputCharWrittenEventCb(BleCharacteristic &characteristic)
 }
 
 /* This function will be called when a connected remote peer sets a new value for an analog output characteristic */
-void analogOutputCharWrittenEventCb(BleCharacteristic &characteristic)
+void analogOutputCharWrittenEventCb(BleCentral &central, BleCharacteristic &characteristic)
 {
   for(unsigned int i = 0; i < ARRAY_SIZE(analogOutputPins); i++) {
     if (&analogOutputPins[i].characteristic == &characteristic) {

libraries/CurieBle/src/BleCharacteristic.cpp

@@ -31,7 +31,7 @@
  * by a remote client to enable/disable receipt of notifications/indications
  */
 void
-_cccdEventHandler(BleDescriptor &cccd, BleDescriptorEvent event, void *arg)
+_cccdEventHandler(BleCentral& central, BleDescriptor &cccd, BleDescriptorEvent event, void *arg)
 {
     if (BLE_DESC_EVENT_WRITE == event) {
         BleStatus status;
@@ -47,11 +47,11 @@ _cccdEventHandler(BleDescriptor &cccd, BleDescriptorEvent event, void *arg)
 
         if (ch->_notifyEnabled || ch->_indicateEnabled) {
             if (ch->_event_handlers[BleSubscribed]) {
-                ch->_event_handlers[BleSubscribed](*ch);
+                ch->_event_handlers[BleSubscribed](central, *ch);
             }
         } else {
             if (ch->_event_handlers[BleUnsubscribed]) {
-                ch->_event_handlers[BleUnsubscribed](*ch);
+                ch->_event_handlers[BleUnsubscribed](central, *ch);
             }
         }
     }
@@ -65,6 +65,7 @@ BleCharacteristic::BleCharacteristic(const char* uuid,
 {
     _initialised = false;
     _connected = false;
+    _written = false;
     _notifyEnabled = false;
     _indicateEnabled = false;
 
@@ -164,9 +165,6 @@ BleCharacteristic::_setValue(void)
             status = ble_client_gatts_send_notif_ind(_handles.value_handle, _data_len, _data, 0, _indicateEnabled);
             if (BLE_STATUS_SUCCESS != status)
                 return status;
-
-            if (_indicateEnabled && _event_handlers[BleAcked])
-                _event_handlers[BleAcked](*this);
         }
     }
 
@@ -188,6 +186,23 @@ BleCharacteristic::setValue(const uint8_t value[], const uint16_t length)
     return _setValue();
 }
 
+void
+BleCharacteristic::setValue(BleCentral& central, const uint8_t* value, uint16_t length)
+{
+    if (length > _char_data.max_len) {
+        length = _char_data.max_len;
+    }
+
+    memcpy(_data, value, length);
+    _data_len = length;
+
+    _written = true;
+
+    if (_event_handlers[BleUnsubscribed]) {
+        _event_handlers[BleWritten](central, *this);
+    }
+}
+
 BleStatus
 BleCharacteristic::setValue(const String &str)
 {
@@ -388,6 +403,23 @@ BleCharacteristic::operator[] (int offset) const
     return _data[offset];
 }
 
+
+boolean_t
+BleCharacteristic::written()
+{
+    boolean_t written = _written;
+
+    _written = false;
+
+    return written;
+}
+
+boolean_t
+BleCharacteristic::subscribed()
+{
+    return (_notifyEnabled || _indicateEnabled);
+}
+
 void
 BleCharacteristic::setEventHandler(BleCharacteristicEvent event, BleCharacteristicEventHandler callback)
 {

libraries/CurieBle/src/BleCharacteristic.h

@@ -21,6 +21,7 @@
 #define _BLE_CHARACTERISTIC_H_INCLUDED
 
 #include "BleAttribute.h"
+#include "BleCentral.h"
 #include "BleCommon.h"
 #include "BleDescriptor.h"
 
@@ -33,9 +34,8 @@ enum BleCharacteristicEvent {
     BleWritten = 0,
     BleSubscribed = 1,
     BleUnsubscribed = 2,
-    BleAcked = 3,
 
-    BleCharacteristicEventLast = 4
+    BleCharacteristicEventLast = 3
 };
 
 /* Forward declaration needed for callback function prototype below */
@@ -44,7 +44,7 @@ class BleService;
 class BlePeripheral;
 
 /** Function prototype for BLE Characteristic event callback */
-typedef void (*BleCharacteristicEventHandler)(BleCharacteristic &characteristic);
+typedef void (*BleCharacteristicEventHandler)(BleCentral &central, BleCharacteristic &characteristic);
 
 enum BleProperty {
   // BleBroadcast            = 0x01,
@@ -103,6 +103,9 @@ class BleCharacteristic : public BleAttribute {
     uint16_t valueLength() const;
     uint8_t operator[] (int offset) const;
 
+    boolean_t written();
+    boolean_t subscribed();
+
     /**
      * Provide a function to be called when events related to this Characteristic are raised
      *
@@ -111,6 +114,8 @@ class BleCharacteristic : public BleAttribute {
      */
     void setEventHandler(BleCharacteristicEvent event, BleCharacteristicEventHandler callback);
 
+    void setValue(BleCentral& central, const uint8_t value[], uint16_t length);
+
 private:
     /**
      * Add an optional User-Description descriptor
@@ -197,7 +202,7 @@ class BleCharacteristic : public BleAttribute {
     friend class BlePeripheral;
     friend class BleService;
     friend void  blePeripheralGattsEventHandler(ble_client_gatts_event_t event, struct ble_gatts_evt_msg *event_data, void *param);
-    friend void _cccdEventHandler(BleDescriptor &cccd, BleDescriptorEvent event, void *arg);
+    friend void _cccdEventHandler(BleCentral &central, BleDescriptor &cccd, BleDescriptorEvent event, void *arg);
 
     BleCharacteristic(const uint16_t maxLength,
                       const uint8_t properties);
@@ -212,6 +217,7 @@ class BleCharacteristic : public BleAttribute {
 
     boolean_t                _initialised;
     boolean_t                _connected;
+    boolean_t                _written;
     uint8_t                  _properties;
     BleCharacteristicEventHandler _event_handlers[BleCharacteristicEventLast];
 

libraries/CurieBle/src/BleDescriptor.h

@@ -21,6 +21,7 @@
 #define _BLE_DESCRIPTOR_H_INCLUDED
 
 #include "BleAttribute.h"
+#include "BleCentral.h"
 #include "BleCommon.h"
 
 #include "internal/ble_client.h"
@@ -37,7 +38,7 @@ class BleCharacteristic;
 class BleDescriptor;
 
 /** Function prototype for BLE Characteristic event callback */
-typedef void (*BleDescriptorEventCb)(BleDescriptor &descriptor, BleDescriptorEvent event, void *arg);
+typedef void (*BleDescriptorEventCb)(BleCentral& central, BleDescriptor &descriptor, BleDescriptorEvent event, void *arg);
 
 /**
  * BLE GATT Descriptor class

libraries/CurieBle/src/BlePeripheral.cpp

@@ -72,22 +72,19 @@ void
 blePeripheralGattsEventHandler(ble_client_gatts_event_t event, struct ble_gatts_evt_msg *event_data, void *param)
 {
     BlePeripheral *p = (BlePeripheral *)param;
+    BleCentral c = p->central();
     BleCharacteristic *ch;
     BleDescriptor *desc;
 
     switch (event) {
     case BLE_CLIENT_GATTS_EVENT_WRITE: {
         if ((ch = p->_matchCharacteristic(event_data->wr.attr_handle))) {
-            ch->_data_len = event_data->wr.len > ch->_char_data.max_len ? ch->_char_data.max_len : event_data->wr.len;
-            memcpy(ch->_data, event_data->wr.data, ch->_data_len);
-            if (ch->_event_handlers[BleWritten]) {
-                ch->_event_handlers[BleWritten](*ch);
-            }
+            ch->setValue(c, event_data->wr.data, event_data->wr.len);
         } else if ((desc = p->_matchDescriptor(event_data->wr.attr_handle))) {
             if (desc->_event_cb) {
                 desc->_desc.length = event_data->wr.len > sizeof(desc->_data) ? sizeof(desc->_data) : event_data->wr.len;
                 memcpy(desc->_data, event_data->wr.data, desc->_desc.length);
-                desc->_event_cb(*desc, BLE_DESC_EVENT_WRITE, desc->_event_cb_arg);
+                desc->_event_cb(c, *desc, BLE_DESC_EVENT_WRITE, desc->_event_cb_arg);
             }
         }
     }