refactor(RemoteChar): Reduce nesting

* retrieveDescriptors added optional parameter to pass in pointer to get
  descriptor
* General clean-up

Author: thekurtovic

src/NimBLERemoteCharacteristic.cpp

@@ -37,7 +37,7 @@ static const char* LOG_TAG = "NimBLERemoteCharacteristic";
 /**
  * @brief Constructor.
  * @param [in] svc A pointer to the service this characteristic belongs to.
- * @param [in] ble_gatt_chr struct defined as:
+ * @param [in] chr struct defined as:
  *  struct ble_gatt_chr {
  *      uint16_t def_handle;
  *      uint16_t val_handle;
@@ -63,7 +63,7 @@ NimBLERemoteCharacteristic::~NimBLERemoteCharacteristic() {
  * @brief Callback used by the API when a descriptor is discovered or search complete.
  */
 int NimBLERemoteCharacteristic::descriptorDiscCB(
-    uint16_t conn_handle, const ble_gatt_error* error, uint16_t chr_val_handle, const ble_gatt_dsc* dsc, void* arg) {
+    uint16_t connHandle, const ble_gatt_error* error, uint16_t chrHandle, const ble_gatt_dsc* dsc, void* arg) {
     int rc = error->status;
     NIMBLE_LOGD(LOG_TAG, "Descriptor Discovery >> status: %d handle: %d", rc, (rc == 0) ? dsc->handle : -1);
 
@@ -72,35 +72,31 @@ int NimBLERemoteCharacteristic::descriptorDiscCB(
     const auto        pChr       = (NimBLERemoteCharacteristic*)pTaskData->m_pInstance;
     const NimBLEUUID* uuidFilter = filter->uuid;
 
-    if (pChr->getHandle() != chr_val_handle) {
+    if (pChr->getHandle() != chrHandle) {
         return 0; // Descriptor not for this characteristic
     }
 
-    if (rc == 0) {
-        if (uuidFilter != nullptr) {
-            if (ble_uuid_cmp(uuidFilter->getBase(), &dsc->uuid.u) == 0) {
-                rc = BLE_HS_EDONE; // Found the descriptor, stop the search
-            } else {
-                return 0; // Not the descriptor we are looking for
-            }
-        }
-
+    // Found descriptor, with either no UUID filter or matched.
+    if (!rc && (!uuidFilter || !ble_uuid_cmp(uuidFilter->getBase(), &dsc->uuid.u))) {
+        rc = BLE_HS_EDONE; // Indicate that descriptor was found.
         pChr->m_vDescriptors.push_back(new NimBLERemoteDescriptor(pChr, dsc));
-        return 0;
+    }
+    else if (rc != 0) {
+        NimBLEUtils::taskRelease(*pTaskData, rc);
     }
 
-    NimBLEUtils::taskRelease(*pTaskData, rc);
     NIMBLE_LOGD(LOG_TAG, "<< Descriptor Discovery");
     return rc;
 }
 
 /**
  * @brief Populate the descriptors (if any) for this characteristic.
- * @param [in] the end handle of the characteristic, or the service, whichever comes first.
+ * @param [in] uuidFilter The end handle of the characteristic, or the service, whichever comes first.
+ * @param [out] out Pointer to get the descriptor if found.
+ * @return True if successfully retrieved, success = 0 or BLE_HS_EDONE.
  */
-bool NimBLERemoteCharacteristic::retrieveDescriptors(const NimBLEUUID* uuidFilter) const {
+bool NimBLERemoteCharacteristic::retrieveDescriptors(const NimBLEUUID* uuidFilter, NimBLERemoteDescriptor* out) const {
     NIMBLE_LOGD(LOG_TAG, ">> retrieveDescriptors() for characteristic: %s", getUUID().toString().c_str());
-
     NimBLETaskData taskData(const_cast<NimBLERemoteCharacteristic*>(this));
     desc_filter_t  filter = {uuidFilter, &taskData};
 
@@ -118,6 +114,9 @@ bool NimBLERemoteCharacteristic::retrieveDescriptors(const NimBLEUUID* uuidFilte
     rc = taskData.m_flags;
     if (rc == 0 || rc == BLE_HS_EDONE) {
         NIMBLE_LOGD(LOG_TAG, "<< retrieveDescriptors(): found %d descriptors.", m_vDescriptors.size());
+        if (out && rc == BLE_HS_EDONE) {
+            out = m_vDescriptors.back();
+        }
         return true;
     }
 
@@ -132,8 +131,8 @@ bool NimBLERemoteCharacteristic::retrieveDescriptors(const NimBLEUUID* uuidFilte
  */
 NimBLERemoteDescriptor* NimBLERemoteCharacteristic::getDescriptor(const NimBLEUUID& uuid) const {
     NIMBLE_LOGD(LOG_TAG, ">> getDescriptor: uuid: %s", uuid.toString().c_str());
-    NimBLERemoteDescriptor* pDsc      = nullptr;
-    size_t                  prev_size = m_vDescriptors.size();
+    NimBLERemoteDescriptor* pDsc = nullptr;
+    NimBLEUUID              uuidTmp;
 
     for (const auto& it : m_vDescriptors) {
         if (it->getUUID() == uuid) {
@@ -142,36 +141,22 @@ NimBLERemoteDescriptor* NimBLERemoteCharacteristic::getDescriptor(const NimBLEUU
         }
     }
 
-    if (retrieveDescriptors(&uuid)) {
-        if (m_vDescriptors.size() > prev_size) {
-            pDsc = m_vDescriptors.back();
-            goto Done;
-        }
-
-        // If the request was successful but 16/32 bit uuid not found
-        // try again with the 128 bit uuid.
-        if (uuid.bitSize() == BLE_UUID_TYPE_16 || uuid.bitSize() == BLE_UUID_TYPE_32) {
-            NimBLEUUID uuid128(uuid);
-            uuid128.to128();
-            if (retrieveDescriptors(&uuid128)) {
-                if (m_vDescriptors.size() > prev_size) {
-                    pDsc = m_vDescriptors.back();
-                }
-            }
-        } else {
-            // If the request was successful but the 128 bit uuid not found
-            // try again with the 16 bit uuid.
-            NimBLEUUID uuid16(uuid);
-            uuid16.to16();
-            // if the uuid was 128 bit but not of the BLE base type this check will fail
-            if (uuid16.bitSize() == BLE_UUID_TYPE_16) {
-                if (retrieveDescriptors(&uuid16)) {
-                    if (m_vDescriptors.size() > prev_size) {
-                        pDsc = m_vDescriptors.back();
-                    }
-                }
-            }
-        }
+    if (!retrieveDescriptors(&uuid, pDsc) || pDsc) {
+        goto Done;
+    }
+    // If the request was successful but 16/32 bit uuid not found
+    // try again with the 128 bit uuid.
+    if (uuid.bitSize() == BLE_UUID_TYPE_16 || uuid.bitSize() == BLE_UUID_TYPE_32) {
+        uuidTmp = NimBLEUUID(uuid).to128();
+        retrieveDescriptors(&uuidTmp, pDsc);
+        goto Done;
+    }
+    // If the request was successful but the 128 bit uuid not found
+    // try again with the 16 bit uuid.
+    uuidTmp = NimBLEUUID(uuid).to16();
+    // if the uuid was 128 bit but not of the BLE base type this check will fail
+    if (uuidTmp.bitSize() == BLE_UUID_TYPE_16) {
+        retrieveDescriptors(&uuidTmp, pDsc);
     }
 
 Done:
@@ -305,7 +290,7 @@ size_t NimBLERemoteCharacteristic::deleteDescriptor(const NimBLEUUID& uuid) cons
  * @return True if supported.
  */
 bool NimBLERemoteCharacteristic::canBroadcast() const {
-    return (m_properties & BLE_GATT_CHR_PROP_BROADCAST) != 0;
+    return (m_properties & BLE_GATT_CHR_PROP_BROADCAST);
 };
 
 /**

src/NimBLERemoteCharacteristic.h

@@ -65,10 +65,10 @@ class NimBLERemoteCharacteristic : public NimBLERemoteValueAttribute {
     ~NimBLERemoteCharacteristic();
 
     bool setNotify(uint16_t val, notify_callback notifyCallback = nullptr, bool response = true) const;
-    bool retrieveDescriptors(const NimBLEUUID* uuidFilter = nullptr) const;
+    bool retrieveDescriptors(const NimBLEUUID* uuidFilter = nullptr, NimBLERemoteDescriptor* out = nullptr) const;
 
     static int descriptorDiscCB(
-        uint16_t conn_handle, const ble_gatt_error* error, uint16_t chr_val_handle, const ble_gatt_dsc* dsc, void* arg);
+        uint16_t connHandle, const ble_gatt_error* error, uint16_t chrHandle, const ble_gatt_dsc* dsc, void* arg);
 
     const NimBLERemoteService*                   m_pRemoteService{nullptr};
     uint8_t                                      m_properties{0};