Change internals to use less private friends, add comments in header files, make var types more consistent

Author: sandeepmistry

libraries/CurieBle/src/BleAttribute.cpp

@@ -24,23 +24,42 @@
 unsigned char BleAttribute::_numAttributes = 0;
 
 BleAttribute::BleAttribute(const char* uuid, enum BleAttributeType type) :
-    _uuidStr(uuid),
-    _type(type)
+    _uuid(uuid),
+    _type(type),
+    _handle(0)
 {
-    BleUuid bleUuid(uuid);
-
-    _uuid = bleUuid.uuid();
     _numAttributes++;
 }
 
-const char* BleAttribute::uuid() const {
-    return _uuidStr;
+const char*
+BleAttribute::uuid() const {
+    return _uuid;
 }
 
-enum BleAttributeType BleAttribute::type() const {
+enum BleAttributeType
+BleAttribute::type() const {
     return this->_type;
 }
 
-unsigned char BleAttribute::numAttributes() {
+uint16_t
+BleAttribute::handle() {
+    return _handle;
+}
+
+void
+BleAttribute::setHandle(uint16_t handle) {
+    _handle = handle;
+}
+
+
+bt_uuid
+BleAttribute::btUuid() const {
+    BleUuid bleUuid = BleUuid(uuid());
+    
+    return bleUuid.uuid();
+}
+
+unsigned char
+BleAttribute::numAttributes() {
     return _numAttributes;
 }

libraries/CurieBle/src/BleAttribute.h

@@ -28,23 +28,37 @@ enum BleAttributeType {
     BleTypeDescriptor     = 0x2900
 };
 
+class BlePeripheral;
+
 class BleAttribute {
 public:
+    
+    /**
+     * Get the string representation of the Attribute
+     *
+     * @return const char* string representation of the Attribute
+     */
+    const char* uuid(void) const;
+
+protected:
+    friend BlePeripheral;
+
     BleAttribute(const char* uuid, enum BleAttributeType type);
 
-    const char* uuid() const;
-    enum BleAttributeType type() const;
+    BleAttributeType type(void) const;
+    bt_uuid btUuid(void) const;
+    uint16_t handle(void);
+    void setHandle(uint16_t handle);
 
-protected:
-    static unsigned char numAttributes();
 
-    struct bt_uuid _uuid;
+    static unsigned char numAttributes(void);
 
 private:
     static unsigned char _numAttributes;
 
-    const char* _uuidStr;
+    const char* _uuid;
     enum BleAttributeType _type;
+    uint16_t _handle;
 };
 
 #endif // _BLE_ATTRIBUTE_H_INCLUDED

libraries/CurieBle/src/BleCentral.cpp

@@ -36,17 +36,17 @@ BleCentral::operator bool() const {
     return (memcmp(&_address, &zero, sizeof(_address)) != 0);
 }
 
-bool
+boolean_t
 BleCentral::operator==(const BleCentral& rhs) const {
     return (memcmp(&_address, &rhs._address, sizeof(_address)) == 0);
 }
 
-bool
+boolean_t
 BleCentral::operator!=(const BleCentral& rhs) const {
     return !(*this == rhs);
 }
 
-bool
+boolean_t
 BleCentral::connected() {
     poll();
 
@@ -55,23 +55,27 @@ BleCentral::connected() {
 
 const char* 
 BleCentral::address() const {
-    static String address = "";
+    static char address[18];
+
+    String addressStr = "";
 
     for (int i = 5; i >= 0; i--) {
         unsigned char a = _address.addr[i];
 
         if (a < 0x10) {
-            address += "0";
+            addressStr += "0";
         }
 
-        address += String(a, 16);
+        addressStr += String(a, 16);
 
         if (i > 0) {
-            address += ":";
+            addressStr += ":";
         }
     }
 
-    return address.c_str();
+    strcpy(address, addressStr.c_str());
+
+    return address;
 }
 
 void

libraries/CurieBle/src/BleCentral.h

@@ -28,15 +28,35 @@ class BleCentral {
     friend class BlePeripheral;
 
     public:
-        operator bool() const;
-        bool operator==(const BleCentral& rhs) const;
-        bool operator!=(const BleCentral& rhs) const;
+        /**
+         * Is the Central connected
+         *
+         * @return boolean_t true if the central is connected, otherwise false
+         */
+        boolean_t connected(void);
 
-        bool connected();
-        const char* address() const;
-        void poll();
+        /**
+         * Get the address of the Central in string form
+         *
+         * @return const char* address of the Central in string form
+         */
+        const char* address(void) const;
+        
+        /**
+         * Disconnect the central if it is connected
+         *
+         * @return BleStatus result of operation
+         */
+        BleStatus disconnect(void);
 
-        BleStatus disconnect();
+        /**
+         * Poll the central for events
+         */
+        void poll(void);
+
+        operator bool(void) const;
+        boolean_t operator==(const BleCentral& rhs) const;
+        boolean_t operator!=(const BleCentral& rhs) const;
 
     protected:
         BleCentral(BlePeripheral* peripheral);