feat(hid_service): Update to store / reuse report characteristics (#356)

* feat(hid_service): Update to store / reuse report characteristics

* fix sa

* update example and add removal functions

Author: finger563

components/hid_service/example/main/hid_service_example.cpp

@@ -106,7 +106,7 @@ extern "C" void app_main(void) {
   hid_service.set_report_map(descriptor);
 
   // use the HID service to make an input report characteristic
-  auto input_report = hid_service.input_report(input_report_id);
+  [[maybe_unused]] auto input_report = hid_service.input_report(input_report_id);
 
   // use the HID service to make an output report characteristic
   [[maybe_unused]] auto output_report = hid_service.output_report(output_report_id);
@@ -217,7 +217,11 @@ extern "C" void app_main(void) {
     // send an input report
     auto report = gamepad_input_report.get_report();
     logger.debug("Sending report data ({}): {::#02x}", report.size(), report);
-    input_report->notify(report);
+
+    // Get the stored pointer (we could use the one above, but this is just to
+    // show how to get it)
+    auto report_char = hid_service.input_report(input_report_id);
+    report_char->notify(report);
 
     // sleep
     std::this_thread::sleep_until(start + 1s);

components/hid_service/include/hid_service.hpp

@@ -150,6 +150,17 @@ class HidService : public espp::BaseComponent {
   ///                  is related to the characteristic.
   /// @return The input report characteristic.
   NimBLECharacteristic *input_report(uint8_t report_id) {
+    std::lock_guard<std::mutex> lock(input_report_characteristics_mutex_);
+
+    // look up the report ID in the list of input report characteristics
+    for (const auto &report_char : input_report_characteristics_) {
+      // cppcheck-suppress useStlAlgorithm
+      if (report_char.first == report_id) {
+        return report_char.second;
+      }
+    }
+
+    // we got here, so the report ID was not found
     auto input_report_char = service_->createCharacteristic(
         NimBLEUUID(REPORT_UUID),
         NIMBLE_PROPERTY::READ | NIMBLE_PROPERTY::NOTIFY | NIMBLE_PROPERTY::READ_ENC);
@@ -160,15 +171,49 @@ class HidService : public espp::BaseComponent {
     uint8_t desc_value[] = {report_id, 0x01};
     desc->setValue(desc_value, sizeof(desc_value));
 
+    // now add the report ID to the list of input report characteristics
+    input_report_characteristics_.emplace_back(report_id, input_report_char);
+
     return input_report_char;
   }
 
+  /// @brief Remove an input report characteristic.
+  /// @param report_id The report ID of the input report characteristic to
+  ///        remove.
+  /// @note This will delete the characteristic, and remove it from the list.
+  ///       Any stored pointers to the characteristic will be invalid after this
+  ///       call.
+  void remove_input_report(uint8_t report_id) {
+    std::lock_guard<std::mutex> lock(input_report_characteristics_mutex_);
+    auto it =
+        std::find_if(input_report_characteristics_.begin(), input_report_characteristics_.end(),
+                     [report_id](const ReportCharacteristic &report_char) {
+                       return report_char.first == report_id;
+                     });
+    if (it != input_report_characteristics_.end()) {
+      static constexpr bool delete_char = true;
+      service_->removeCharacteristic(it->second, delete_char);
+      input_report_characteristics_.erase(it);
+    }
+  }
+
   /// @brief Create an output report characteristic.
   /// @param report_id The report ID. This should be the same as the report
   ///                ID in the report descriptor for the output object that
   ///                is related to the characteristic.
   /// @return The output report characteristic.
   NimBLECharacteristic *output_report(uint8_t report_id) {
+    std::lock_guard<std::mutex> lock(output_report_characteristics_mutex_);
+
+    // look up the report ID in the list of output report characteristics
+    for (const auto &report_char : output_report_characteristics_) {
+      // cppcheck-suppress useStlAlgorithm
+      if (report_char.first == report_id) {
+        return report_char.second;
+      }
+    }
+
+    // we got here, so the report ID was not found
     auto output_report_char = service_->createCharacteristic(
         NimBLEUUID(REPORT_UUID), NIMBLE_PROPERTY::READ | NIMBLE_PROPERTY::WRITE |
                                      NIMBLE_PROPERTY::WRITE_NR | NIMBLE_PROPERTY::READ_ENC |
@@ -182,15 +227,49 @@ class HidService : public espp::BaseComponent {
     uint8_t desc_value[] = {report_id, 0x02};
     desc->setValue(desc_value, sizeof(desc_value));
 
+    // now add the report ID to the list of output report characteristics
+    output_report_characteristics_.emplace_back(report_id, output_report_char);
+
     return output_report_char;
   }
 
+  /// @brief Remove an output report characteristic.
+  /// @param report_id The report ID of the output report characteristic to
+  ///        remove.
+  /// @note This will delete the characteristic, and remove it from the list.
+  ///       Any stored pointers to the characteristic will be invalid after this
+  ///       call.
+  void remove_output_report(uint8_t report_id) {
+    std::lock_guard<std::mutex> lock(output_report_characteristics_mutex_);
+    auto it =
+        std::find_if(output_report_characteristics_.begin(), output_report_characteristics_.end(),
+                     [report_id](const ReportCharacteristic &report_char) {
+                       return report_char.first == report_id;
+                     });
+    if (it != output_report_characteristics_.end()) {
+      static constexpr bool delete_char = true;
+      service_->removeCharacteristic(it->second, delete_char);
+      output_report_characteristics_.erase(it);
+    }
+  }
+
   /// @brief Create a feature report characteristic.
   /// @param report_id The report ID. This should be the same as the report
   ///               ID in the report descriptor for the feature object that
   ///               is related to the characteristic.
   /// @return The feature report characteristic.
   NimBLECharacteristic *feature_report(uint8_t report_id) {
+    std::lock_guard<std::mutex> lock(feature_report_characteristics_mutex_);
+
+    // look up the report ID in the list of feature report characteristics
+    for (const auto &report_char : feature_report_characteristics_) {
+      // cppcheck-suppress useStlAlgorithm
+      if (report_char.first == report_id) {
+        return report_char.second;
+      }
+    }
+
+    // we got here, so the report ID was not found
     auto feature_report_char = service_->createCharacteristic(
         NimBLEUUID(REPORT_UUID), NIMBLE_PROPERTY::READ | NIMBLE_PROPERTY::WRITE |
                                      NIMBLE_PROPERTY::READ_ENC | NIMBLE_PROPERTY::WRITE_ENC);
@@ -203,9 +282,32 @@ class HidService : public espp::BaseComponent {
     uint8_t desc_value[] = {report_id, 0x03};
     desc->setValue(desc_value, sizeof(desc_value));
 
+    // now add the report ID to the list of feature report characteristics
+    feature_report_characteristics_.emplace_back(report_id, feature_report_char);
+
     return feature_report_char;
   }
 
+  /// @brief Remove a feature report characteristic.
+  /// @param report_id The report ID of the feature report characteristic to
+  ///        remove.
+  /// @note This will delete the characteristic, and remove it from the list.
+  ///       Any stored pointers to the characteristic will be invalid after this
+  ///       call.
+  void remove_feature_report(uint8_t report_id) {
+    std::lock_guard<std::mutex> lock(feature_report_characteristics_mutex_);
+    auto it =
+        std::find_if(feature_report_characteristics_.begin(), feature_report_characteristics_.end(),
+                     [report_id](const ReportCharacteristic &report_char) {
+                       return report_char.first == report_id;
+                     });
+    if (it != feature_report_characteristics_.end()) {
+      static constexpr bool delete_char = true;
+      service_->removeCharacteristic(it->second, delete_char);
+      feature_report_characteristics_.erase(it);
+    }
+  }
+
 protected:
   static constexpr uint16_t SERVICE_UUID = 0x1812;
   static constexpr uint16_t HID_INFORMATION_UUID = 0x2a4a;
@@ -238,6 +340,15 @@ class HidService : public espp::BaseComponent {
     protocol_mode_->setValue(pMode, 1);
   }
 
+  typedef std::pair<uint8_t, NimBLECharacteristic *> ReportCharacteristic;
+
+  std::mutex input_report_characteristics_mutex_;
+  std::vector<ReportCharacteristic> input_report_characteristics_;
+  std::mutex output_report_characteristics_mutex_;
+  std::vector<ReportCharacteristic> output_report_characteristics_;
+  std::mutex feature_report_characteristics_mutex_;
+  std::vector<ReportCharacteristic> feature_report_characteristics_;
+
   NimBLEService *service_{nullptr};
   NimBLECharacteristic *hid_info_{nullptr};      // 0x2a4a
   NimBLECharacteristic *report_map_{nullptr};    // 0x2a4b