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

system/bta/include/bta_ras_api.h

+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 {

system/bta/ras/ras_client.cc

+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()) {

system/bta/ras/ras_server.cc

+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);

system/bta/ras/ras_types.h

+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 =

system/gd/hci/distance_measurement_manager.cc

+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);