jeans/esphome
jeans/esphome
1
0
Fork 0
mirror of https://github.com/esphome/esphome.git synced 2025-07-30 15:16:37 +00:00
Code Issues Packages Projects Releases Wiki Activity

revert

Browse Source
This commit is contained in:
J. Nick Koston 2025-07-25 16:50:36 -10:00
parent 60d988ca92
commit 793b3de3e9
No known key found for this signature in database
2 changed files with 62 additions and 119 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

176
esphome/components/bluetooth_proxy/bluetooth_connection.cpp
View File

@ -93,136 +93,84 @@ void BluetoothConnection::send_service_for_discovery_() {
fill_128bit_uuid_array(service_resp.uuid, service_result.uuid); fill_128bit_uuid_array(service_resp.uuid, service_result.uuid);
service_resp.handle = service_result.start_handle; service_resp.handle = service_result.start_handle;
// Process characteristics for this service
if (!this->process_characteristics_for_service_(service_result.start_handle, service_result.end_handle,
service_resp)) {
return; // Error processing characteristics
}
// Send the message (we already checked api_conn is not null at the beginning)
api_conn->send_message(resp, api::BluetoothGATTGetServicesResponse::MESSAGE_TYPE);
}
bool BluetoothConnection::process_characteristics_for_service_(uint16_t service_start_handle,
uint16_t service_end_handle,
api::BluetoothGATTService &service_resp) {
// Get the number of characteristics directly with one call // Get the number of characteristics directly with one call
uint16_t total_char_count = 0; uint16_t total_char_count = 0;
esp_gatt_status_t char_count_status = esp_gatt_status_t char_count_status =
esp_ble_gattc_get_attr_count(this->gattc_if_, this->conn_id_, ESP_GATT_DB_CHARACTERISTIC, service_start_handle, esp_ble_gattc_get_attr_count(this->gattc_if_, this->conn_id_, ESP_GATT_DB_CHARACTERISTIC,
service_end_handle, 0, &total_char_count); service_result.start_handle, service_result.end_handle, 0, &total_char_count);
if (char_count_status != ESP_GATT_OK) { if (char_count_status != ESP_GATT_OK) {
ESP_LOGW(TAG, "[%d] [%s] Error getting characteristic count, status=%d", this->connection_index_, ESP_LOGW(TAG, "[%d] [%s] Error getting characteristic count, status=%d", this->connection_index_,
this->address_str().c_str(), char_count_status); this->address_str().c_str(), char_count_status);
return false; return;
} }
if (total_char_count == 0) { if (total_char_count > 0) {
return true; // No characteristics, which is valid // Reserve space and process characteristics
} service_resp.characteristics.reserve(total_char_count);
uint16_t char_offset = 0;
esp_gattc_char_elem_t char_result;
while (true) { // characteristics
uint16_t char_count = 1;
esp_gatt_status_t char_status =
esp_ble_gattc_get_all_char(this->gattc_if_, this->conn_id_, service_result.start_handle,
service_result.end_handle, &char_result, &char_count, char_offset);
if (char_status == ESP_GATT_INVALID_OFFSET || char_status == ESP_GATT_NOT_FOUND || char_count == 0) {
break;
} else 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);
return;
}
// Reserve space and process characteristics
service_resp.characteristics.reserve(total_char_count);
// Use a reasonable fixed-size buffer on the stack
constexpr uint8_t MAX_CHARACTERISTICS_PER_BATCH = 8;
esp_gattc_char_elem_t char_results[MAX_CHARACTERISTICS_PER_BATCH];
uint16_t char_offset = 0;
while (char_offset < total_char_count) {
uint16_t char_count = std::min(static_cast<uint16_t>(MAX_CHARACTERISTICS_PER_BATCH),
static_cast<uint16_t>(total_char_count - char_offset));
esp_gatt_status_t char_status =
esp_ble_gattc_get_all_char(this->gattc_if_, this->conn_id_, service_start_handle, service_end_handle,
char_results, &char_count, char_offset);
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);
return false;
}
if (char_count == 0) {
break; // No more characteristics
}
// Process this batch of characteristics
for (uint8_t i = 0; i < char_count; i++) {
service_resp.characteristics.emplace_back(); service_resp.characteristics.emplace_back();
auto &characteristic_resp = service_resp.characteristics.back(); auto &characteristic_resp = service_resp.characteristics.back();
fill_128bit_uuid_array(characteristic_resp.uuid, char_results[i].uuid); fill_128bit_uuid_array(characteristic_resp.uuid, char_result.uuid);
characteristic_resp.handle = char_results[i].char_handle; characteristic_resp.handle = char_result.char_handle;
characteristic_resp.properties = char_results[i].properties; characteristic_resp.properties = char_result.properties;
char_offset++;
// Process descriptors for this characteristic // Get the number of descriptors directly with one call
if (!this->process_descriptors_for_characteristic_(char_results[i].char_handle, service_end_handle, uint16_t total_desc_count = 0;
characteristic_resp)) { esp_gatt_status_t desc_count_status =
return false; // Error processing descriptors esp_ble_gattc_get_attr_count(this->gattc_if_, this->conn_id_, ESP_GATT_DB_DESCRIPTOR, char_result.char_handle,
service_result.end_handle, 0, &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_,
this->address_str().c_str(), char_result.char_handle, desc_count_status);
return;
} }
if (total_desc_count > 0) {
// Reserve space and process descriptors
characteristic_resp.descriptors.reserve(total_desc_count);
uint16_t desc_offset = 0;
esp_gattc_descr_elem_t desc_result;
while (true) { // descriptors
uint16_t desc_count = 1;
esp_gatt_status_t desc_status = esp_ble_gattc_get_all_descr(
this->gattc_if_, this->conn_id_, char_result.char_handle, &desc_result, &desc_count, desc_offset);
if (desc_status == ESP_GATT_INVALID_OFFSET || desc_status == ESP_GATT_NOT_FOUND || desc_count == 0) {
break;
} else 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);
return;
}
characteristic_resp.descriptors.emplace_back();
auto &descriptor_resp = characteristic_resp.descriptors.back();
fill_128bit_uuid_array(descriptor_resp.uuid, desc_result.uuid);
descriptor_resp.handle = desc_result.handle;
desc_offset++;
}
} // end else if (total_desc_count > 0)
} }
} // end else if (total_char_count > 0)
char_offset += char_count; // Send the message (we already checked api_conn is not null at the beginning)
} api_conn->send_message(resp, api::BluetoothGATTGetServicesResponse::MESSAGE_TYPE);
return true;
}
bool BluetoothConnection::process_descriptors_for_characteristic_(
uint16_t char_handle, uint16_t service_end_handle, api::BluetoothGATTCharacteristic &characteristic_resp) {
// Get the number of descriptors directly with one call
uint16_t total_desc_count = 0;
esp_gatt_status_t desc_count_status = esp_ble_gattc_get_attr_count(
this->gattc_if_, this->conn_id_, ESP_GATT_DB_DESCRIPTOR, char_handle, service_end_handle, 0, &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_,
this->address_str().c_str(), char_handle, desc_count_status);
return false;
}
if (total_desc_count == 0) {
return true; // No descriptors, which is valid
}
// Reserve space and process descriptors
characteristic_resp.descriptors.reserve(total_desc_count);
// Use a reasonable fixed-size buffer on the stack
constexpr uint8_t MAX_DESCRIPTORS_PER_BATCH = 8;
esp_gattc_descr_elem_t desc_results[MAX_DESCRIPTORS_PER_BATCH];
uint16_t desc_offset = 0;
while (desc_offset < total_desc_count) {
uint16_t desc_count = std::min(static_cast<uint16_t>(MAX_DESCRIPTORS_PER_BATCH),
static_cast<uint16_t>(total_desc_count - desc_offset));
esp_gatt_status_t desc_status = esp_ble_gattc_get_all_descr(this->gattc_if_, this->conn_id_, char_handle,
desc_results, &desc_count, desc_offset);
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);
return false;
}
if (desc_count == 0) {
break; // No more descriptors
}
// Process this batch of descriptors
for (uint8_t i = 0; i < desc_count; i++) {
characteristic_resp.descriptors.emplace_back();
auto &descriptor_resp = characteristic_resp.descriptors.back();
fill_128bit_uuid_array(descriptor_resp.uuid, desc_results[i].uuid);
descriptor_resp.handle = desc_results[i].handle;
}
desc_offset += desc_count;
}
return true;
} }
bool BluetoothConnection::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if, bool BluetoothConnection::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if,

5
esphome/components/bluetooth_proxy/bluetooth_connection.h
View File

@ -3,7 +3,6 @@
#ifdef USE_ESP32 #ifdef USE_ESP32
#include "esphome/components/esp32_ble_client/ble_client_base.h" #include "esphome/components/esp32_ble_client/ble_client_base.h"
#include "esphome/components/api/api_pb2.h"
namespace esphome::bluetooth_proxy { namespace esphome::bluetooth_proxy {
@ -29,10 +28,6 @@ class BluetoothConnection : public esp32_ble_client::BLEClientBase {
friend class BluetoothProxy; friend class BluetoothProxy;
void send_service_for_discovery_(); void send_service_for_discovery_();
bool process_characteristics_for_service_(uint16_t service_start_handle, uint16_t service_end_handle,
api::BluetoothGATTService &service_resp);
bool process_descriptors_for_characteristic_(uint16_t char_handle, uint16_t service_end_handle,
api::BluetoothGATTCharacteristic &characteristic_resp);
void reset_connection_(esp_err_t reason); void reset_connection_(esp_err_t reason);
// Memory optimized layout for 32-bit systems // Memory optimized layout for 32-bit systems