esphome 2024.12.3__py3-none-any.whl → 2025.2.0b1__py3-none-any.whl

esphome/components/esp32_ble_server/ble_characteristic.cpp

@@ -32,70 +32,36 @@ BLECharacteristic::BLECharacteristic(const ESPBTUUID uuid, uint32_t properties)
   this->set_write_no_response_property((properties & PROPERTY_WRITE_NR) != 0);
 }
 
-void BLECharacteristic::set_value(std::vector<uint8_t> value) {
+void BLECharacteristic::set_value(ByteBuffer buffer) { this->set_value(buffer.get_data()); }
+
+void BLECharacteristic::set_value(const std::vector<uint8_t> &buffer) {
   xSemaphoreTake(this->set_value_lock_, 0L);
-  this->value_ = std::move(value);
+  this->value_ = buffer;
   xSemaphoreGive(this->set_value_lock_);
 }
-void BLECharacteristic::set_value(const std::string &value) {
-  this->set_value(std::vector<uint8_t>(value.begin(), value.end()));
-}
-void BLECharacteristic::set_value(const uint8_t *data, size_t length) {
-  this->set_value(std::vector<uint8_t>(data, data + length));
-}
-void BLECharacteristic::set_value(uint8_t &data) {
-  uint8_t temp[1];
-  temp[0] = data;
-  this->set_value(temp, 1);
-}
-void BLECharacteristic::set_value(uint16_t &data) {
-  uint8_t temp[2];
-  temp[0] = data;
-  temp[1] = data >> 8;
-  this->set_value(temp, 2);
-}
-void BLECharacteristic::set_value(uint32_t &data) {
-  uint8_t temp[4];
-  temp[0] = data;
-  temp[1] = data >> 8;
-  temp[2] = data >> 16;
-  temp[3] = data >> 24;
-  this->set_value(temp, 4);
-}
-void BLECharacteristic::set_value(int &data) {
-  uint8_t temp[4];
-  temp[0] = data;
-  temp[1] = data >> 8;
-  temp[2] = data >> 16;
-  temp[3] = data >> 24;
-  this->set_value(temp, 4);
-}
-void BLECharacteristic::set_value(float &data) {
-  float temp = data;
-  this->set_value((uint8_t *) &temp, 4);
-}
-void BLECharacteristic::set_value(double &data) {
-  double temp = data;
-  this->set_value((uint8_t *) &temp, 8);
-}
-void BLECharacteristic::set_value(bool &data) {
-  uint8_t temp[1];
-  temp[0] = data;
-  this->set_value(temp, 1);
+void BLECharacteristic::set_value(const std::string &buffer) {
+  this->set_value(std::vector<uint8_t>(buffer.begin(), buffer.end()));
 }
 
-void BLECharacteristic::notify(bool notification) {
-  if (!notification) {
-    ESP_LOGW(TAG, "notification=false is not yet supported");
-    // TODO: Handle when notification=false
-  }
-  if (this->service_->get_server()->get_connected_client_count() == 0)
+void BLECharacteristic::notify() {
+  if (this->service_ == nullptr || this->service_->get_server() == nullptr ||
+      this->service_->get_server()->get_connected_client_count() == 0)
     return;
 
   for (auto &client : this->service_->get_server()->get_clients()) {
     size_t length = this->value_.size();
-    esp_err_t err = esp_ble_gatts_send_indicate(this->service_->get_server()->get_gatts_if(), client.first,
-                                                this->handle_, length, this->value_.data(), false);
+    // If the client is not in the list of clients to notify, skip it
+    if (this->clients_to_notify_.count(client) == 0)
+      continue;
+    // If the client is in the list of clients to notify, check if it requires an ack (i.e. INDICATE)
+    bool require_ack = this->clients_to_notify_[client];
+    // TODO: Remove this block when INDICATE acknowledgment is supported
+    if (require_ack) {
+      ESP_LOGW(TAG, "INDICATE acknowledgment is not yet supported (i.e. it works as a NOTIFY)");
+      require_ack = false;
+    }
+    esp_err_t err = esp_ble_gatts_send_indicate(this->service_->get_server()->get_gatts_if(), client, this->handle_,
+                                                length, this->value_.data(), require_ack);
     if (err != ESP_OK) {
       ESP_LOGE(TAG, "esp_ble_gatts_send_indicate failed %d", err);
       return;
@@ -103,7 +69,24 @@ void BLECharacteristic::notify(bool notification) {
   }
 }
 
-void BLECharacteristic::add_descriptor(BLEDescriptor *descriptor) { this->descriptors_.push_back(descriptor); }
+void BLECharacteristic::add_descriptor(BLEDescriptor *descriptor) {
+  // If the descriptor is the CCCD descriptor, listen to its write event to know if the client wants to be notified
+  if (descriptor->get_uuid() == ESPBTUUID::from_uint16(ESP_GATT_UUID_CHAR_CLIENT_CONFIG)) {
+    descriptor->on(BLEDescriptorEvt::VectorEvt::ON_WRITE, [this](const std::vector<uint8_t> &value, uint16_t conn_id) {
+      if (value.size() != 2)
+        return;
+      uint16_t cccd = encode_uint16(value[1], value[0]);
+      bool notify = (cccd & 1) != 0;
+      bool indicate = (cccd & 2) != 0;
+      if (notify || indicate) {
+        this->clients_to_notify_[conn_id] = indicate;
+      } else {
+        this->clients_to_notify_.erase(conn_id);
+      }
+    });
+  }
+  this->descriptors_.push_back(descriptor);
+}
 
 void BLECharacteristic::remove_descriptor(BLEDescriptor *descriptor) {
   this->descriptors_.erase(std::remove(this->descriptors_.begin(), this->descriptors_.end(), descriptor),
@@ -223,6 +206,9 @@ void BLECharacteristic::gatts_event_handler(esp_gatts_cb_event_t event, esp_gatt
       if (!param->read.need_rsp)
         break;  // For some reason you can request a read but not want a response
 
+      this->EventEmitter<BLECharacteristicEvt::EmptyEvt, uint16_t>::emit_(BLECharacteristicEvt::EmptyEvt::ON_READ,
+                                                                          param->read.conn_id);
+
       uint16_t max_offset = 22;
 
       esp_gatt_rsp_t response;
@@ -262,13 +248,13 @@ void BLECharacteristic::gatts_event_handler(esp_gatts_cb_event_t event, esp_gatt
     }
     case ESP_GATTS_WRITE_EVT: {
       if (this->handle_ != param->write.handle)
-        return;
+        break;
 
       if (param->write.is_prep) {
         this->value_.insert(this->value_.end(), param->write.value, param->write.value + param->write.len);
         this->write_event_ = true;
       } else {
-        this->set_value(param->write.value, param->write.len);
+        this->set_value(ByteBuffer::wrap(param->write.value, param->write.len));
       }
 
       if (param->write.need_rsp) {
@@ -289,7 +275,8 @@ void BLECharacteristic::gatts_event_handler(esp_gatts_cb_event_t event, esp_gatt
       }
 
       if (!param->write.is_prep) {
-        this->on_write_(this->value_);
+        this->EventEmitter<BLECharacteristicEvt::VectorEvt, std::vector<uint8_t>, uint16_t>::emit_(
+            BLECharacteristicEvt::VectorEvt::ON_WRITE, this->value_, param->write.conn_id);
       }
 
       break;
@@ -300,7 +287,8 @@ void BLECharacteristic::gatts_event_handler(esp_gatts_cb_event_t event, esp_gatt
         break;
       this->write_event_ = false;
       if (param->exec_write.exec_write_flag == ESP_GATT_PREP_WRITE_EXEC) {
-        this->on_write_(this->value_);
+        this->EventEmitter<BLECharacteristicEvt::VectorEvt, std::vector<uint8_t>, uint16_t>::emit_(
+            BLECharacteristicEvt::VectorEvt::ON_WRITE, this->value_, param->exec_write.conn_id);
       }
       esp_err_t err =
           esp_ble_gatts_send_response(gatts_if, param->write.conn_id, param->write.trans_id, ESP_GATT_OK, nullptr);

esphome/components/esp32_ble_server/ble_characteristic.h

@@ -2,8 +2,11 @@
 
 #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>
 
 #ifdef USE_ESP32
 
@@ -19,24 +22,30 @@ namespace esphome {
 namespace esp32_ble_server {
 
 using namespace esp32_ble;
+using namespace bytebuffer;
+using namespace event_emitter;
 
 class BLEService;
 
-class BLECharacteristic {
+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> {
  public:
   BLECharacteristic(ESPBTUUID uuid, uint32_t properties);
   ~BLECharacteristic();
 
-  void set_value(const uint8_t *data, size_t length);
-  void set_value(std::vector<uint8_t> value);
-  void set_value(const std::string &value);
-  void set_value(uint8_t &data);
-  void set_value(uint16_t &data);
-  void set_value(uint32_t &data);
-  void set_value(int &data);
-  void set_value(float &data);
-  void set_value(double &data);
-  void set_value(bool &data);
+  void set_value(ByteBuffer buffer);
+  void set_value(const std::vector<uint8_t> &buffer);
+  void set_value(const std::string &buffer);
 
   void set_broadcast_property(bool value);
   void set_indicate_property(bool value);
@@ -45,13 +54,12 @@ class BLECharacteristic {
   void set_write_property(bool value);
   void set_write_no_response_property(bool value);
 
-  void notify(bool notification = true);
+  void notify();
 
   void do_create(BLEService *service);
+  void do_delete() { this->clients_to_notify_.clear(); }
   void gatts_event_handler(esp_gatts_cb_event_t event, esp_gatt_if_t gatts_if, esp_ble_gatts_cb_param_t *param);
 
-  void on_write(const std::function<void(const std::vector<uint8_t> &)> &&func) { this->on_write_ = func; }
-
   void add_descriptor(BLEDescriptor *descriptor);
   void remove_descriptor(BLEDescriptor *descriptor);
 
@@ -71,7 +79,7 @@ class BLECharacteristic {
 
  protected:
   bool write_event_{false};
-  BLEService *service_;
+  BLEService *service_{};
   ESPBTUUID uuid_;
   esp_gatt_char_prop_t properties_;
   uint16_t handle_{0xFFFF};
@@ -81,8 +89,7 @@ class BLECharacteristic {
   SemaphoreHandle_t set_value_lock_;
 
   std::vector<BLEDescriptor *> descriptors_;
-
-  std::function<void(const std::vector<uint8_t> &)> on_write_;
+  std::unordered_map<uint16_t, bool> clients_to_notify_;
 
   esp_gatt_perm_t permissions_ = ESP_GATT_PERM_READ | ESP_GATT_PERM_WRITE;
 

esphome/components/esp32_ble_server/ble_descriptor.cpp

@@ -12,11 +12,19 @@ namespace esp32_ble_server {
 
 static const char *const TAG = "esp32_ble_server.descriptor";
 
-BLEDescriptor::BLEDescriptor(ESPBTUUID uuid, uint16_t max_len) {
+static RAMAllocator<uint8_t> descriptor_allocator{};  // NOLINT
+
+BLEDescriptor::BLEDescriptor(ESPBTUUID uuid, uint16_t max_len, bool read, bool write) {
   this->uuid_ = uuid;
   this->value_.attr_len = 0;
   this->value_.attr_max_len = max_len;
-  this->value_.attr_value = (uint8_t *) malloc(max_len);  // NOLINT
+  this->value_.attr_value = descriptor_allocator.allocate(max_len);
+  if (read) {
+    this->permissions_ |= ESP_GATT_PERM_READ;
+  }
+  if (write) {
+    this->permissions_ |= ESP_GATT_PERM_WRITE;
+  }
 }
 
 BLEDescriptor::~BLEDescriptor() { free(this->value_.attr_value); }  // NOLINT
@@ -38,14 +46,15 @@ void BLEDescriptor::do_create(BLECharacteristic *characteristic) {
   this->state_ = CREATING;
 }
 
-void BLEDescriptor::set_value(const std::string &value) { this->set_value((uint8_t *) value.data(), value.length()); }
-void BLEDescriptor::set_value(const uint8_t *data, size_t length) {
+void BLEDescriptor::set_value(std::vector<uint8_t> buffer) {
+  size_t length = buffer.size();
+
   if (length > this->value_.attr_max_len) {
     ESP_LOGE(TAG, "Size %d too large, must be no bigger than %d", length, this->value_.attr_max_len);
     return;
   }
   this->value_.attr_len = length;
-  memcpy(this->value_.attr_value, data, length);
+  memcpy(this->value_.attr_value, buffer.data(), length);
 }
 
 void BLEDescriptor::gatts_event_handler(esp_gatts_cb_event_t event, esp_gatt_if_t gatts_if,
@@ -61,10 +70,13 @@ void BLEDescriptor::gatts_event_handler(esp_gatts_cb_event_t event, esp_gatt_if_
       break;
     }
     case ESP_GATTS_WRITE_EVT: {
-      if (this->handle_ == param->write.handle) {
-        this->value_.attr_len = param->write.len;
-        memcpy(this->value_.attr_value, param->write.value, param->write.len);
-      }
+      if (this->handle_ != param->write.handle)
+        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);
       break;
     }
     default:

esphome/components/esp32_ble_server/ble_descriptor.h

@@ -1,6 +1,8 @@
 #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
 
@@ -11,17 +13,26 @@ namespace esphome {
 namespace esp32_ble_server {
 
 using namespace esp32_ble;
+using namespace bytebuffer;
+using namespace event_emitter;
 
 class BLECharacteristic;
 
-class BLEDescriptor {
+namespace BLEDescriptorEvt {
+enum VectorEvt {
+  ON_WRITE,
+};
+}  // namespace BLEDescriptorEvt
+
+class BLEDescriptor : public EventEmitter<BLEDescriptorEvt::VectorEvt, std::vector<uint8_t>, uint16_t> {
  public:
-  BLEDescriptor(ESPBTUUID uuid, uint16_t max_len = 100);
+  BLEDescriptor(ESPBTUUID uuid, uint16_t max_len = 100, bool read = true, bool write = true);
   virtual ~BLEDescriptor();
   void do_create(BLECharacteristic *characteristic);
+  ESPBTUUID get_uuid() const { return this->uuid_; }
 
-  void set_value(const std::string &value);
-  void set_value(const uint8_t *data, size_t length);
+  void set_value(std::vector<uint8_t> buffer);
+  void set_value(ByteBuffer buffer) { this->set_value(buffer.get_data()); }
 
   void gatts_event_handler(esp_gatts_cb_event_t event, esp_gatt_if_t gatts_if, esp_ble_gatts_cb_param_t *param);
 
@@ -33,9 +44,9 @@ class BLEDescriptor {
   ESPBTUUID uuid_;
   uint16_t handle_{0xFFFF};
 
-  esp_attr_value_t value_;
+  esp_attr_value_t value_{};
 
-  esp_gatt_perm_t permissions_ = ESP_GATT_PERM_READ | ESP_GATT_PERM_WRITE;
+  esp_gatt_perm_t permissions_{};
 
   enum State : uint8_t {
     FAILED = 0x00,

esphome/components/esp32_ble_server/ble_server.cpp

@@ -19,11 +19,6 @@ namespace esp32_ble_server {
 
 static const char *const TAG = "esp32_ble_server";
 
-static const uint16_t DEVICE_INFORMATION_SERVICE_UUID = 0x180A;
-static const uint16_t MODEL_UUID = 0x2A24;
-static const uint16_t VERSION_UUID = 0x2A26;
-static const uint16_t MANUFACTURER_UUID = 0x2A29;
-
 void BLEServer::setup() {
   if (this->parent_->is_failed()) {
     this->mark_failed();
@@ -38,9 +33,27 @@ void BLEServer::loop() {
     return;
   }
   switch (this->state_) {
-    case RUNNING:
-      return;
-
+    case RUNNING: {
+      // Start all services that are pending to start
+      if (!this->services_to_start_.empty()) {
+        uint16_t index_to_remove = 0;
+        // Iterate over the services to start
+        for (unsigned i = 0; i < this->services_to_start_.size(); i++) {
+          BLEService *service = this->services_to_start_[i];
+          if (service->is_created()) {
+            service->start();  // Needs to be called once per characteristic in the service
+          } else {
+            index_to_remove = i + 1;
+          }
+        }
+        // Remove the services that have been started
+        if (index_to_remove > 0) {
+          this->services_to_start_.erase(this->services_to_start_.begin(),
+                                         this->services_to_start_.begin() + index_to_remove - 1);
+        }
+      }
+      break;
+    }
     case INIT: {
       esp_err_t err = esp_ble_gatts_app_register(0);
       if (err != ESP_OK) {
@@ -53,29 +66,26 @@ void BLEServer::loop() {
     }
     case REGISTERING: {
       if (this->registered_) {
+        // Create the device information service first so
+        // 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_) {
+            continue;
+          }
           pair.second->do_create(this);
         }
-        if (this->device_information_service_ == nullptr) {
-          this->create_service(ESPBTUUID::from_uint16(DEVICE_INFORMATION_SERVICE_UUID));
-          this->device_information_service_ =
-              this->get_service(ESPBTUUID::from_uint16(DEVICE_INFORMATION_SERVICE_UUID));
-          this->create_device_characteristics_();
-        }
         this->state_ = STARTING_SERVICE;
       }
       break;
     }
     case STARTING_SERVICE: {
-      if (!this->device_information_service_->is_created()) {
-        break;
-      }
       if (this->device_information_service_->is_running()) {
         this->state_ = RUNNING;
         this->restart_advertising_();
         ESP_LOGD(TAG, "BLE server setup successfully");
-      } else if (!this->device_information_service_->is_starting()) {
+      } else if (this->device_information_service_->is_created()) {
         this->device_information_service_->start();
       }
       break;
@@ -93,81 +103,66 @@ void BLEServer::restart_advertising_() {
   }
 }
 
-bool BLEServer::create_device_characteristics_() {
-  if (this->model_.has_value()) {
-    BLECharacteristic *model =
-        this->device_information_service_->create_characteristic(MODEL_UUID, BLECharacteristic::PROPERTY_READ);
-    model->set_value(this->model_.value());
-  } else {
-    BLECharacteristic *model =
-        this->device_information_service_->create_characteristic(MODEL_UUID, BLECharacteristic::PROPERTY_READ);
-    model->set_value(ESPHOME_BOARD);
-  }
-
-  BLECharacteristic *version =
-      this->device_information_service_->create_characteristic(VERSION_UUID, BLECharacteristic::PROPERTY_READ);
-  version->set_value("ESPHome " ESPHOME_VERSION);
-
-  BLECharacteristic *manufacturer =
-      this->device_information_service_->create_characteristic(MANUFACTURER_UUID, BLECharacteristic::PROPERTY_READ);
-  manufacturer->set_value(this->manufacturer_);
-
-  return true;
-}
-
-void BLEServer::create_service(ESPBTUUID uuid, bool advertise, uint16_t num_handles, uint8_t inst_id) {
+BLEService *BLEServer::create_service(ESPBTUUID uuid, bool advertise, uint16_t num_handles) {
   ESP_LOGV(TAG, "Creating BLE service - %s", uuid.to_string().c_str());
-  // If the service already exists, do nothing
-  BLEService *service = this->get_service(uuid);
-  if (service != nullptr) {
-    ESP_LOGW(TAG, "BLE service %s already exists", uuid.to_string().c_str());
-    return;
+  // Calculate the inst_id for the service
+  uint8_t inst_id = 0;
+  for (; inst_id < 0xFF; inst_id++) {
+    if (this->get_service(uuid, inst_id) == nullptr) {
+      break;
+    }
+  }
+  if (inst_id == 0xFF) {
+    ESP_LOGW(TAG, "Could not create BLE service %s, too many instances", uuid.to_string().c_str());
+    return nullptr;
   }
-  service = new BLEService(uuid, num_handles, inst_id, advertise);  // NOLINT(cppcoreguidelines-owning-memory)
-  this->services_.emplace(uuid.to_string(), service);
-  service->do_create(this);
+  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);
+  if (this->parent_->is_active() && this->registered_) {
+    service->do_create(this);
+  }
+  return service;
 }
 
-void BLEServer::remove_service(ESPBTUUID uuid) {
-  ESP_LOGV(TAG, "Removing BLE service - %s", uuid.to_string().c_str());
-  BLEService *service = this->get_service(uuid);
+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 not found", uuid.to_string().c_str());
+    ESP_LOGW(TAG, "BLE service %s %d does not exist", uuid.to_string().c_str(), inst_id);
     return;
   }
   service->do_delete();
   delete service;  // NOLINT(cppcoreguidelines-owning-memory)
-  this->services_.erase(uuid.to_string());
+  this->services_.erase(BLEServer::get_service_key(uuid, inst_id));
 }
 
-BLEService *BLEServer::get_service(ESPBTUUID uuid) {
+BLEService *BLEServer::get_service(ESPBTUUID uuid, uint8_t inst_id) {
   BLEService *service = nullptr;
-  if (this->services_.count(uuid.to_string()) > 0) {
-    service = this->services_.at(uuid.to_string());
+  if (this->services_.count(BLEServer::get_service_key(uuid, inst_id)) > 0) {
+    service = this->services_.at(BLEServer::get_service_key(uuid, inst_id));
   }
   return service;
 }
 
+std::string BLEServer::get_service_key(ESPBTUUID uuid, uint8_t inst_id) {
+  return uuid.to_string() + std::to_string(inst_id);
+}
+
 void BLEServer::gatts_event_handler(esp_gatts_cb_event_t event, esp_gatt_if_t gatts_if,
                                     esp_ble_gatts_cb_param_t *param) {
   switch (event) {
     case ESP_GATTS_CONNECT_EVT: {
       ESP_LOGD(TAG, "BLE Client connected");
-      this->add_client_(param->connect.conn_id, (void *) this);
-      this->connected_clients_++;
-      for (auto *component : this->service_components_) {
-        component->on_client_connect();
-      }
+      this->add_client_(param->connect.conn_id);
+      this->emit_(BLEServerEvt::EmptyEvt::ON_CONNECT, param->connect.conn_id);
       break;
     }
     case ESP_GATTS_DISCONNECT_EVT: {
       ESP_LOGD(TAG, "BLE Client disconnected");
-      if (this->remove_client_(param->disconnect.conn_id))
-        this->connected_clients_--;
+      this->remove_client_(param->disconnect.conn_id);
       this->parent_->advertising_start();
-      for (auto *component : this->service_components_) {
-        component->on_client_disconnect();
-      }
+      this->emit_(BLEServerEvt::EmptyEvt::ON_DISCONNECT, param->disconnect.conn_id);
       break;
     }
     case ESP_GATTS_REG_EVT: {

esphome/components/esp32_ble_server/ble_server.h

@@ -4,36 +4,38 @@
 #include "ble_characteristic.h"
 
 #include "esphome/components/esp32_ble/ble.h"
-#include "esphome/components/esp32_ble/ble_advertising.h"
 #include "esphome/components/esp32_ble/ble_uuid.h"
-#include "esphome/components/esp32_ble/queue.h"
+#include "esphome/components/bytebuffer/bytebuffer.h"
 #include "esphome/core/component.h"
 #include "esphome/core/helpers.h"
-#include "esphome/core/preferences.h"
 
 #include <memory>
 #include <vector>
 #include <unordered_map>
+#include <unordered_set>
 
 #ifdef USE_ESP32
 
-#include <esp_gap_ble_api.h>
 #include <esp_gatts_api.h>
 
 namespace esphome {
 namespace esp32_ble_server {
 
 using namespace esp32_ble;
+using namespace bytebuffer;
 
-class BLEServiceComponent {
- public:
-  virtual void on_client_connect(){};
-  virtual void on_client_disconnect(){};
-  virtual void start();
-  virtual void stop();
+namespace BLEServerEvt {
+enum EmptyEvt {
+  ON_CONNECT,
+  ON_DISCONNECT,
 };
+}  // namespace BLEServerEvt
 
-class BLEServer : public Component, public GATTsEventHandler, public BLEStatusEventHandler, public Parented<ESP32BLE> {
+class BLEServer : public Component,
+                  public GATTsEventHandler,
+                  public BLEStatusEventHandler,
+                  public Parented<ESP32BLE>,
+                  public EventEmitter<BLEServerEvt::EmptyEvt, uint16_t> {
  public:
   void setup() override;
   void loop() override;
@@ -44,47 +46,41 @@ class BLEServer : public Component, public GATTsEventHandler, public BLEStatusEv
   void teardown();
   bool is_running();
 
-  void set_manufacturer(const std::string &manufacturer) { this->manufacturer_ = manufacturer; }
-  void set_model(const std::string &model) { this->model_ = model; }
   void set_manufacturer_data(const std::vector<uint8_t> &data) {
     this->manufacturer_data_ = data;
     this->restart_advertising_();
   }
 
-  void create_service(ESPBTUUID uuid, bool advertise = false, uint16_t num_handles = 15, uint8_t inst_id = 0);
-  void remove_service(ESPBTUUID uuid);
-  BLEService *get_service(ESPBTUUID uuid);
+  BLEService *create_service(ESPBTUUID uuid, bool advertise = false, uint16_t num_handles = 15);
+  void remove_service(ESPBTUUID uuid, uint8_t inst_id = 0);
+  BLEService *get_service(ESPBTUUID uuid, uint8_t inst_id = 0);
+  void enqueue_start_service(BLEService *service) { this->services_to_start_.push_back(service); }
+  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->connected_clients_; }
-  const std::unordered_map<uint16_t, void *> &get_clients() { return this->clients_; }
+  uint32_t get_connected_client_count() { return this->clients_.size(); }
+  const std::unordered_set<uint16_t> &get_clients() { return this->clients_; }
 
   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;
 
-  void register_service_component(BLEServiceComponent *component) { this->service_components_.push_back(component); }
-
  protected:
-  bool create_device_characteristics_();
+  static std::string get_service_key(ESPBTUUID uuid, uint8_t inst_id);
   void restart_advertising_();
 
-  void add_client_(uint16_t conn_id, void *client) { this->clients_.emplace(conn_id, client); }
-  bool remove_client_(uint16_t conn_id) { return this->clients_.erase(conn_id) > 0; }
+  void add_client_(uint16_t conn_id) { this->clients_.insert(conn_id); }
+  void remove_client_(uint16_t conn_id) { this->clients_.erase(conn_id); }
 
-  std::string manufacturer_;
-  optional<std::string> model_;
-  std::vector<uint8_t> manufacturer_data_;
+  std::vector<uint8_t> manufacturer_data_{};
   esp_gatt_if_t gatts_if_{0};
   bool registered_{false};
 
-  uint32_t connected_clients_{0};
-  std::unordered_map<uint16_t, void *> clients_;
-  std::unordered_map<std::string, BLEService *> services_;
-  BLEService *device_information_service_;
-
-  std::vector<BLEServiceComponent *> service_components_;
+  std::unordered_set<uint16_t> clients_;
+  std::unordered_map<std::string, BLEService *> services_{};
+  std::vector<BLEService *> services_to_start_{};
+  BLEService *device_information_service_{};
 
   enum State : uint8_t {
     INIT = 0x00,