[bluetooth_proxy] Batch BLE service discovery messages for 67% reduction in API traffic (#9992)

esphome/components/api/api.proto

@@ -1505,7 +1505,7 @@ message BluetoothGATTGetServicesResponse {
   option (ifdef) = "USE_BLUETOOTH_PROXY";
 
   uint64 address = 1;
-  repeated BluetoothGATTService services = 2 [(fixed_array_size) = 1];
+  repeated BluetoothGATTService services = 2;
 }
 
 message BluetoothGATTGetServicesDoneResponse {

esphome/components/api/api_pb2.cpp

@@ -1929,11 +1929,13 @@ void BluetoothGATTService::calculate_size(ProtoSize &size) const {
 }
 void BluetoothGATTGetServicesResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_uint64(1, this->address);
-  buffer.encode_message(2, this->services[0], true);
+  for (auto &it : this->services) {
+    buffer.encode_message(2, it, true);
+  }
 }
 void BluetoothGATTGetServicesResponse::calculate_size(ProtoSize &size) const {
   size.add_uint64(1, this->address);
-  size.add_message_object_force(1, this->services[0]);
+  size.add_repeated_message(1, this->services);
 }
 void BluetoothGATTGetServicesDoneResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_uint64(1, this->address);

esphome/components/api/api_pb2.h

@@ -1895,12 +1895,12 @@ class BluetoothGATTService : public ProtoMessage {
 class BluetoothGATTGetServicesResponse : public ProtoMessage {
  public:
   static constexpr uint8_t MESSAGE_TYPE = 71;
-  static constexpr uint8_t ESTIMATED_SIZE = 21;
+  static constexpr uint8_t ESTIMATED_SIZE = 38;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *message_name() const override { return "bluetooth_gatt_get_services_response"; }
 #endif
   uint64_t address{0};
-  std::array<BluetoothGATTService, 1> services{};
+  std::vector<BluetoothGATTService> services{};
   void encode(ProtoWriteBuffer buffer) const override;
   void calculate_size(ProtoSize &size) const override;
 #ifdef HAS_PROTO_MESSAGE_DUMP

esphome/components/bluetooth_proxy/bluetooth_connection.cpp

@@ -57,7 +57,7 @@ void BluetoothConnection::reset_connection_(esp_err_t reason) {
 }
 
 void BluetoothConnection::send_service_for_discovery_() {
-  if (this->send_service_ == this->service_count_) {
+  if (this->send_service_ >= this->service_count_) {
     this->send_service_ = DONE_SENDING_SERVICES;
     this->proxy_->send_gatt_services_done(this->address_);
     if (this->connection_type_ == espbt::ConnectionType::V3_WITH_CACHE ||
@@ -70,26 +70,36 @@ void BluetoothConnection::send_service_for_discovery_() {
   // Early return if no API connection
   auto *api_conn = this->proxy_->get_api_connection();
   if (api_conn == nullptr) {
+    this->send_service_ = DONE_SENDING_SERVICES;
     return;
   }
 
-  // Send next service
+  // Prepare response for up to 3 services
+  api::BluetoothGATTGetServicesResponse resp;
+  resp.address = this->address_;
+
+  // Process up to 3 services in this iteration
+  uint8_t services_to_process =
+      std::min(MAX_SERVICES_PER_BATCH, static_cast<uint8_t>(this->service_count_ - this->send_service_));
+  resp.services.reserve(services_to_process);
+
+  for (int service_idx = 0; service_idx < services_to_process; service_idx++) {
     esp_gattc_service_elem_t service_result;
     uint16_t service_count = 1;
     esp_gatt_status_t service_status = esp_ble_gattc_get_service(this->gattc_if_, this->conn_id_, nullptr,
                                                                  &service_result, &service_count, this->send_service_);
-  this->send_service_++;
 
     if (service_status != ESP_GATT_OK || service_count == 0) {
       ESP_LOGE(TAG, "[%d] [%s] esp_ble_gattc_get_service %s, status=%d, service_count=%d, offset=%d",
-             this->connection_index_, this->address_str().c_str(), service_status != ESP_GATT_OK ? "error" : "missing",
+               this->connection_index_, this->address_str().c_str(),
-             service_status, service_count, this->send_service_ - 1);
+               service_status != ESP_GATT_OK ? "error" : "missing", service_status, service_count, this->send_service_);
+      this->send_service_ = DONE_SENDING_SERVICES;
       return;
     }
 
-  api::BluetoothGATTGetServicesResponse resp;
+    this->send_service_++;
-  resp.address = this->address_;
+    resp.services.emplace_back();
-  auto &service_resp = resp.services[0];
+    auto &service_resp = resp.services.back();
     fill_128bit_uuid_array(service_resp.uuid, service_result.uuid);
     service_resp.handle = service_result.start_handle;
 
@@ -100,15 +110,15 @@ void BluetoothConnection::send_service_for_discovery_() {
                                      service_result.start_handle, service_result.end_handle, 0, &total_char_count);
 
     if (char_count_status != ESP_GATT_OK) {
-    ESP_LOGW(TAG, "[%d] [%s] Error getting characteristic count, status=%d", this->connection_index_,
+      ESP_LOGE(TAG, "[%d] [%s] Error getting characteristic count, status=%d", this->connection_index_,
                this->address_str().c_str(), char_count_status);
+      this->send_service_ = DONE_SENDING_SERVICES;
       return;
     }
 
     if (total_char_count == 0) {
-    // No characteristics, just send the service response
+      // No characteristics, continue to next service
-    api_conn->send_message(resp, api::BluetoothGATTGetServicesResponse::MESSAGE_TYPE);
+      continue;
-    return;
     }
 
     // Reserve space and process characteristics
@@ -126,6 +136,7 @@ void BluetoothConnection::send_service_for_discovery_() {
       if (char_status != ESP_GATT_OK) {
         ESP_LOGE(TAG, "[%d] [%s] esp_ble_gattc_get_all_char error, status=%d", this->connection_index_,
                  this->address_str().c_str(), char_status);
+        this->send_service_ = DONE_SENDING_SERVICES;
         return;
       }
       if (char_count == 0) {
@@ -145,8 +156,9 @@ void BluetoothConnection::send_service_for_discovery_() {
           this->gattc_if_, this->conn_id_, ESP_GATT_DB_DESCRIPTOR, 0, 0, char_result.char_handle, &total_desc_count);
 
       if (desc_count_status != ESP_GATT_OK) {
-      ESP_LOGW(TAG, "[%d] [%s] Error getting descriptor count for char handle %d, status=%d", this->connection_index_,
+        ESP_LOGE(TAG, "[%d] [%s] Error getting descriptor count for char handle %d, status=%d", this->connection_index_,
                  this->address_str().c_str(), char_result.char_handle, desc_count_status);
+        this->send_service_ = DONE_SENDING_SERVICES;
         return;
       }
       if (total_desc_count == 0) {
@@ -168,6 +180,7 @@ void BluetoothConnection::send_service_for_discovery_() {
         if (desc_status != ESP_GATT_OK) {
           ESP_LOGE(TAG, "[%d] [%s] esp_ble_gattc_get_all_descr error, status=%d", this->connection_index_,
                    this->address_str().c_str(), desc_status);
+          this->send_service_ = DONE_SENDING_SERVICES;
           return;
         }
         if (desc_count == 0) {
@@ -181,8 +194,9 @@ void BluetoothConnection::send_service_for_discovery_() {
         desc_offset++;
       }
     }
+  }
 
-  // Send the message (we already checked api_conn is not null at the beginning)
+  // Send the message with 1-3 services
   api_conn->send_message(resp, api::BluetoothGATTGetServicesResponse::MESSAGE_TYPE);
 }
 

esphome/components/bluetooth_proxy/bluetooth_proxy.h

@@ -22,6 +22,7 @@ namespace esphome::bluetooth_proxy {
 
 static const esp_err_t ESP_GATT_NOT_CONNECTED = -1;
 static const int DONE_SENDING_SERVICES = -2;
+static const uint8_t MAX_SERVICES_PER_BATCH = 3;
 
 using namespace esp32_ble_client;