Bluetooth Proxy: Raw bundled advertisements (#4924)

esphome/components/bluetooth_proxy/bluetooth_connection.cpp

@@ -1,6 +1,6 @@
 #include "bluetooth_connection.h"
 
-#include "esphome/components/api/api_server.h"
+#include "esphome/components/api/api_pb2.h"
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
 
@@ -20,24 +20,21 @@ bool BluetoothConnection::gattc_event_handler(esp_gattc_cb_event_t event, esp_ga
 
   switch (event) {
     case ESP_GATTC_DISCONNECT_EVT: {
-      api::global_api_server->send_bluetooth_device_connection(this->address_, false, 0, param->disconnect.reason);
+      this->proxy_->send_device_connection(this->address_, false, 0, param->disconnect.reason);
       this->set_address(0);
-      api::global_api_server->send_bluetooth_connections_free(this->proxy_->get_bluetooth_connections_free(),
-                                                              this->proxy_->get_bluetooth_connections_limit());
+      this->proxy_->send_connections_free();
       break;
     }
     case ESP_GATTC_OPEN_EVT: {
       if (param->open.conn_id != this->conn_id_)
         break;
       if (param->open.status != ESP_GATT_OK && param->open.status != ESP_GATT_ALREADY_OPEN) {
-        api::global_api_server->send_bluetooth_device_connection(this->address_, false, 0, param->open.status);
+        this->proxy_->send_device_connection(this->address_, false, 0, param->open.status);
         this->set_address(0);
-        api::global_api_server->send_bluetooth_connections_free(this->proxy_->get_bluetooth_connections_free(),
-                                                                this->proxy_->get_bluetooth_connections_limit());
+        this->proxy_->send_connections_free();
       } else if (this->connection_type_ == espbt::ConnectionType::V3_WITH_CACHE) {
-        api::global_api_server->send_bluetooth_device_connection(this->address_, true, this->mtu_);
-        api::global_api_server->send_bluetooth_connections_free(this->proxy_->get_bluetooth_connections_free(),
-                                                                this->proxy_->get_bluetooth_connections_limit());
+        this->proxy_->send_device_connection(this->address_, true, this->mtu_);
+        this->proxy_->send_connections_free();
       }
       this->seen_mtu_or_services_ = false;
       break;
@@ -52,9 +49,8 @@ bool BluetoothConnection::gattc_event_handler(esp_gattc_cb_event_t event, esp_ga
         this->seen_mtu_or_services_ = true;
         break;
       }
-      api::global_api_server->send_bluetooth_device_connection(this->address_, true, this->mtu_);
-      api::global_api_server->send_bluetooth_connections_free(this->proxy_->get_bluetooth_connections_free(),
-                                                              this->proxy_->get_bluetooth_connections_limit());
+      this->proxy_->send_device_connection(this->address_, true, this->mtu_);
+      this->proxy_->send_connections_free();
       break;
     }
     case ESP_GATTC_SEARCH_CMPL_EVT: {
@@ -67,9 +63,8 @@ bool BluetoothConnection::gattc_event_handler(esp_gattc_cb_event_t event, esp_ga
         this->seen_mtu_or_services_ = true;
         break;
       }
-      api::global_api_server->send_bluetooth_device_connection(this->address_, true, this->mtu_);
-      api::global_api_server->send_bluetooth_connections_free(this->proxy_->get_bluetooth_connections_free(),
-                                                              this->proxy_->get_bluetooth_connections_limit());
+      this->proxy_->send_device_connection(this->address_, true, this->mtu_);
+      this->proxy_->send_connections_free();
       break;
     }
     case ESP_GATTC_READ_DESCR_EVT:
@@ -79,7 +74,7 @@ bool BluetoothConnection::gattc_event_handler(esp_gattc_cb_event_t event, esp_ga
       if (param->read.status != ESP_GATT_OK) {
         ESP_LOGW(TAG, "[%d] [%s] Error reading char/descriptor at handle 0x%2X, status=%d", this->connection_index_,
                  this->address_str_.c_str(), param->read.handle, param->read.status);
-        api::global_api_server->send_bluetooth_gatt_error(this->address_, param->read.handle, param->read.status);
+        this->proxy_->send_gatt_error(this->address_, param->read.handle, param->read.status);
         break;
       }
       api::BluetoothGATTReadResponse resp;
@@ -89,7 +84,7 @@ bool BluetoothConnection::gattc_event_handler(esp_gattc_cb_event_t event, esp_ga
       for (uint16_t i = 0; i < param->read.value_len; i++) {
         resp.data.push_back(param->read.value[i]);
       }
-      api::global_api_server->send_bluetooth_gatt_read_response(resp);
+      this->proxy_->get_api_connection()->send_bluetooth_gatt_read_response(resp);
       break;
     }
     case ESP_GATTC_WRITE_CHAR_EVT:
@@ -99,13 +94,13 @@ bool BluetoothConnection::gattc_event_handler(esp_gattc_cb_event_t event, esp_ga
       if (param->write.status != ESP_GATT_OK) {
         ESP_LOGW(TAG, "[%d] [%s] Error writing char/descriptor at handle 0x%2X, status=%d", this->connection_index_,
                  this->address_str_.c_str(), param->write.handle, param->write.status);
-        api::global_api_server->send_bluetooth_gatt_error(this->address_, param->write.handle, param->write.status);
+        this->proxy_->send_gatt_error(this->address_, param->write.handle, param->write.status);
         break;
       }
       api::BluetoothGATTWriteResponse resp;
       resp.address = this->address_;
       resp.handle = param->write.handle;
-      api::global_api_server->send_bluetooth_gatt_write_response(resp);
+      this->proxy_->get_api_connection()->send_bluetooth_gatt_write_response(resp);
       break;
     }
     case ESP_GATTC_UNREG_FOR_NOTIFY_EVT: {
@@ -113,28 +108,26 @@ bool BluetoothConnection::gattc_event_handler(esp_gattc_cb_event_t event, esp_ga
         ESP_LOGW(TAG, "[%d] [%s] Error unregistering notifications for handle 0x%2X, status=%d",
                  this->connection_index_, this->address_str_.c_str(), param->unreg_for_notify.handle,
                  param->unreg_for_notify.status);
-        api::global_api_server->send_bluetooth_gatt_error(this->address_, param->unreg_for_notify.handle,
-                                                          param->unreg_for_notify.status);
+        this->proxy_->send_gatt_error(this->address_, param->unreg_for_notify.handle, param->unreg_for_notify.status);
         break;
       }
       api::BluetoothGATTNotifyResponse resp;
       resp.address = this->address_;
       resp.handle = param->unreg_for_notify.handle;
-      api::global_api_server->send_bluetooth_gatt_notify_response(resp);
+      this->proxy_->get_api_connection()->send_bluetooth_gatt_notify_response(resp);
       break;
     }
     case ESP_GATTC_REG_FOR_NOTIFY_EVT: {
       if (param->reg_for_notify.status != ESP_GATT_OK) {
         ESP_LOGW(TAG, "[%d] [%s] Error registering notifications for handle 0x%2X, status=%d", this->connection_index_,
                  this->address_str_.c_str(), param->reg_for_notify.handle, param->reg_for_notify.status);
-        api::global_api_server->send_bluetooth_gatt_error(this->address_, param->reg_for_notify.handle,
-                                                          param->reg_for_notify.status);
+        this->proxy_->send_gatt_error(this->address_, param->reg_for_notify.handle, param->reg_for_notify.status);
         break;
       }
       api::BluetoothGATTNotifyResponse resp;
       resp.address = this->address_;
       resp.handle = param->reg_for_notify.handle;
-      api::global_api_server->send_bluetooth_gatt_notify_response(resp);
+      this->proxy_->get_api_connection()->send_bluetooth_gatt_notify_response(resp);
       break;
     }
     case ESP_GATTC_NOTIFY_EVT: {
@@ -149,7 +142,7 @@ bool BluetoothConnection::gattc_event_handler(esp_gattc_cb_event_t event, esp_ga
       for (uint16_t i = 0; i < param->notify.value_len; i++) {
         resp.data.push_back(param->notify.value[i]);
       }
-      api::global_api_server->send_bluetooth_gatt_notify_data_response(resp);
+      this->proxy_->get_api_connection()->send_bluetooth_gatt_notify_data_response(resp);
       break;
     }
     default:
@@ -166,10 +159,9 @@ void BluetoothConnection::gap_event_handler(esp_gap_ble_cb_event_t event, esp_bl
       if (memcmp(param->ble_security.auth_cmpl.bd_addr, this->remote_bda_, 6) != 0)
         break;
       if (param->ble_security.auth_cmpl.success) {
-        api::global_api_server->send_bluetooth_device_pairing(this->address_, true);
+        this->proxy_->send_device_pairing(this->address_, true);
       } else {
-        api::global_api_server->send_bluetooth_device_pairing(this->address_, false,
-                                                              param->ble_security.auth_cmpl.fail_reason);
+        this->proxy_->send_device_pairing(this->address_, false, param->ble_security.auth_cmpl.fail_reason);
       }
       break;
     default:

esphome/components/bluetooth_proxy/bluetooth_proxy.cpp

@@ -1,11 +1,10 @@
 #include "bluetooth_proxy.h"
 
 #include "esphome/core/log.h"
+#include "esphome/core/macros.h"
 
 #ifdef USE_ESP32
 
-#include "esphome/components/api/api_server.h"
-
 namespace esphome {
 namespace bluetooth_proxy {
 
@@ -27,15 +26,39 @@ std::vector<uint64_t> get_128bit_uuid_vec(esp_bt_uuid_t uuid_source) {
 BluetoothProxy::BluetoothProxy() { global_bluetooth_proxy = this; }
 
 bool BluetoothProxy::parse_device(const esp32_ble_tracker::ESPBTDevice &device) {
-  if (!api::global_api_server->is_connected())
+  if (!api::global_api_server->is_connected() || this->api_connection_ == nullptr || this->raw_advertisements_)
     return false;
+
   ESP_LOGV(TAG, "Proxying packet from %s - %s. RSSI: %d dB", device.get_name().c_str(), device.address_str().c_str(),
            device.get_rssi());
   this->send_api_packet_(device);
-
   return true;
 }
 
+bool BluetoothProxy::parse_devices(esp_ble_gap_cb_param_t::ble_scan_result_evt_param *advertisements, size_t count) {
+  if (!api::global_api_server->is_connected() || this->api_connection_ == nullptr || !this->raw_advertisements_)
+    return false;
+
+  api::BluetoothLERawAdvertisementsResponse resp;
+  for (size_t i = 0; i < count; i++) {
+    auto &result = advertisements[i];
+    api::BluetoothLERawAdvertisement adv;
+    adv.address = esp32_ble::ble_addr_to_uint64(result.bda);
+    adv.rssi = result.rssi;
+    adv.address_type = result.ble_addr_type;
+
+    uint8_t length = result.adv_data_len + result.scan_rsp_len;
+    adv.data.reserve(length);
+    for (uint16_t i = 0; i < length; i++) {
+      adv.data.push_back(result.ble_adv[i]);
+    }
+
+    resp.advertisements.push_back(std::move(adv));
+  }
+  ESP_LOGV(TAG, "Proxying %d packets", count);
+  this->api_connection_->send_bluetooth_le_raw_advertisements_response(resp);
+  return true;
+}
 void BluetoothProxy::send_api_packet_(const esp32_ble_tracker::ESPBTDevice &device) {
   api::BluetoothLEAdvertisementResponse resp;
   resp.address = device.address_uint64();
@@ -58,7 +81,7 @@ void BluetoothProxy::send_api_packet_(const esp32_ble_tracker::ESPBTDevice &devi
     manufacturer_data.data.assign(data.data.begin(), data.data.end());
     resp.manufacturer_data.push_back(std::move(manufacturer_data));
   }
-  api::global_api_server->send_bluetooth_le_advertisement(resp);
+  this->api_connection_->send_bluetooth_le_advertisement(resp);
 }
 
 void BluetoothProxy::dump_config() {
@@ -81,7 +104,7 @@ int BluetoothProxy::get_bluetooth_connections_free() {
 }
 
 void BluetoothProxy::loop() {
-  if (!api::global_api_server->is_connected()) {
+  if (!api::global_api_server->is_connected() || this->api_connection_ == nullptr) {
     for (auto *connection : this->connections_) {
       if (connection->get_address() != 0) {
         connection->disconnect();
@@ -92,7 +115,7 @@ void BluetoothProxy::loop() {
   for (auto *connection : this->connections_) {
     if (connection->send_service_ == connection->service_count_) {
       connection->send_service_ = DONE_SENDING_SERVICES;
-      api::global_api_server->send_bluetooth_gatt_services_done(connection->get_address());
+      this->send_gatt_services_done(connection->get_address());
       if (connection->connection_type_ == espbt::ConnectionType::V3_WITH_CACHE ||
           connection->connection_type_ == espbt::ConnectionType::V3_WITHOUT_CACHE) {
         connection->release_services();
@@ -170,7 +193,7 @@ void BluetoothProxy::loop() {
         service_resp.characteristics.push_back(std::move(characteristic_resp));
       }
       resp.services.push_back(std::move(service_resp));
-      api::global_api_server->send_bluetooth_gatt_services(resp);
+      this->api_connection_->send_bluetooth_gatt_get_services_response(resp);
     }
   }
 }
@@ -208,16 +231,15 @@ void BluetoothProxy::bluetooth_device_request(const api::BluetoothDeviceRequest
       auto *connection = this->get_connection_(msg.address, true);
       if (connection == nullptr) {
         ESP_LOGW(TAG, "No free connections available");
-        api::global_api_server->send_bluetooth_device_connection(msg.address, false);
+        this->send_device_connection(msg.address, false);
         return;
       }
       if (connection->state() == espbt::ClientState::CONNECTED ||
           connection->state() == espbt::ClientState::ESTABLISHED) {
         ESP_LOGW(TAG, "[%d] [%s] Connection already established", connection->get_connection_index(),
                  connection->address_str().c_str());
-        api::global_api_server->send_bluetooth_device_connection(msg.address, true);
-        api::global_api_server->send_bluetooth_connections_free(this->get_bluetooth_connections_free(),
-                                                                this->get_bluetooth_connections_limit());
+        this->send_device_connection(msg.address, true);
+        this->send_connections_free();
         return;
       } else if (connection->state() == espbt::ClientState::SEARCHING) {
         ESP_LOGW(TAG, "[%d] [%s] Connection request ignored, already searching for device",
@@ -263,25 +285,22 @@ void BluetoothProxy::bluetooth_device_request(const api::BluetoothDeviceRequest
       } else {
         connection->set_state(espbt::ClientState::SEARCHING);
       }
-      api::global_api_server->send_bluetooth_connections_free(this->get_bluetooth_connections_free(),
-                                                              this->get_bluetooth_connections_limit());
+      this->send_connections_free();
       break;
     }
     case api::enums::BLUETOOTH_DEVICE_REQUEST_TYPE_DISCONNECT: {
       auto *connection = this->get_connection_(msg.address, false);
       if (connection == nullptr) {
-        api::global_api_server->send_bluetooth_device_connection(msg.address, false);
-        api::global_api_server->send_bluetooth_connections_free(this->get_bluetooth_connections_free(),
-                                                                this->get_bluetooth_connections_limit());
+        this->send_device_connection(msg.address, false);
+        this->send_connections_free();
         return;
       }
       if (connection->state() != espbt::ClientState::IDLE) {
         connection->disconnect();
       } else {
         connection->set_address(0);
-        api::global_api_server->send_bluetooth_device_connection(msg.address, false);
-        api::global_api_server->send_bluetooth_connections_free(this->get_bluetooth_connections_free(),
-                                                                this->get_bluetooth_connections_limit());
+        this->send_device_connection(msg.address, false);
+        this->send_connections_free();
       }
       break;
     }
@@ -291,10 +310,10 @@ void BluetoothProxy::bluetooth_device_request(const api::BluetoothDeviceRequest
         if (!connection->is_paired()) {
           auto err = connection->pair();
           if (err != ESP_OK) {
-            api::global_api_server->send_bluetooth_device_pairing(msg.address, false, err);
+            this->send_device_pairing(msg.address, false, err);
           }
         } else {
-          api::global_api_server->send_bluetooth_device_pairing(msg.address, true);
+          this->send_device_pairing(msg.address, true);
         }
       }
       break;
@@ -303,14 +322,20 @@ void BluetoothProxy::bluetooth_device_request(const api::BluetoothDeviceRequest
       esp_bd_addr_t address;
       uint64_to_bd_addr(msg.address, address);
       esp_err_t ret = esp_ble_remove_bond_device(address);
-      api::global_api_server->send_bluetooth_device_unpairing(msg.address, ret == ESP_OK, ret);
+      this->send_device_pairing(msg.address, ret == ESP_OK, ret);
       break;
     }
     case api::enums::BLUETOOTH_DEVICE_REQUEST_TYPE_CLEAR_CACHE: {
       esp_bd_addr_t address;
       uint64_to_bd_addr(msg.address, address);
       esp_err_t ret = esp_ble_gattc_cache_clean(address);
-      api::global_api_server->send_bluetooth_device_clear_cache(msg.address, ret == ESP_OK, ret);
+      api::BluetoothDeviceClearCacheResponse call;
+      call.address = msg.address;
+      call.success = ret == ESP_OK;
+      call.error = ret;
+
+      this->api_connection_->send_bluetooth_device_clear_cache_response(call);
+
       break;
     }
   }
@@ -320,13 +345,13 @@ void BluetoothProxy::bluetooth_gatt_read(const api::BluetoothGATTReadRequest &ms
   auto *connection = this->get_connection_(msg.address, false);
   if (connection == nullptr) {
     ESP_LOGW(TAG, "Cannot read GATT characteristic, not connected");
-    api::global_api_server->send_bluetooth_gatt_error(msg.address, msg.handle, ESP_GATT_NOT_CONNECTED);
+    this->send_gatt_error(msg.address, msg.handle, ESP_GATT_NOT_CONNECTED);
     return;
   }
 
   auto err = connection->read_characteristic(msg.handle);
   if (err != ESP_OK) {
-    api::global_api_server->send_bluetooth_gatt_error(msg.address, msg.handle, err);
+    this->send_gatt_error(msg.address, msg.handle, err);
   }
 }
 
@@ -334,13 +359,13 @@ void BluetoothProxy::bluetooth_gatt_write(const api::BluetoothGATTWriteRequest &
   auto *connection = this->get_connection_(msg.address, false);
   if (connection == nullptr) {
     ESP_LOGW(TAG, "Cannot write GATT characteristic, not connected");
-    api::global_api_server->send_bluetooth_gatt_error(msg.address, msg.handle, ESP_GATT_NOT_CONNECTED);
+    this->send_gatt_error(msg.address, msg.handle, ESP_GATT_NOT_CONNECTED);
     return;
   }
 
   auto err = connection->write_characteristic(msg.handle, msg.data, msg.response);
   if (err != ESP_OK) {
-    api::global_api_server->send_bluetooth_gatt_error(msg.address, msg.handle, err);
+    this->send_gatt_error(msg.address, msg.handle, err);
   }
 }
 
@@ -348,13 +373,13 @@ void BluetoothProxy::bluetooth_gatt_read_descriptor(const api::BluetoothGATTRead
   auto *connection = this->get_connection_(msg.address, false);
   if (connection == nullptr) {
     ESP_LOGW(TAG, "Cannot read GATT descriptor, not connected");
-    api::global_api_server->send_bluetooth_gatt_error(msg.address, msg.handle, ESP_GATT_NOT_CONNECTED);
+    this->send_gatt_error(msg.address, msg.handle, ESP_GATT_NOT_CONNECTED);
     return;
   }
 
   auto err = connection->read_descriptor(msg.handle);
   if (err != ESP_OK) {
-    api::global_api_server->send_bluetooth_gatt_error(msg.address, msg.handle, err);
+    this->send_gatt_error(msg.address, msg.handle, err);
   }
 }
 
@@ -362,13 +387,13 @@ void BluetoothProxy::bluetooth_gatt_write_descriptor(const api::BluetoothGATTWri
   auto *connection = this->get_connection_(msg.address, false);
   if (connection == nullptr) {
     ESP_LOGW(TAG, "Cannot write GATT descriptor, not connected");
-    api::global_api_server->send_bluetooth_gatt_error(msg.address, msg.handle, ESP_GATT_NOT_CONNECTED);
+    this->send_gatt_error(msg.address, msg.handle, ESP_GATT_NOT_CONNECTED);
     return;
   }
 
   auto err = connection->write_descriptor(msg.handle, msg.data, true);
   if (err != ESP_OK) {
-    api::global_api_server->send_bluetooth_gatt_error(msg.address, msg.handle, err);
+    this->send_gatt_error(msg.address, msg.handle, err);
   }
 }
 
@@ -376,12 +401,12 @@ void BluetoothProxy::bluetooth_gatt_send_services(const api::BluetoothGATTGetSer
   auto *connection = this->get_connection_(msg.address, false);
   if (connection == nullptr || !connection->connected()) {
     ESP_LOGW(TAG, "Cannot get GATT services, not connected");
-    api::global_api_server->send_bluetooth_gatt_error(msg.address, 0, ESP_GATT_NOT_CONNECTED);
+    this->send_gatt_error(msg.address, 0, ESP_GATT_NOT_CONNECTED);
     return;
   }
   if (!connection->service_count_) {
     ESP_LOGW(TAG, "[%d] [%s] No GATT services found", connection->connection_index_, connection->address_str().c_str());
-    api::global_api_server->send_bluetooth_gatt_services_done(msg.address);
+    this->send_gatt_services_done(msg.address);
     return;
   }
   if (connection->send_service_ ==
@@ -393,16 +418,89 @@ void BluetoothProxy::bluetooth_gatt_notify(const api::BluetoothGATTNotifyRequest
   auto *connection = this->get_connection_(msg.address, false);
   if (connection == nullptr) {
     ESP_LOGW(TAG, "Cannot notify GATT characteristic, not connected");
-    api::global_api_server->send_bluetooth_gatt_error(msg.address, msg.handle, ESP_GATT_NOT_CONNECTED);
+    this->send_gatt_error(msg.address, msg.handle, ESP_GATT_NOT_CONNECTED);
     return;
   }
 
   auto err = connection->notify_characteristic(msg.handle, msg.enable);
   if (err != ESP_OK) {
-    api::global_api_server->send_bluetooth_gatt_error(msg.address, msg.handle, err);
+    this->send_gatt_error(msg.address, msg.handle, err);
   }
 }
 
+void BluetoothProxy::subscribe_api_connection(api::APIConnection *api_connection, uint32_t flags) {
+  if (this->api_connection_ != nullptr) {
+    ESP_LOGE(TAG, "Only one API subscription is allowed at a time");
+    return;
+  }
+  this->api_connection_ = api_connection;
+  this->raw_advertisements_ = flags & BluetoothProxySubscriptionFlag::SUBSCRIPTION_RAW_ADVERTISEMENTS;
+}
+
+void BluetoothProxy::unsubscribe_api_connection(api::APIConnection *api_connection) {
+  if (this->api_connection_ != api_connection) {
+    ESP_LOGV(TAG, "API connection is not subscribed");
+    return;
+  }
+  this->api_connection_ = nullptr;
+  this->raw_advertisements_ = false;
+}
+
+void BluetoothProxy::send_device_connection(uint64_t address, bool connected, uint16_t mtu, esp_err_t error) {
+  if (this->api_connection_ == nullptr)
+    return;
+  api::BluetoothDeviceConnectionResponse call;
+  call.address = address;
+  call.connected = connected;
+  call.mtu = mtu;
+  call.error = error;
+  this->api_connection_->send_bluetooth_device_connection_response(call);
+}
+void BluetoothProxy::send_connections_free() {
+  if (this->api_connection_ == nullptr)
+    return;
+  api::BluetoothConnectionsFreeResponse call;
+  call.free = this->get_bluetooth_connections_free();
+  call.limit = this->get_bluetooth_connections_limit();
+  this->api_connection_->send_bluetooth_connections_free_response(call);
+}
+
+void BluetoothProxy::send_gatt_services_done(uint64_t address) {
+  if (this->api_connection_ == nullptr)
+    return;
+  api::BluetoothGATTGetServicesDoneResponse call;
+  call.address = address;
+  this->api_connection_->send_bluetooth_gatt_get_services_done_response(call);
+}
+
+void BluetoothProxy::send_gatt_error(uint64_t address, uint16_t handle, esp_err_t error) {
+  if (this->api_connection_ == nullptr)
+    return;
+  api::BluetoothGATTErrorResponse call;
+  call.address = address;
+  call.handle = handle;
+  call.error = error;
+  this->api_connection_->send_bluetooth_gatt_error_response(call);
+}
+
+void BluetoothProxy::send_device_pairing(uint64_t address, bool paired, esp_err_t error) {
+  api::BluetoothDevicePairingResponse call;
+  call.address = address;
+  call.paired = paired;
+  call.error = error;
+
+  this->api_connection_->send_bluetooth_device_pairing_response(call);
+}
+
+void BluetoothProxy::send_device_unpairing(uint64_t address, bool success, esp_err_t error) {
+  api::BluetoothDeviceUnpairingResponse call;
+  call.address = address;
+  call.success = success;
+  call.error = error;
+
+  this->api_connection_->send_bluetooth_device_unpairing_response(call);
+}
+
 BluetoothProxy *global_bluetooth_proxy = nullptr;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
 
 }  // namespace bluetooth_proxy

esphome/components/bluetooth_proxy/bluetooth_proxy.h

@@ -5,6 +5,7 @@
 #include <map>
 #include <vector>
 
+#include "esphome/components/api/api_connection.h"
 #include "esphome/components/api/api_pb2.h"
 #include "esphome/components/esp32_ble_client/ble_client_base.h"
 #include "esphome/components/esp32_ble_tracker/esp32_ble_tracker.h"
@@ -21,10 +22,33 @@ static const esp_err_t ESP_GATT_NOT_CONNECTED = -1;
 
 using namespace esp32_ble_client;
 
+// Legacy versions:
+// Version 1: Initial version without active connections
+// Version 2: Support for active connections
+// Version 3: New connection API
+// Version 4: Pairing support
+// Version 5: Cache clear support
+static const uint32_t LEGACY_ACTIVE_CONNECTIONS_VERSION = 5;
+static const uint32_t LEGACY_PASSIVE_ONLY_VERSION = 1;
+
+enum BluetoothProxyFeature : uint32_t {
+  FEATURE_PASSIVE_SCAN = 1 << 0,
+  FEATURE_ACTIVE_CONNECTIONS = 1 << 1,
+  FEATURE_REMOTE_CACHING = 1 << 2,
+  FEATURE_PAIRING = 1 << 3,
+  FEATURE_CACHE_CLEARING = 1 << 4,
+  FEATURE_RAW_ADVERTISEMENTS = 1 << 5,
+};
+
+enum BluetoothProxySubscriptionFlag : uint32_t {
+  SUBSCRIPTION_RAW_ADVERTISEMENTS = 1 << 0,
+};
+
 class BluetoothProxy : public esp32_ble_tracker::ESPBTDeviceListener, public Component {
  public:
   BluetoothProxy();
   bool parse_device(const esp32_ble_tracker::ESPBTDevice &device) override;
+  bool parse_devices(esp_ble_gap_cb_param_t::ble_scan_result_evt_param *advertisements, size_t count) override;
   void dump_config() override;
   void loop() override;
 
@@ -44,6 +68,18 @@ class BluetoothProxy : public esp32_ble_tracker::ESPBTDeviceListener, public Com
   int get_bluetooth_connections_free();
   int get_bluetooth_connections_limit() { return this->connections_.size(); }
 
+  void subscribe_api_connection(api::APIConnection *api_connection, uint32_t flags);
+  void unsubscribe_api_connection(api::APIConnection *api_connection);
+  api::APIConnection *get_api_connection() { return this->api_connection_; }
+
+  void send_device_connection(uint64_t address, bool connected, uint16_t mtu = 0, esp_err_t error = ESP_OK);
+  void send_connections_free();
+  void send_gatt_services_done(uint64_t address);
+  void send_gatt_error(uint64_t address, uint16_t handle, esp_err_t error);
+  void send_device_pairing(uint64_t address, bool paired, esp_err_t error = ESP_OK);
+  void send_device_unpairing(uint64_t address, bool success, esp_err_t error = ESP_OK);
+  void send_device_clear_cache(uint64_t address, bool success, esp_err_t error = ESP_OK);
+
   static void uint64_to_bd_addr(uint64_t address, esp_bd_addr_t bd_addr) {
     bd_addr[0] = (address >> 40) & 0xff;
     bd_addr[1] = (address >> 32) & 0xff;
@@ -56,6 +92,27 @@ class BluetoothProxy : public esp32_ble_tracker::ESPBTDeviceListener, public Com
   void set_active(bool active) { this->active_ = active; }
   bool has_active() { return this->active_; }
 
+  uint32_t get_legacy_version() const {
+    if (this->active_) {
+      return LEGACY_ACTIVE_CONNECTIONS_VERSION;
+    }
+    return LEGACY_PASSIVE_ONLY_VERSION;
+  }
+
+  uint32_t get_feature_flags() const {
+    uint32_t flags = 0;
+    flags |= BluetoothProxyFeature::FEATURE_PASSIVE_SCAN;
+    flags |= BluetoothProxyFeature::FEATURE_RAW_ADVERTISEMENTS;
+    if (this->active_) {
+      flags |= BluetoothProxyFeature::FEATURE_ACTIVE_CONNECTIONS;
+      flags |= BluetoothProxyFeature::FEATURE_REMOTE_CACHING;
+      flags |= BluetoothProxyFeature::FEATURE_PAIRING;
+      flags |= BluetoothProxyFeature::FEATURE_CACHE_CLEARING;
+    }
+
+    return flags;
+  }
+
  protected:
   void send_api_packet_(const esp32_ble_tracker::ESPBTDevice &device);
 
@@ -64,18 +121,12 @@ class BluetoothProxy : public esp32_ble_tracker::ESPBTDeviceListener, public Com
   bool active_;
 
   std::vector<BluetoothConnection *> connections_{};
+  api::APIConnection *api_connection_{nullptr};
+  bool raw_advertisements_{false};
 };
 
 extern BluetoothProxy *global_bluetooth_proxy;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
 
-// Version 1: Initial version without active connections
-// Version 2: Support for active connections
-// Version 3: New connection API
-// Version 4: Pairing support
-// Version 5: Cache clear support
-static const uint32_t ACTIVE_CONNECTIONS_VERSION = 5;
-static const uint32_t PASSIVE_ONLY_VERSION = 1;
-
 }  // namespace bluetooth_proxy
 }  // namespace esphome