Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit bc21e5f7 authored by Steven Liu's avatar Steven Liu
Browse files

Configs MTU for RAS if it is required.

Flag: com.android.bluetooth.flags.channel_sounding_in_stack
Bug: 324185011
Bug: 372295481
Test: m com.android.btservices
Change-Id: Ibfec52233be58e125868763eab05574c78719d88
parent cdc27a6c
Loading
Loading
Loading
Loading
+2 −0
Original line number Diff line number Diff line
@@ -38,6 +38,7 @@ public:
          const RawAddress& address,
          const std::vector<VendorSpecificCharacteristic>& vendor_specific_reply) = 0;
  virtual void OnRasServerConnected(const RawAddress& identity_address) = 0;
  virtual void OnMtuChangedFromServer(const RawAddress& address, uint16_t mtu) = 0;
  virtual void OnRasServerDisconnected(const RawAddress& identity_address) = 0;
};

@@ -67,6 +68,7 @@ public:
  virtual void OnWriteVendorSpecificReplyComplete(const RawAddress& address, bool success) = 0;
  virtual void OnRemoteData(const RawAddress& address, const std::vector<uint8_t>& data) = 0;
  virtual void OnRemoteDataTimeout(const RawAddress& address) = 0;
  virtual void OnMtuChangedFromClient(const RawAddress& address, uint16_t mtu) = 0;
};

class RasClient {
+22 −0
Original line number Diff line number Diff line
@@ -68,6 +68,7 @@ class RasClientImpl : public bluetooth::ras::RasClient {
  static constexpr uint16_t kFollowingSegmentTimeoutMs = 1000;
  static constexpr uint16_t kRangingDataReadyTimeoutMs = 5000;
  static constexpr uint16_t kInvalidConnInterval = 0;  // valid value is from 0x0006 to 0x0C0
  static constexpr uint16_t kMinimumRasMtu = 247;      // 4.1 Maximum transmission unit of RAP 1.0

public:
  struct GattReadCallbackData {
@@ -108,6 +109,7 @@ public:
    RangingType ranging_type_ = RANGING_TYPE_NONE;
    TimeoutType timeout_type_ = TIMEOUT_NONE;
    uint16_t conn_interval_ = kInvalidConnInterval;
    uint16_t mtu = kDefaultGattMtu;

    const gatt::Characteristic* FindCharacteristicByUuid(Uuid uuid) {
      for (auto& characteristic : service_->characteristics) {
@@ -230,6 +232,9 @@ public:
      case BTA_GATTC_SEARCH_CMPL_EVT: {
        OnGattServiceSearchComplete(p_data->search_cmpl);
      } break;
      case BTA_GATTC_CFG_MTU_EVT: {
        OnGattConfigMtu(p_data->cfg_mtu);
      } break;
      case BTA_GATTC_NOTIF_EVT: {
        OnGattNotification(p_data->notify);
      } break;
@@ -310,6 +315,9 @@ public:
        break;
      }
    }
    // config mtu anyway, if it had been configured by others, it can get the current mtu.
    log::info("config the MTU size as RAP minimum value {}", kMinimumRasMtu);
    BTA_GATTC_ConfigureMTU(evt.conn_id, kMinimumRasMtu);

    if (tracker->service_search_complete_) {
      log::info("Service search already completed, ignore");
@@ -362,6 +370,20 @@ public:
    }
  }

  void OnGattConfigMtu(const tBTA_GATTC_CFG_MTU& evt) {
    if (evt.status != GATT_SUCCESS) {
      log::warn("Failed to config the MTU size:{}", evt.mtu);
      return;
    }
    // the MTU is always 517 since android 14
    log::info("conn_id=0x{:04x}, status:{}, mtu:{}", evt.conn_id, evt.status, evt.mtu);
    auto tracker = FindTrackerByHandle(evt.conn_id);
    if (tracker != nullptr) {
      tracker->mtu = evt.mtu;
      callbacks_->OnMtuChangedFromClient(tracker->address_for_cs_, evt.mtu);
    }
  }

  bool UseCachedData(std::shared_ptr<RasTracker> tracker) {
    auto cached_data = cached_data_.find(tracker->address_);
    if (cached_data == cached_data_.end()) {
+17 −0
Original line number Diff line number Diff line
@@ -85,6 +85,7 @@ public:
    PendingWriteResponse pending_write_response_;
    uint16_t last_ready_procedure_ = 0;
    uint16_t last_overwritten_procedure_ = 0;
    uint16_t mtu = kDefaultGattMtu;
  };

  void Initialize() override {
@@ -210,6 +211,9 @@ public:
      case BTA_GATTS_DISCONNECT_EVT: {
        OnGattDisconnect(p_data);
      } break;
      case BTA_GATTS_MTU_EVT: {
        OnGattMtuChanged(p_data->req_data);
      } break;
      case BTA_GATTS_REG_EVT: {
        OnGattServerRegister(p_data);
      } break;
@@ -250,6 +254,19 @@ public:
    callbacks_->OnRasServerConnected(identity_address);
  }

  void OnGattMtuChanged(const tBTA_GATTS_REQ& req_data) {
    auto remote_bda = req_data.remote_bda;
    log::info("mtu is changed as {}", req_data.p_data->mtu);
    auto it = trackers_.find(remote_bda);
    if (it != trackers_.end()) {
      it->second.mtu = req_data.p_data->mtu;

      tBLE_ADDR_TYPE address_type = BLE_ADDR_PUBLIC_ID;
      btm_random_pseudo_to_identity_addr(&remote_bda, &address_type);
      callbacks_->OnMtuChangedFromServer(remote_bda, it->second.mtu);
    }
  }

  void OnGattDisconnect(tBTA_GATTS* p_data) {
    auto remote_bda = p_data->conn.remote_bda;
    log::info("Address: {}, conn_id:{}", remote_bda, p_data->conn.conn_id);
+1 −0
Original line number Diff line number Diff line
@@ -32,6 +32,7 @@ static const uint16_t kRasControlPointCharacteristic16bit = 0x2C17;
static const uint16_t kRasRangingDataReadyCharacteristic16bit = 0x2C18;
static const uint16_t kRasRangingDataOverWrittenCharacteristic16bit = 0x2C19;
static const uint16_t kClientCharacteristicConfiguration16bit = 0x2902;
static const uint16_t kDefaultGattMtu = 23;

static const bluetooth::Uuid kRangingService = bluetooth::Uuid::From16Bit(kRangingService16Bit);
static const bluetooth::Uuid kRasFeaturesCharacteristic =
+33 −8
Original line number Diff line number Diff line
@@ -66,7 +66,6 @@ static constexpr uint32_t kMinSubeventLen = 0x0004E2; // 1250us
static constexpr uint32_t kMaxSubeventLen = 0x3d0900;         // 4s
static constexpr uint8_t kTxPwrDelta = 0x00;
static constexpr uint8_t kProcedureDataBufferSize = 0x10;  // Buffer size of Procedure data
static constexpr uint16_t kMtuForRasData = 507;            // 512 - 5
static constexpr uint16_t kRangingCounterMask = 0x0FFF;
static constexpr uint8_t kInvalidConfigId = 0xFF;
static constexpr uint8_t kMinConfigId = 0;
@@ -74,6 +73,9 @@ static constexpr uint8_t kMaxConfigId = 3;
static constexpr uint16_t kDefaultIntervalMs = 1000;  // 1s
static constexpr uint8_t kMaxRetryCounterForCreateConfig = 0x03;
static constexpr uint16_t kInvalidConnInterval = 0;  // valid value is from 0x0006 to 0x0C80
static constexpr uint16_t kDefaultRasMtu = 247;      // Section 3.1.2 of RAP 1.0
static constexpr uint8_t kAttHeaderSize = 5;         // Section 3.2.2.1 of RAS 1.0
static constexpr uint8_t kRasSegmentHeaderSize = 1;

struct DistanceMeasurementManager::impl : bluetooth::hal::RangingHalCallback {
  struct CsProcedureData {
@@ -532,6 +534,7 @@ struct DistanceMeasurementManager::impl : bluetooth::hal::RangingHalCallback {
        }
        distance_measurement_callbacks_->OnDistanceMeasurementStopped(
                address, REASON_NO_LE_CONNECTION, METHOD_CS);
        gatt_mtus_.erase(it->first);
        it = cs_requester_trackers_.erase(it);  // erase and get the next iterator
      } else {
        ++it;
@@ -578,6 +581,20 @@ struct DistanceMeasurementManager::impl : bluetooth::hal::RangingHalCallback {
    it->second.local_hci_role = local_hci_role;
  }

  void handle_mtu_changed(uint16_t connection_handle, uint16_t mtu) {
    log::info("gatt mtu is changed as {}", mtu);
    gatt_mtus_[connection_handle] = mtu;
  }

  uint16_t get_ras_raw_payload_size(uint16_t connection_handle) {
    auto it = gatt_mtus_.find(connection_handle);
    uint16_t mtu = kDefaultRasMtu;
    if (it != gatt_mtus_.end()) {
      mtu = gatt_mtus_[connection_handle];
    }
    return mtu - kAttHeaderSize - kRasSegmentHeaderSize;
  }

  void handle_ras_server_disconnected(const Address& identity_address, uint16_t connection_handle) {
    auto it = cs_responder_trackers_.find(connection_handle);
    if (it == cs_responder_trackers_.end()) {
@@ -590,6 +607,7 @@ struct DistanceMeasurementManager::impl : bluetooth::hal::RangingHalCallback {
      return;
    }
    cs_responder_trackers_.erase(connection_handle);
    gatt_mtus_.erase(connection_handle);
  }

  void handle_vendor_specific_reply_complete(const Address address, uint16_t connection_handle,
@@ -1329,7 +1347,8 @@ struct DistanceMeasurementManager::impl : bluetooth::hal::RangingHalCallback {
      append_vector(procedure_data->ras_raw_data_, subevent_raw);
      // erase buffer
      procedure_data->ras_subevent_data_.clear();
      send_on_demand_data(live_tracker->address, procedure_data);
      send_on_demand_data(live_tracker->address, procedure_data,
                          get_ras_raw_payload_size(connection_handle));
      // remove procedure data sent previously
      if (procedure_done_status == CsProcedureDoneStatus::ALL_RESULTS_COMPLETE) {
        delete_consumed_procedure_data(live_tracker, live_tracker->procedure_counter);
@@ -1337,20 +1356,21 @@ struct DistanceMeasurementManager::impl : bluetooth::hal::RangingHalCallback {
    }
  }

  void send_on_demand_data(Address address, CsProcedureData* procedure_data) {
  void send_on_demand_data(Address address, CsProcedureData* procedure_data,
                           uint16_t raw_payload_size) {
    // Check is last segment or not.
    uint16_t unsent_data_size =
            procedure_data->ras_raw_data_.size() - procedure_data->ras_raw_data_index_;
    if (procedure_data->local_status != CsProcedureDoneStatus::PARTIAL_RESULTS &&
        unsent_data_size <= kMtuForRasData) {
        unsent_data_size <= raw_payload_size) {
      procedure_data->segmentation_header_.last_segment_ = 1;
    } else if (unsent_data_size < kMtuForRasData) {
    } else if (unsent_data_size < raw_payload_size) {
      log::verbose("waiting for more data, current unsent data size {}", unsent_data_size);
      return;
    }

    // Create raw data for segment_data;
    uint16_t copy_size = unsent_data_size < kMtuForRasData ? unsent_data_size : kMtuForRasData;
    uint16_t copy_size = unsent_data_size < raw_payload_size ? unsent_data_size : raw_payload_size;
    auto copy_start = procedure_data->ras_raw_data_.begin() + procedure_data->ras_raw_data_index_;
    auto copy_end = copy_start + copy_size;
    std::vector<uint8_t> subevent_data(copy_start, copy_end);
@@ -1371,8 +1391,8 @@ struct DistanceMeasurementManager::impl : bluetooth::hal::RangingHalCallback {
    if (procedure_data->segmentation_header_.last_segment_) {
      // last segment sent, clear buffer
      procedure_data->ras_raw_data_.clear();
    } else if (unsent_data_size > kMtuForRasData) {
      send_on_demand_data(address, procedure_data);
    } else if (unsent_data_size > raw_payload_size) {
      send_on_demand_data(address, procedure_data, raw_payload_size);
    }
  }

@@ -2431,6 +2451,7 @@ struct DistanceMeasurementManager::impl : bluetooth::hal::RangingHalCallback {
  std::unordered_map<Address, RSSITracker> rssi_trackers;
  std::unordered_map<uint16_t, CsTracker> cs_requester_trackers_;
  std::unordered_map<uint16_t, CsTracker> cs_responder_trackers_;
  std::unordered_map<uint16_t, uint16_t> gatt_mtus_;
  DistanceMeasurementCallbacks* distance_measurement_callbacks_;
  CsOptionalSubfeaturesSupported cs_subfeature_supported_;
  uint8_t num_antennas_supported_ = 0x01;
@@ -2524,6 +2545,10 @@ void DistanceMeasurementManager::HandleRasServerConnected(const Address& identit
         local_hci_role);
}

void DistanceMeasurementManager::HandleMtuChanged(uint16_t connection_handle, uint16_t mtu) {
  CallOn(pimpl_.get(), &impl::handle_mtu_changed, connection_handle, mtu);
}

void DistanceMeasurementManager::HandleRasServerDisconnected(
        const bluetooth::hci::Address& identity_address, uint16_t connection_handle) {
  CallOn(pimpl_.get(), &impl::handle_ras_server_disconnected, identity_address, connection_handle);
Loading