esphome 2025.9.3__py3-none-any.whl → 2025.10.0b1__py3-none-any.whl

esphome/components/esp32_ble_server/ble_characteristic.h

@@ -2,11 +2,12 @@
 
 #include "ble_descriptor.h"
 #include "esphome/components/esp32_ble/ble_uuid.h"
-#include "esphome/components/event_emitter/event_emitter.h"
 #include "esphome/components/bytebuffer/bytebuffer.h"
 
 #include <vector>
-#include <unordered_map>
+#include <span>
+#include <functional>
+#include <memory>
 
 #ifdef USE_ESP32
 
@@ -23,22 +24,10 @@ namespace esp32_ble_server {
 
 using namespace esp32_ble;
 using namespace bytebuffer;
-using namespace event_emitter;
 
 class BLEService;
 
-namespace BLECharacteristicEvt {
-enum VectorEvt {
-  ON_WRITE,
-};
-
-enum EmptyEvt {
-  ON_READ,
-};
-}  // namespace BLECharacteristicEvt
-
-class BLECharacteristic : public EventEmitter<BLECharacteristicEvt::VectorEvt, std::vector<uint8_t>, uint16_t>,
-                          public EventEmitter<BLECharacteristicEvt::EmptyEvt, uint16_t> {
+class BLECharacteristic {
  public:
   BLECharacteristic(ESPBTUUID uuid, uint32_t properties);
   ~BLECharacteristic();
@@ -77,6 +66,15 @@ class BLECharacteristic : public EventEmitter<BLECharacteristicEvt::VectorEvt, s
   bool is_created();
   bool is_failed();
 
+  // Direct callback registration - only allocates when callback is set
+  void on_write(std::function<void(std::span<const uint8_t>, uint16_t)> &&callback) {
+    this->on_write_callback_ =
+        std::make_unique<std::function<void(std::span<const uint8_t>, uint16_t)>>(std::move(callback));
+  }
+  void on_read(std::function<void(uint16_t)> &&callback) {
+    this->on_read_callback_ = std::make_unique<std::function<void(uint16_t)>>(std::move(callback));
+  }
+
  protected:
   bool write_event_{false};
   BLEService *service_{};
@@ -89,7 +87,20 @@ class BLECharacteristic : public EventEmitter<BLECharacteristicEvt::VectorEvt, s
   SemaphoreHandle_t set_value_lock_;
 
   std::vector<BLEDescriptor *> descriptors_;
-  std::unordered_map<uint16_t, bool> clients_to_notify_;
+
+  struct ClientNotificationEntry {
+    uint16_t conn_id;
+    bool indicate;  // true = indicate, false = notify
+  };
+  std::vector<ClientNotificationEntry> clients_to_notify_;
+
+  void remove_client_from_notify_list_(uint16_t conn_id);
+  ClientNotificationEntry *find_client_in_notify_list_(uint16_t conn_id);
+
+  void set_property_bit_(esp_gatt_char_prop_t bit, bool value);
+
+  std::unique_ptr<std::function<void(std::span<const uint8_t>, uint16_t)>> on_write_callback_;
+  std::unique_ptr<std::function<void(uint16_t)>> on_read_callback_;
 
   esp_gatt_perm_t permissions_ = ESP_GATT_PERM_READ | ESP_GATT_PERM_WRITE;
 

esphome/components/esp32_ble_server/ble_descriptor.cpp

@@ -74,9 +74,10 @@ void BLEDescriptor::gatts_event_handler(esp_gatts_cb_event_t event, esp_gatt_if_
         break;
       this->value_.attr_len = param->write.len;
       memcpy(this->value_.attr_value, param->write.value, param->write.len);
-      this->emit_(BLEDescriptorEvt::VectorEvt::ON_WRITE,
-                  std::vector<uint8_t>(param->write.value, param->write.value + param->write.len),
-                  param->write.conn_id);
+      if (this->on_write_callback_) {
+        (*this->on_write_callback_)(std::span<const uint8_t>(param->write.value, param->write.len),
+                                    param->write.conn_id);
+      }
       break;
     }
     default:

esphome/components/esp32_ble_server/ble_descriptor.h

@@ -1,30 +1,26 @@
 #pragma once
 
 #include "esphome/components/esp32_ble/ble_uuid.h"
-#include "esphome/components/event_emitter/event_emitter.h"
 #include "esphome/components/bytebuffer/bytebuffer.h"
 
 #ifdef USE_ESP32
 
 #include <esp_gatt_defs.h>
 #include <esp_gatts_api.h>
+#include <span>
+#include <functional>
+#include <memory>
 
 namespace esphome {
 namespace esp32_ble_server {
 
 using namespace esp32_ble;
 using namespace bytebuffer;
-using namespace event_emitter;
 
 class BLECharacteristic;
 
-namespace BLEDescriptorEvt {
-enum VectorEvt {
-  ON_WRITE,
-};
-}  // namespace BLEDescriptorEvt
-
-class BLEDescriptor : public EventEmitter<BLEDescriptorEvt::VectorEvt, std::vector<uint8_t>, uint16_t> {
+// Base class for BLE descriptors
+class BLEDescriptor {
  public:
   BLEDescriptor(ESPBTUUID uuid, uint16_t max_len = 100, bool read = true, bool write = true);
   virtual ~BLEDescriptor();
@@ -39,6 +35,12 @@ class BLEDescriptor : public EventEmitter<BLEDescriptorEvt::VectorEvt, std::vect
   bool is_created() { return this->state_ == CREATED; }
   bool is_failed() { return this->state_ == FAILED; }
 
+  // Direct callback registration - only allocates when callback is set
+  void on_write(std::function<void(std::span<const uint8_t>, uint16_t)> &&callback) {
+    this->on_write_callback_ =
+        std::make_unique<std::function<void(std::span<const uint8_t>, uint16_t)>>(std::move(callback));
+  }
+
  protected:
   BLECharacteristic *characteristic_{nullptr};
   ESPBTUUID uuid_;
@@ -46,6 +48,8 @@ class BLEDescriptor : public EventEmitter<BLEDescriptorEvt::VectorEvt, std::vect
 
   esp_attr_value_t value_{};
 
+  std::unique_ptr<std::function<void(std::span<const uint8_t>, uint16_t)>> on_write_callback_;
+
   esp_gatt_perm_t permissions_{};
 
   enum State : uint8_t {

esphome/components/esp32_ble_server/ble_server.cpp

@@ -70,11 +70,11 @@ void BLEServer::loop() {
         // it is at the top of the GATT table
         this->device_information_service_->do_create(this);
         // Create all services previously created
-        for (auto &pair : this->services_) {
-          if (pair.second == this->device_information_service_) {
+        for (auto &entry : this->services_) {
+          if (entry.service == this->device_information_service_) {
             continue;
           }
-          pair.second->do_create(this);
+          entry.service->do_create(this);
         }
         this->state_ = STARTING_SERVICE;
       }
@@ -118,7 +118,7 @@ BLEService *BLEServer::create_service(ESPBTUUID uuid, bool advertise, uint16_t n
   }
   BLEService *service =  // NOLINT(cppcoreguidelines-owning-memory)
       new BLEService(uuid, num_handles, inst_id, advertise);
-  this->services_.emplace(BLEServer::get_service_key(uuid, inst_id), service);
+  this->services_.push_back({uuid, inst_id, service});
   if (this->parent_->is_active() && this->registered_) {
     service->do_create(this);
   }
@@ -127,26 +127,32 @@ BLEService *BLEServer::create_service(ESPBTUUID uuid, bool advertise, uint16_t n
 
 void BLEServer::remove_service(ESPBTUUID uuid, uint8_t inst_id) {
   ESP_LOGV(TAG, "Removing BLE service - %s %d", uuid.to_string().c_str(), inst_id);
-  BLEService *service = this->get_service(uuid, inst_id);
-  if (service == nullptr) {
-    ESP_LOGW(TAG, "BLE service %s %d does not exist", uuid.to_string().c_str(), inst_id);
-    return;
+  for (auto it = this->services_.begin(); it != this->services_.end(); ++it) {
+    if (it->uuid == uuid && it->inst_id == inst_id) {
+      it->service->do_delete();
+      delete it->service;  // NOLINT(cppcoreguidelines-owning-memory)
+      this->services_.erase(it);
+      return;
+    }
   }
-  service->do_delete();
-  delete service;  // NOLINT(cppcoreguidelines-owning-memory)
-  this->services_.erase(BLEServer::get_service_key(uuid, inst_id));
+  ESP_LOGW(TAG, "BLE service %s %d does not exist", uuid.to_string().c_str(), inst_id);
 }
 
 BLEService *BLEServer::get_service(ESPBTUUID uuid, uint8_t inst_id) {
-  BLEService *service = nullptr;
-  if (this->services_.count(BLEServer::get_service_key(uuid, inst_id)) > 0) {
-    service = this->services_.at(BLEServer::get_service_key(uuid, inst_id));
+  for (auto &entry : this->services_) {
+    if (entry.uuid == uuid && entry.inst_id == inst_id) {
+      return entry.service;
+    }
   }
-  return service;
+  return nullptr;
 }
 
-std::string BLEServer::get_service_key(ESPBTUUID uuid, uint8_t inst_id) {
-  return uuid.to_string() + std::to_string(inst_id);
+void BLEServer::dispatch_callbacks_(CallbackType type, uint16_t conn_id) {
+  for (auto &entry : this->callbacks_) {
+    if (entry.type == type) {
+      entry.callback(conn_id);
+    }
+  }
 }
 
 void BLEServer::gatts_event_handler(esp_gatts_cb_event_t event, esp_gatt_if_t gatts_if,
@@ -155,14 +161,14 @@ void BLEServer::gatts_event_handler(esp_gatts_cb_event_t event, esp_gatt_if_t ga
     case ESP_GATTS_CONNECT_EVT: {
       ESP_LOGD(TAG, "BLE Client connected");
       this->add_client_(param->connect.conn_id);
-      this->emit_(BLEServerEvt::EmptyEvt::ON_CONNECT, param->connect.conn_id);
+      this->dispatch_callbacks_(CallbackType::ON_CONNECT, param->connect.conn_id);
       break;
     }
     case ESP_GATTS_DISCONNECT_EVT: {
       ESP_LOGD(TAG, "BLE Client disconnected");
       this->remove_client_(param->disconnect.conn_id);
       this->parent_->advertising_start();
-      this->emit_(BLEServerEvt::EmptyEvt::ON_DISCONNECT, param->disconnect.conn_id);
+      this->dispatch_callbacks_(CallbackType::ON_DISCONNECT, param->disconnect.conn_id);
       break;
     }
     case ESP_GATTS_REG_EVT: {
@@ -174,17 +180,46 @@ void BLEServer::gatts_event_handler(esp_gatts_cb_event_t event, esp_gatt_if_t ga
       break;
   }
 
-  for (const auto &pair : this->services_) {
-    pair.second->gatts_event_handler(event, gatts_if, param);
+  for (auto &entry : this->services_) {
+    entry.service->gatts_event_handler(event, gatts_if, param);
+  }
+}
+
+int8_t BLEServer::find_client_index_(uint16_t conn_id) const {
+  for (uint8_t i = 0; i < this->client_count_; i++) {
+    if (this->clients_[i] == conn_id)
+      return i;
+  }
+  return -1;
+}
+
+void BLEServer::add_client_(uint16_t conn_id) {
+  // Check if already in list
+  if (this->find_client_index_(conn_id) >= 0)
+    return;
+  // Add if there's space
+  if (this->client_count_ < USE_ESP32_BLE_MAX_CONNECTIONS) {
+    this->clients_[this->client_count_++] = conn_id;
+  } else {
+    // This should never happen since max clients is known at compile time
+    ESP_LOGE(TAG, "Client array full");
+  }
+}
+
+void BLEServer::remove_client_(uint16_t conn_id) {
+  int8_t index = this->find_client_index_(conn_id);
+  if (index >= 0) {
+    // Replace with last element and decrement count (client order not preserved)
+    this->clients_[index] = this->clients_[--this->client_count_];
   }
 }
 
 void BLEServer::ble_before_disabled_event_handler() {
   // Delete all clients
-  this->clients_.clear();
+  this->client_count_ = 0;
   // Delete all services
-  for (auto &pair : this->services_) {
-    pair.second->do_delete();
+  for (auto &entry : this->services_) {
+    entry.service->do_delete();
   }
   this->registered_ = false;
   this->state_ = INIT;

esphome/components/esp32_ble_server/ble_server.h

@@ -12,7 +12,7 @@
 #include <memory>
 #include <vector>
 #include <unordered_map>
-#include <unordered_set>
+#include <functional>
 
 #ifdef USE_ESP32
 
@@ -24,18 +24,7 @@ namespace esp32_ble_server {
 using namespace esp32_ble;
 using namespace bytebuffer;
 
-namespace BLEServerEvt {
-enum EmptyEvt {
-  ON_CONNECT,
-  ON_DISCONNECT,
-};
-}  // namespace BLEServerEvt
-
-class BLEServer : public Component,
-                  public GATTsEventHandler,
-                  public BLEStatusEventHandler,
-                  public Parented<ESP32BLE>,
-                  public EventEmitter<BLEServerEvt::EmptyEvt, uint16_t> {
+class BLEServer : public Component, public GATTsEventHandler, public BLEStatusEventHandler, public Parented<ESP32BLE> {
  public:
   void setup() override;
   void loop() override;
@@ -57,27 +46,56 @@ class BLEServer : public Component,
   void set_device_information_service(BLEService *service) { this->device_information_service_ = service; }
 
   esp_gatt_if_t get_gatts_if() { return this->gatts_if_; }
-  uint32_t get_connected_client_count() { return this->clients_.size(); }
-  const std::unordered_set<uint16_t> &get_clients() { return this->clients_; }
+  uint32_t get_connected_client_count() { return this->client_count_; }
+  const uint16_t *get_clients() const { return this->clients_; }
+  uint8_t get_client_count() const { return this->client_count_; }
 
   void gatts_event_handler(esp_gatts_cb_event_t event, esp_gatt_if_t gatts_if,
                            esp_ble_gatts_cb_param_t *param) override;
 
   void ble_before_disabled_event_handler() override;
 
+  // Direct callback registration - supports multiple callbacks
+  void on_connect(std::function<void(uint16_t)> &&callback) {
+    this->callbacks_.push_back({CallbackType::ON_CONNECT, std::move(callback)});
+  }
+  void on_disconnect(std::function<void(uint16_t)> &&callback) {
+    this->callbacks_.push_back({CallbackType::ON_DISCONNECT, std::move(callback)});
+  }
+
  protected:
-  static std::string get_service_key(ESPBTUUID uuid, uint8_t inst_id);
+  enum class CallbackType : uint8_t {
+    ON_CONNECT,
+    ON_DISCONNECT,
+  };
+
+  struct CallbackEntry {
+    CallbackType type;
+    std::function<void(uint16_t)> callback;
+  };
+
+  struct ServiceEntry {
+    ESPBTUUID uuid;
+    uint8_t inst_id;
+    BLEService *service;
+  };
+
   void restart_advertising_();
 
-  void add_client_(uint16_t conn_id) { this->clients_.insert(conn_id); }
-  void remove_client_(uint16_t conn_id) { this->clients_.erase(conn_id); }
+  int8_t find_client_index_(uint16_t conn_id) const;
+  void add_client_(uint16_t conn_id);
+  void remove_client_(uint16_t conn_id);
+  void dispatch_callbacks_(CallbackType type, uint16_t conn_id);
+
+  std::vector<CallbackEntry> callbacks_;
 
   std::vector<uint8_t> manufacturer_data_{};
   esp_gatt_if_t gatts_if_{0};
   bool registered_{false};
 
-  std::unordered_set<uint16_t> clients_;
-  std::unordered_map<std::string, BLEService *> services_{};
+  uint16_t clients_[USE_ESP32_BLE_MAX_CONNECTIONS]{};
+  uint8_t client_count_{0};
+  std::vector<ServiceEntry> services_{};
   std::vector<BLEService *> services_to_start_{};
   BLEService *device_information_service_{};
 

esphome/components/esp32_ble_server/ble_server_automations.cpp

@@ -9,66 +9,82 @@ namespace esp32_ble_server_automations {
 
 using namespace esp32_ble;
 
+#ifdef USE_ESP32_BLE_SERVER_CHARACTERISTIC_ON_WRITE
 Trigger<std::vector<uint8_t>, uint16_t> *BLETriggers::create_characteristic_on_write_trigger(
     BLECharacteristic *characteristic) {
   Trigger<std::vector<uint8_t>, uint16_t> *on_write_trigger =  // NOLINT(cppcoreguidelines-owning-memory)
       new Trigger<std::vector<uint8_t>, uint16_t>();
-  characteristic->EventEmitter<BLECharacteristicEvt::VectorEvt, std::vector<uint8_t>, uint16_t>::on(
-      BLECharacteristicEvt::VectorEvt::ON_WRITE,
-      [on_write_trigger](const std::vector<uint8_t> &data, uint16_t id) { on_write_trigger->trigger(data, id); });
+  characteristic->on_write([on_write_trigger](std::span<const uint8_t> data, uint16_t id) {
+    // Convert span to vector for trigger
+    on_write_trigger->trigger(std::vector<uint8_t>(data.begin(), data.end()), id);
+  });
   return on_write_trigger;
 }
+#endif
 
+#ifdef USE_ESP32_BLE_SERVER_DESCRIPTOR_ON_WRITE
 Trigger<std::vector<uint8_t>, uint16_t> *BLETriggers::create_descriptor_on_write_trigger(BLEDescriptor *descriptor) {
   Trigger<std::vector<uint8_t>, uint16_t> *on_write_trigger =  // NOLINT(cppcoreguidelines-owning-memory)
       new Trigger<std::vector<uint8_t>, uint16_t>();
-  descriptor->on(
-      BLEDescriptorEvt::VectorEvt::ON_WRITE,
-      [on_write_trigger](const std::vector<uint8_t> &data, uint16_t id) { on_write_trigger->trigger(data, id); });
+  descriptor->on_write([on_write_trigger](std::span<const uint8_t> data, uint16_t id) {
+    // Convert span to vector for trigger
+    on_write_trigger->trigger(std::vector<uint8_t>(data.begin(), data.end()), id);
+  });
   return on_write_trigger;
 }
+#endif
 
+#ifdef USE_ESP32_BLE_SERVER_ON_CONNECT
 Trigger<uint16_t> *BLETriggers::create_server_on_connect_trigger(BLEServer *server) {
   Trigger<uint16_t> *on_connect_trigger = new Trigger<uint16_t>();  // NOLINT(cppcoreguidelines-owning-memory)
-  server->on(BLEServerEvt::EmptyEvt::ON_CONNECT,
-             [on_connect_trigger](uint16_t conn_id) { on_connect_trigger->trigger(conn_id); });
+  server->on_connect([on_connect_trigger](uint16_t conn_id) { on_connect_trigger->trigger(conn_id); });
   return on_connect_trigger;
 }
+#endif
 
+#ifdef USE_ESP32_BLE_SERVER_ON_DISCONNECT
 Trigger<uint16_t> *BLETriggers::create_server_on_disconnect_trigger(BLEServer *server) {
   Trigger<uint16_t> *on_disconnect_trigger = new Trigger<uint16_t>();  // NOLINT(cppcoreguidelines-owning-memory)
-  server->on(BLEServerEvt::EmptyEvt::ON_DISCONNECT,
-             [on_disconnect_trigger](uint16_t conn_id) { on_disconnect_trigger->trigger(conn_id); });
+  server->on_disconnect([on_disconnect_trigger](uint16_t conn_id) { on_disconnect_trigger->trigger(conn_id); });
   return on_disconnect_trigger;
 }
+#endif
 
+#ifdef USE_ESP32_BLE_SERVER_SET_VALUE_ACTION
 void BLECharacteristicSetValueActionManager::set_listener(BLECharacteristic *characteristic,
-                                                          EventEmitterListenerID listener_id,
                                                           const std::function<void()> &pre_notify_listener) {
-  // Check if there is already a listener for this characteristic
-  if (this->listeners_.count(characteristic) > 0) {
-    // Unpack the pair listener_id, pre_notify_listener_id
-    auto listener_pairs = this->listeners_[characteristic];
-    EventEmitterListenerID old_listener_id = listener_pairs.first;
-    EventEmitterListenerID old_pre_notify_listener_id = listener_pairs.second;
-    // Remove the previous listener
-    characteristic->EventEmitter<BLECharacteristicEvt::EmptyEvt, uint16_t>::off(BLECharacteristicEvt::EmptyEvt::ON_READ,
-                                                                                old_listener_id);
-    // Remove the pre-notify listener
-    this->off(BLECharacteristicSetValueActionEvt::PRE_NOTIFY, old_pre_notify_listener_id);
+  // Find and remove existing listener for this characteristic
+  auto *existing = this->find_listener_(characteristic);
+  if (existing != nullptr) {
+    // Remove from vector
+    this->remove_listener_(characteristic);
+  }
+  // Save the entry to the vector
+  this->listeners_.push_back({characteristic, pre_notify_listener});
+}
+
+BLECharacteristicSetValueActionManager::ListenerEntry *BLECharacteristicSetValueActionManager::find_listener_(
+    BLECharacteristic *characteristic) {
+  for (auto &entry : this->listeners_) {
+    if (entry.characteristic == characteristic) {
+      return &entry;
+    }
+  }
+  return nullptr;
+}
+
+void BLECharacteristicSetValueActionManager::remove_listener_(BLECharacteristic *characteristic) {
+  // Since we typically have very few listeners, optimize by swapping with back and popping
+  for (size_t i = 0; i < this->listeners_.size(); i++) {
+    if (this->listeners_[i].characteristic == characteristic) {
+      // Swap with last element and pop (safe even when i is the last element)
+      this->listeners_[i] = this->listeners_.back();
+      this->listeners_.pop_back();
+      return;
+    }
   }
-  // Create a new listener for the pre-notify event
-  EventEmitterListenerID pre_notify_listener_id =
-      this->on(BLECharacteristicSetValueActionEvt::PRE_NOTIFY,
-               [pre_notify_listener, characteristic](const BLECharacteristic *evt_characteristic) {
-                 // Only call the pre-notify listener if the characteristic is the one we are interested in
-                 if (characteristic == evt_characteristic) {
-                   pre_notify_listener();
-                 }
-               });
-  // Save the pair listener_id, pre_notify_listener_id to the map
-  this->listeners_[characteristic] = std::make_pair(listener_id, pre_notify_listener_id);
 }
+#endif
 
 }  // namespace esp32_ble_server_automations
 }  // namespace esp32_ble_server

esphome/components/esp32_ble_server/ble_server_automations.h

@@ -4,11 +4,9 @@
 #include "ble_characteristic.h"
 #include "ble_descriptor.h"
 
-#include "esphome/components/event_emitter/event_emitter.h"
 #include "esphome/core/automation.h"
 
 #include <vector>
-#include <unordered_map>
 #include <functional>
 
 #ifdef USE_ESP32
@@ -19,41 +17,53 @@ namespace esp32_ble_server {
 namespace esp32_ble_server_automations {
 
 using namespace esp32_ble;
-using namespace event_emitter;
 
 class BLETriggers {
  public:
+#ifdef USE_ESP32_BLE_SERVER_CHARACTERISTIC_ON_WRITE
   static Trigger<std::vector<uint8_t>, uint16_t> *create_characteristic_on_write_trigger(
       BLECharacteristic *characteristic);
+#endif
+#ifdef USE_ESP32_BLE_SERVER_DESCRIPTOR_ON_WRITE
   static Trigger<std::vector<uint8_t>, uint16_t> *create_descriptor_on_write_trigger(BLEDescriptor *descriptor);
+#endif
+#ifdef USE_ESP32_BLE_SERVER_ON_CONNECT
   static Trigger<uint16_t> *create_server_on_connect_trigger(BLEServer *server);
+#endif
+#ifdef USE_ESP32_BLE_SERVER_ON_DISCONNECT
   static Trigger<uint16_t> *create_server_on_disconnect_trigger(BLEServer *server);
+#endif
 };
 
-enum BLECharacteristicSetValueActionEvt {
-  PRE_NOTIFY,
-};
-
+#ifdef USE_ESP32_BLE_SERVER_SET_VALUE_ACTION
 // Class to make sure only one BLECharacteristicSetValueAction is active at a time for each characteristic
-class BLECharacteristicSetValueActionManager
-    : public EventEmitter<BLECharacteristicSetValueActionEvt, BLECharacteristic *> {
+class BLECharacteristicSetValueActionManager {
  public:
   // Singleton pattern
   static BLECharacteristicSetValueActionManager *get_instance() {
     static BLECharacteristicSetValueActionManager instance;
     return &instance;
   }
-  void set_listener(BLECharacteristic *characteristic, EventEmitterListenerID listener_id,
-                    const std::function<void()> &pre_notify_listener);
-  EventEmitterListenerID get_listener(BLECharacteristic *characteristic) {
-    return this->listeners_[characteristic].first;
-  }
+  void set_listener(BLECharacteristic *characteristic, const std::function<void()> &pre_notify_listener);
+  bool has_listener(BLECharacteristic *characteristic) { return this->find_listener_(characteristic) != nullptr; }
   void emit_pre_notify(BLECharacteristic *characteristic) {
-    this->emit_(BLECharacteristicSetValueActionEvt::PRE_NOTIFY, characteristic);
+    for (const auto &entry : this->listeners_) {
+      if (entry.characteristic == characteristic) {
+        entry.pre_notify_listener();
+        break;
+      }
+    }
   }
 
  private:
-  std::unordered_map<BLECharacteristic *, std::pair<EventEmitterListenerID, EventEmitterListenerID>> listeners_;
+  struct ListenerEntry {
+    BLECharacteristic *characteristic;
+    std::function<void()> pre_notify_listener;
+  };
+  std::vector<ListenerEntry> listeners_;
+
+  ListenerEntry *find_listener_(BLECharacteristic *characteristic);
+  void remove_listener_(BLECharacteristic *characteristic);
 };
 
 template<typename... Ts> class BLECharacteristicSetValueAction : public Action<Ts...> {
@@ -63,32 +73,34 @@ template<typename... Ts> class BLECharacteristicSetValueAction : public Action<T
   void set_buffer(ByteBuffer buffer) { this->set_buffer(buffer.get_data()); }
   void play(Ts... x) override {
     // If the listener is already set, do nothing
-    if (BLECharacteristicSetValueActionManager::get_instance()->get_listener(this->parent_) == this->listener_id_)
+    if (BLECharacteristicSetValueActionManager::get_instance()->has_listener(this->parent_))
       return;
     // Set initial value
     this->parent_->set_value(this->buffer_.value(x...));
     // Set the listener for read events
-    this->listener_id_ = this->parent_->EventEmitter<BLECharacteristicEvt::EmptyEvt, uint16_t>::on(
-        BLECharacteristicEvt::EmptyEvt::ON_READ, [this, x...](uint16_t id) {
-          // Set the value of the characteristic every time it is read
-          this->parent_->set_value(this->buffer_.value(x...));
-        });
+    this->parent_->on_read([this, x...](uint16_t id) {
+      // Set the value of the characteristic every time it is read
+      this->parent_->set_value(this->buffer_.value(x...));
+    });
     // Set the listener in the global manager so only one BLECharacteristicSetValueAction is set for each characteristic
     BLECharacteristicSetValueActionManager::get_instance()->set_listener(
-        this->parent_, this->listener_id_, [this, x...]() { this->parent_->set_value(this->buffer_.value(x...)); });
+        this->parent_, [this, x...]() { this->parent_->set_value(this->buffer_.value(x...)); });
   }
 
  protected:
   BLECharacteristic *parent_;
-  EventEmitterListenerID listener_id_;
 };
+#endif  // USE_ESP32_BLE_SERVER_SET_VALUE_ACTION
 
+#ifdef USE_ESP32_BLE_SERVER_NOTIFY_ACTION
 template<typename... Ts> class BLECharacteristicNotifyAction : public Action<Ts...> {
  public:
   BLECharacteristicNotifyAction(BLECharacteristic *characteristic) : parent_(characteristic) {}
   void play(Ts... x) override {
+#ifdef USE_ESP32_BLE_SERVER_SET_VALUE_ACTION
     // Call the pre-notify event
     BLECharacteristicSetValueActionManager::get_instance()->emit_pre_notify(this->parent_);
+#endif
     // Notify the characteristic
     this->parent_->notify();
   }
@@ -96,7 +108,9 @@ template<typename... Ts> class BLECharacteristicNotifyAction : public Action<Ts.
  protected:
   BLECharacteristic *parent_;
 };
+#endif  // USE_ESP32_BLE_SERVER_NOTIFY_ACTION
 
+#ifdef USE_ESP32_BLE_SERVER_DESCRIPTOR_SET_VALUE_ACTION
 template<typename... Ts> class BLEDescriptorSetValueAction : public Action<Ts...> {
  public:
   BLEDescriptorSetValueAction(BLEDescriptor *descriptor) : parent_(descriptor) {}
@@ -107,6 +121,7 @@ template<typename... Ts> class BLEDescriptorSetValueAction : public Action<Ts...
  protected:
   BLEDescriptor *parent_;
 };
+#endif  // USE_ESP32_BLE_SERVER_DESCRIPTOR_SET_VALUE_ACTION
 
 }  // namespace esp32_ble_server_automations
 }  // namespace esp32_ble_server