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

esphome/components/esp32_ble_server/ble_server_automations.cpp

@@ -0,0 +1,77 @@
+#include "ble_server_automations.h"
+
+#ifdef USE_ESP32
+
+namespace esphome {
+namespace esp32_ble_server {
+// Interface to interact with ESPHome automations and triggers
+namespace esp32_ble_server_automations {
+
+using namespace esp32_ble;
+
+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); });
+  return on_write_trigger;
+}
+
+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); });
+  return on_write_trigger;
+}
+
+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); });
+  return on_connect_trigger;
+}
+
+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); });
+  return on_disconnect_trigger;
+}
+
+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);
+  }
+  // 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);
+}
+
+}  // namespace esp32_ble_server_automations
+}  // namespace esp32_ble_server
+}  // namespace esphome
+
+#endif

esphome/components/esp32_ble_server/ble_server_automations.h

@@ -0,0 +1,115 @@
+#pragma once
+
+#include "ble_server.h"
+#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
+
+namespace esphome {
+namespace esp32_ble_server {
+// Interface to interact with ESPHome actions and triggers
+namespace esp32_ble_server_automations {
+
+using namespace esp32_ble;
+using namespace event_emitter;
+
+class BLETriggers {
+ public:
+  static Trigger<std::vector<uint8_t>, uint16_t> *create_characteristic_on_write_trigger(
+      BLECharacteristic *characteristic);
+  static Trigger<std::vector<uint8_t>, uint16_t> *create_descriptor_on_write_trigger(BLEDescriptor *descriptor);
+  static Trigger<uint16_t> *create_server_on_connect_trigger(BLEServer *server);
+  static Trigger<uint16_t> *create_server_on_disconnect_trigger(BLEServer *server);
+};
+
+enum BLECharacteristicSetValueActionEvt {
+  PRE_NOTIFY,
+};
+
+// Class to make sure only one BLECharacteristicSetValueAction is active at a time for each characteristic
+class BLECharacteristicSetValueActionManager
+    : public EventEmitter<BLECharacteristicSetValueActionEvt, BLECharacteristic *> {
+ 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 emit_pre_notify(BLECharacteristic *characteristic) {
+    this->emit_(BLECharacteristicSetValueActionEvt::PRE_NOTIFY, characteristic);
+  }
+
+ private:
+  std::unordered_map<BLECharacteristic *, std::pair<EventEmitterListenerID, EventEmitterListenerID>> listeners_;
+};
+
+template<typename... Ts> class BLECharacteristicSetValueAction : public Action<Ts...> {
+ public:
+  BLECharacteristicSetValueAction(BLECharacteristic *characteristic) : parent_(characteristic) {}
+  TEMPLATABLE_VALUE(std::vector<uint8_t>, buffer)
+  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_)
+      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...));
+        });
+    // 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...)); });
+  }
+
+ protected:
+  BLECharacteristic *parent_;
+  EventEmitterListenerID listener_id_;
+};
+
+template<typename... Ts> class BLECharacteristicNotifyAction : public Action<Ts...> {
+ public:
+  BLECharacteristicNotifyAction(BLECharacteristic *characteristic) : parent_(characteristic) {}
+  void play(Ts... x) override {
+    // Call the pre-notify event
+    BLECharacteristicSetValueActionManager::get_instance()->emit_pre_notify(this->parent_);
+    // Notify the characteristic
+    this->parent_->notify();
+  }
+
+ protected:
+  BLECharacteristic *parent_;
+};
+
+template<typename... Ts> class BLEDescriptorSetValueAction : public Action<Ts...> {
+ public:
+  BLEDescriptorSetValueAction(BLEDescriptor *descriptor) : parent_(descriptor) {}
+  TEMPLATABLE_VALUE(std::vector<uint8_t>, buffer)
+  void set_buffer(ByteBuffer buffer) { this->set_buffer(buffer.get_data()); }
+  void play(Ts... x) override { this->parent_->set_value(this->buffer_.value(x...)); }
+
+ protected:
+  BLEDescriptor *parent_;
+};
+
+}  // namespace esp32_ble_server_automations
+}  // namespace esp32_ble_server
+}  // namespace esphome
+
+#endif

esphome/components/esp32_ble_server/ble_service.cpp

@@ -52,18 +52,21 @@ void BLEService::do_create(BLEServer *server) {
   esp_err_t err = esp_ble_gatts_create_service(server->get_gatts_if(), &srvc_id, this->num_handles_);
   if (err != ESP_OK) {
     ESP_LOGE(TAG, "esp_ble_gatts_create_service failed: %d", err);
-    this->init_state_ = FAILED;
+    this->state_ = FAILED;
     return;
   }
-  this->init_state_ = CREATING;
+  this->state_ = CREATING;
 }
 
 void BLEService::do_delete() {
-  if (this->init_state_ == DELETING || this->init_state_ == DELETED)
+  if (this->state_ == DELETING || this->state_ == DELETED)
     return;
-  this->init_state_ = DELETING;
+  this->state_ = DELETING;
   this->created_characteristic_count_ = 0;
   this->last_created_characteristic_ = nullptr;
+  // Call all characteristics to delete
+  for (auto *characteristic : this->characteristics_)
+    characteristic->do_delete();
   this->stop_();
   esp_err_t err = esp_ble_gatts_delete_service(this->handle_);
   if (err != ESP_OK) {
@@ -91,6 +94,7 @@ void BLEService::start() {
     return;
   should_start_ = true;
 
+  this->state_ = STARTING;
   esp_err_t err = esp_ble_gatts_start_service(this->handle_);
   if (err != ESP_OK) {
     ESP_LOGE(TAG, "esp_ble_gatts_start_service failed: %d", err);
@@ -98,7 +102,6 @@ void BLEService::start() {
   }
   if (this->advertise_)
     esp32_ble::global_ble->advertising_add_service_uuid(this->uuid_);
-  this->running_state_ = STARTING;
 }
 
 void BLEService::stop() {
@@ -107,9 +110,9 @@ void BLEService::stop() {
 }
 
 void BLEService::stop_() {
-  if (this->running_state_ == STOPPING || this->running_state_ == STOPPED)
+  if (this->state_ == STOPPING || this->state_ == STOPPED)
     return;
-  this->running_state_ = STOPPING;
+  this->state_ = STOPPING;
   esp_err_t err = esp_ble_gatts_stop_service(this->handle_);
   if (err != ESP_OK) {
     ESP_LOGE(TAG, "esp_ble_gatts_stop_service failed: %d", err);
@@ -119,17 +122,16 @@ void BLEService::stop_() {
     esp32_ble::global_ble->advertising_remove_service_uuid(this->uuid_);
 }
 
-bool BLEService::is_created() { return this->init_state_ == CREATED; }
 bool BLEService::is_failed() {
-  if (this->init_state_ == FAILED)
+  if (this->state_ == FAILED)
     return true;
   bool failed = false;
   for (auto *characteristic : this->characteristics_)
     failed |= characteristic->is_failed();
 
   if (failed)
-    this->init_state_ = FAILED;
-  return this->init_state_ == FAILED;
+    this->state_ = FAILED;
+  return this->state_ == FAILED;
 }
 
 void BLEService::gatts_event_handler(esp_gatts_cb_event_t event, esp_gatt_if_t gatts_if,
@@ -139,7 +141,7 @@ void BLEService::gatts_event_handler(esp_gatts_cb_event_t event, esp_gatt_if_t g
       if (this->uuid_ == ESPBTUUID::from_uuid(param->create.service_id.id.uuid) &&
           this->inst_id_ == param->create.service_id.id.inst_id) {
         this->handle_ = param->create.service_handle;
-        this->init_state_ = CREATED;
+        this->state_ = CREATED;
         if (this->should_start_)
           this->start();
       }
@@ -147,18 +149,18 @@ void BLEService::gatts_event_handler(esp_gatts_cb_event_t event, esp_gatt_if_t g
     }
     case ESP_GATTS_DELETE_EVT:
       if (param->del.service_handle == this->handle_) {
-        this->init_state_ = DELETED;
+        this->state_ = DELETED;
       }
       break;
     case ESP_GATTS_START_EVT: {
       if (param->start.service_handle == this->handle_) {
-        this->running_state_ = RUNNING;
+        this->state_ = RUNNING;
       }
       break;
     }
     case ESP_GATTS_STOP_EVT: {
       if (param->start.service_handle == this->handle_) {
-        this->running_state_ = STOPPED;
+        this->state_ = STOPPED;
       }
       break;
     }

esphome/components/esp32_ble_server/ble_service.h

@@ -32,6 +32,7 @@ class BLEService {
   BLECharacteristic *create_characteristic(ESPBTUUID uuid, esp_gatt_char_prop_t properties);
 
   ESPBTUUID get_uuid() { return this->uuid_; }
+  uint8_t get_inst_id() { return this->inst_id_; }
   BLECharacteristic *get_last_created_characteristic() { return this->last_created_characteristic_; }
   uint16_t get_handle() { return this->handle_; }
 
@@ -44,18 +45,17 @@ class BLEService {
   void start();
   void stop();
 
-  bool is_created();
   bool is_failed();
-
-  bool is_running() { return this->running_state_ == RUNNING; }
-  bool is_starting() { return this->running_state_ == STARTING; }
-  bool is_deleted() { return this->init_state_ == DELETED; }
+  bool is_created() { return this->state_ == CREATED; }
+  bool is_running() { return this->state_ == RUNNING; }
+  bool is_starting() { return this->state_ == STARTING; }
+  bool is_deleted() { return this->state_ == DELETED; }
 
  protected:
   std::vector<BLECharacteristic *> characteristics_;
   BLECharacteristic *last_created_characteristic_{nullptr};
   uint32_t created_characteristic_count_{0};
-  BLEServer *server_;
+  BLEServer *server_ = nullptr;
   ESPBTUUID uuid_;
   uint16_t num_handles_;
   uint16_t handle_{0xFFFF};
@@ -66,22 +66,18 @@ class BLEService {
   bool do_create_characteristics_();
   void stop_();
 
-  enum InitState : uint8_t {
+  enum State : uint8_t {
     FAILED = 0x00,
     INIT,
     CREATING,
-    CREATING_DEPENDENTS,
     CREATED,
-    DELETING,
-    DELETED,
-  } init_state_{INIT};
-
-  enum RunningState : uint8_t {
     STARTING,
     RUNNING,
     STOPPING,
     STOPPED,
-  } running_state_{STOPPED};
+    DELETING,
+    DELETED,
+  } state_{INIT};
 };
 
 }  // namespace esp32_ble_server

esphome/components/esp32_ble_tracker/__init__.py

@@ -1,9 +1,13 @@
-import re
-
 from esphome import automation
 import esphome.codegen as cg
 from esphome.components import esp32_ble
 from esphome.components.esp32 import add_idf_sdkconfig_option
+from esphome.components.esp32_ble import (
+    bt_uuid,
+    bt_uuid16_format,
+    bt_uuid32_format,
+    bt_uuid128_format,
+)
 import esphome.config_validation as cv
 from esphome.const import (
     CONF_ACTIVE,
@@ -86,43 +90,6 @@ def validate_scan_parameters(config):
     return config
 
 
-bt_uuid16_format = "XXXX"
-bt_uuid32_format = "XXXXXXXX"
-bt_uuid128_format = "XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX"
-
-
-def bt_uuid(value):
-    in_value = cv.string_strict(value)
-    value = in_value.upper()
-
-    if len(value) == len(bt_uuid16_format):
-        pattern = re.compile("^[A-F|0-9]{4,}$")
-        if not pattern.match(value):
-            raise cv.Invalid(
-                f"Invalid hexadecimal value for 16 bit UUID format: '{in_value}'"
-            )
-        return value
-    if len(value) == len(bt_uuid32_format):
-        pattern = re.compile("^[A-F|0-9]{8,}$")
-        if not pattern.match(value):
-            raise cv.Invalid(
-                f"Invalid hexadecimal value for 32 bit UUID format: '{in_value}'"
-            )
-        return value
-    if len(value) == len(bt_uuid128_format):
-        pattern = re.compile(
-            "^[A-F|0-9]{8,}-[A-F|0-9]{4,}-[A-F|0-9]{4,}-[A-F|0-9]{4,}-[A-F|0-9]{12,}$"
-        )
-        if not pattern.match(value):
-            raise cv.Invalid(
-                f"Invalid hexadecimal value for 128 UUID format: '{in_value}'"
-            )
-        return value
-    raise cv.Invalid(
-        f"Service UUID must be in 16 bit '{bt_uuid16_format}', 32 bit '{bt_uuid32_format}', or 128 bit '{bt_uuid128_format}' format"
-    )
-
-
 def as_hex(value):
     return cg.RawExpression(f"0x{value}ULL")
 

esphome/components/esp32_ble_tracker/esp32_ble_tracker.cpp

@@ -58,7 +58,6 @@ void ESP32BLETracker::setup() {
   global_esp32_ble_tracker = this;
   this->scan_result_lock_ = xSemaphoreCreateMutex();
   this->scan_end_lock_ = xSemaphoreCreateMutex();
-  this->scanner_idle_ = true;
 
 #ifdef USE_OTA
   ota::get_global_ota_callback()->add_on_state_callback(
@@ -107,6 +106,15 @@ void ESP32BLETracker::loop() {
         break;
     }
   }
+  if (connecting != connecting_ || discovered != discovered_ || searching != searching_ ||
+      disconnecting != disconnecting_) {
+    connecting_ = connecting;
+    discovered_ = discovered;
+    searching_ = searching;
+    disconnecting_ = disconnecting;
+    ESP_LOGD(TAG, "connecting: %d, discovered: %d, searching: %d, disconnecting: %d", connecting_, discovered_,
+             searching_, disconnecting_);
+  }
   bool promote_to_connecting = discovered && !searching && !connecting;
 
   if (!this->scanner_idle_) {
@@ -183,8 +191,9 @@ void ESP32BLETracker::loop() {
     }
 
     if (this->scan_start_failed_ || this->scan_set_param_failed_) {
-      if (this->scan_start_fail_count_ == 255) {
-        ESP_LOGE(TAG, "ESP-IDF BLE scan could not restart after 255 attempts, rebooting to restore BLE stack...");
+      if (this->scan_start_fail_count_ == std::numeric_limits<uint8_t>::max()) {
+        ESP_LOGE(TAG, "ESP-IDF BLE scan could not restart after %d attempts, rebooting to restore BLE stack...",
+                 std::numeric_limits<uint8_t>::max());
         App.reboot();
       }
       if (xSemaphoreTake(this->scan_end_lock_, 0L)) {
@@ -282,6 +291,12 @@ void ESP32BLETracker::start_scan_(bool first) {
   this->scan_params_.scan_interval = this->scan_interval_;
   this->scan_params_.scan_window = this->scan_window_;
 
+  // Start timeout before scan is started. Otherwise scan never starts if any error.
+  this->set_timeout("scan", this->scan_duration_ * 2000, []() {
+    ESP_LOGE(TAG, "ESP-IDF BLE scan never terminated, rebooting to restore BLE stack...");
+    App.reboot();
+  });
+
   esp_err_t err = esp_ble_gap_set_scan_params(&this->scan_params_);
   if (err != ESP_OK) {
     ESP_LOGE(TAG, "esp_ble_gap_set_scan_params failed: %d", err);
@@ -293,11 +308,6 @@ void ESP32BLETracker::start_scan_(bool first) {
     return;
   }
   this->scanner_idle_ = false;
-
-  this->set_timeout("scan", this->scan_duration_ * 2000, []() {
-    ESP_LOGE(TAG, "ESP-IDF BLE scan never terminated, rebooting to restore BLE stack...");
-    App.reboot();
-  });
 }
 
 void ESP32BLETracker::end_of_scan_() {
@@ -371,6 +381,7 @@ void ESP32BLETracker::gap_event_handler(esp_gap_ble_cb_event_t event, esp_ble_ga
 }
 
 void ESP32BLETracker::gap_scan_set_param_complete_(const esp_ble_gap_cb_param_t::ble_scan_param_cmpl_evt_param &param) {
+  ESP_LOGV(TAG, "gap_scan_set_param_complete - status %d", param.status);
   if (param.status == ESP_BT_STATUS_DONE) {
     this->scan_set_param_failed_ = ESP_BT_STATUS_SUCCESS;
   } else {
@@ -379,20 +390,25 @@ void ESP32BLETracker::gap_scan_set_param_complete_(const esp_ble_gap_cb_param_t:
 }
 
 void ESP32BLETracker::gap_scan_start_complete_(const esp_ble_gap_cb_param_t::ble_scan_start_cmpl_evt_param &param) {
+  ESP_LOGV(TAG, "gap_scan_start_complete - status %d", param.status);
   this->scan_start_failed_ = param.status;
   if (param.status == ESP_BT_STATUS_SUCCESS) {
     this->scan_start_fail_count_ = 0;
   } else {
-    this->scan_start_fail_count_++;
+    if (this->scan_start_fail_count_ != std::numeric_limits<uint8_t>::max()) {
+      this->scan_start_fail_count_++;
+    }
     xSemaphoreGive(this->scan_end_lock_);
   }
 }
 
 void ESP32BLETracker::gap_scan_stop_complete_(const esp_ble_gap_cb_param_t::ble_scan_stop_cmpl_evt_param &param) {
+  ESP_LOGV(TAG, "gap_scan_stop_complete - status %d", param.status);
   xSemaphoreGive(this->scan_end_lock_);
 }
 
 void ESP32BLETracker::gap_scan_result_(const esp_ble_gap_cb_param_t::ble_scan_result_evt_param &param) {
+  ESP_LOGV(TAG, "gap_scan_result - event %d", param.search_evt);
   if (param.search_evt == ESP_GAP_SEARCH_INQ_RES_EVT) {
     if (xSemaphoreTake(this->scan_result_lock_, 0L)) {
       if (this->scan_result_index_ < ESP32BLETracker::SCAN_RESULT_BUFFER_SIZE) {
@@ -663,7 +679,14 @@ void ESP32BLETracker::dump_config() {
   ESP_LOGCONFIG(TAG, "  Scan Interval: %.1f ms", this->scan_interval_ * 0.625f);
   ESP_LOGCONFIG(TAG, "  Scan Window: %.1f ms", this->scan_window_ * 0.625f);
   ESP_LOGCONFIG(TAG, "  Scan Type: %s", this->scan_active_ ? "ACTIVE" : "PASSIVE");
-  ESP_LOGCONFIG(TAG, "  Continuous Scanning: %s", this->scan_continuous_ ? "True" : "False");
+  ESP_LOGCONFIG(TAG, "  Continuous Scanning: %s", YESNO(this->scan_continuous_));
+  ESP_LOGCONFIG(TAG, "  Scanner Idle: %s", YESNO(this->scanner_idle_));
+  ESP_LOGCONFIG(TAG, "  Scan End: %s", YESNO(xSemaphoreGetMutexHolder(this->scan_end_lock_) == nullptr));
+  ESP_LOGCONFIG(TAG, "  Connecting: %d, discovered: %d, searching: %d, disconnecting: %d", connecting_, discovered_,
+                searching_, disconnecting_);
+  if (this->scan_start_fail_count_) {
+    ESP_LOGCONFIG(TAG, "  Scan Start Fail Count: %d", this->scan_start_fail_count_);
+  }
 }
 
 void ESP32BLETracker::print_bt_device_info(const ESPBTDevice &device) {

esphome/components/esp32_ble_tracker/esp32_ble_tracker.h

@@ -178,7 +178,7 @@ class ESPBTClient : public ESPBTDeviceListener {
   int app_id;
 
  protected:
-  ClientState state_;
+  ClientState state_{ClientState::INIT};
 };
 
 class ESP32BLETracker : public Component,
@@ -229,7 +229,7 @@ class ESP32BLETracker : public Component,
   /// Called when a `ESP_GAP_BLE_SCAN_STOP_COMPLETE_EVT` event is received.
   void gap_scan_stop_complete_(const esp_ble_gap_cb_param_t::ble_scan_stop_cmpl_evt_param &param);
 
-  int app_id_;
+  int app_id_{0};
 
   /// Vector of addresses that have already been printed in print_bt_device_info
   std::vector<uint64_t> already_discovered_;
@@ -242,10 +242,10 @@ class ESP32BLETracker : public Component,
   uint32_t scan_duration_;
   uint32_t scan_interval_;
   uint32_t scan_window_;
-  uint8_t scan_start_fail_count_;
+  uint8_t scan_start_fail_count_{0};
   bool scan_continuous_;
   bool scan_active_;
-  bool scanner_idle_;
+  bool scanner_idle_{true};
   bool ble_was_disabled_{true};
   bool raw_advertisements_{false};
   bool parse_advertisements_{false};
@@ -260,6 +260,10 @@ class ESP32BLETracker : public Component,
   esp_ble_gap_cb_param_t::ble_scan_result_evt_param *scan_result_buffer_;
   esp_bt_status_t scan_start_failed_{ESP_BT_STATUS_SUCCESS};
   esp_bt_status_t scan_set_param_failed_{ESP_BT_STATUS_SUCCESS};
+  int connecting_{0};
+  int discovered_{0};
+  int searching_{0};
+  int disconnecting_{0};
 };
 
 // NOLINTNEXTLINE

esphome/components/esp32_improv/__init__.py

@@ -1,6 +1,6 @@
 from esphome import automation
 import esphome.codegen as cg
-from esphome.components import binary_sensor, esp32_ble_server, output
+from esphome.components import binary_sensor, output
 import esphome.config_validation as cv
 from esphome.const import CONF_ID, CONF_ON_STATE, CONF_TRIGGER_ID
 
@@ -24,9 +24,7 @@ Error = improv_ns.enum("Error")
 State = improv_ns.enum("State")
 
 esp32_improv_ns = cg.esphome_ns.namespace("esp32_improv")
-ESP32ImprovComponent = esp32_improv_ns.class_(
-    "ESP32ImprovComponent", cg.Component, esp32_ble_server.BLEServiceComponent
-)
+ESP32ImprovComponent = esp32_improv_ns.class_("ESP32ImprovComponent", cg.Component)
 ESP32ImprovProvisionedTrigger = esp32_improv_ns.class_(
     "ESP32ImprovProvisionedTrigger", automation.Trigger.template()
 )
@@ -47,7 +45,6 @@ ESP32ImprovStoppedTrigger = esp32_improv_ns.class_(
 CONFIG_SCHEMA = cv.Schema(
     {
         cv.GenerateID(): cv.declare_id(ESP32ImprovComponent),
-        cv.GenerateID(CONF_BLE_SERVER_ID): cv.use_id(esp32_ble_server.BLEServer),
         cv.Required(CONF_AUTHORIZER): cv.Any(
             cv.none, cv.use_id(binary_sensor.BinarySensor)
         ),
@@ -100,9 +97,6 @@ async def to_code(config):
     var = cg.new_Pvariable(config[CONF_ID])
     await cg.register_component(var, config)
 
-    ble_server = await cg.get_variable(config[CONF_BLE_SERVER_ID])
-    cg.add(ble_server.register_service_component(var))
-
     cg.add_define("USE_IMPROV")
     cg.add_library("improv/Improv", "1.2.4")