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

Commit 53cae542 authored by Chienyuan Huang's avatar Chienyuan Huang Committed by Automerger Merge Worker
Browse files

Merge "RAS: implement Real-time Ranging Data" into main am: 11fa99ce 

Original change: https://android-review.googlesource.com/c/platform/packages/modules/Bluetooth/+/3063970



Change-Id: Id0ec3ea5bb38c6fd526da2193fa8772a7b721fab
Signed-off-by: default avatarAutomerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
parents b3b347f7 11fa99ce

system/bta/include/bta_ras_api.h

+2 −1
Original line number Diff line number Diff line
@@ -37,7 +37,8 @@ RasServer* GetRasServer(); 
class RasClientCallbacks {

 public:

  virtual ~RasClientCallbacks() = default;

  virtual void OnRemoteData(RawAddress address, std::vector<uint8_t> data) = 0;

  virtual void OnRemoteData(const RawAddress& address,

                            const std::vector<uint8_t>& data) = 0;

};



class RasClient {

system/bta/ras/ras_client.cc

+15 −6
Original line number Diff line number Diff line
@@ -187,11 +187,7 @@ class RasClientImpl : public bluetooth::ras::RasClient { 
        },

        nullptr);



    // Subscribe Characteristics

    SubscribeCharacteristic(tracker, kRasOnDemandDataCharacteristic);

    SubscribeCharacteristic(tracker, kRasControlPointCharacteristic);

    SubscribeCharacteristic(tracker, kRasRangingDataReadyCharacteristic);

    SubscribeCharacteristic(tracker, kRasRangingDataOverWrittenCharacteristic);

  }



  void OnGattNotification(const tBTA_GATTC_NOTIFY& evt) {
@@ -211,8 +207,9 @@ class RasClientImpl : public bluetooth::ras::RasClient { 
               getUuidName(characteristic->uuid), evt.len);



    switch (uuid_16bit) {

      case kRasRealTimeRangingDataCharacteristic16bit:

      case kRasOnDemandDataCharacteristic16bit: {

        OnDemandData(evt, tracker);

        OnRemoteData(evt, tracker);

        break;

      }

      case kRasControlPointCharacteristic16bit: {
@@ -226,7 +223,7 @@ class RasClientImpl : public bluetooth::ras::RasClient { 
    }

  }



  void OnDemandData(const tBTA_GATTC_NOTIFY& evt,

  void OnRemoteData(const tBTA_GATTC_NOTIFY& evt,

                    std::shared_ptr<RasTracker> tracker) {

    std::vector<uint8_t> data;

    data.resize(evt.len);
@@ -446,6 +443,18 @@ class RasClientImpl : public bluetooth::ras::RasClient { 
        STREAM_TO_UINT32(tracker->remote_supported_features_, value);

        log::info("Remote supported features : {}",

                  getFeaturesString(tracker->remote_supported_features_));

        if (tracker->remote_supported_features_ &

            feature::kRealTimeRangingData) {

          log::info("Subscribe Real-time Ranging Data");

          SubscribeCharacteristic(tracker,

                                  kRasRealTimeRangingDataCharacteristic);

        } else {

          log::info("Subscribe On-demand Ranging Data");

          SubscribeCharacteristic(tracker, kRasOnDemandDataCharacteristic);

          SubscribeCharacteristic(tracker, kRasRangingDataReadyCharacteristic);

          SubscribeCharacteristic(tracker,

                                  kRasRangingDataOverWrittenCharacteristic);

        }

      } break;

      default:

        log::warn("Unexpected UUID");

system/bta/ras/ras_server.cc

+41 −25
Original line number Diff line number Diff line
@@ -35,7 +35,7 @@ namespace { 
class RasServerImpl;

RasServerImpl* instance;



static constexpr uint32_t kSupportedFeatures = 0;

static constexpr uint32_t kSupportedFeatures = feature::kRealTimeRangingData;

static constexpr uint16_t kBufferSize = 3;



class RasServerImpl : public bluetooth::ras::RasServer {
@@ -75,7 +75,7 @@ class RasServerImpl : public bluetooth::ras::RasServer { 


  void PushProcedureData(RawAddress address, uint16_t procedure_counter,

                         bool is_last, std::vector<uint8_t> data) {

    log::info("{}, counter:{}, is_last:{}, with size {}", address,

    log::debug("{}, counter:{}, is_last:{}, with size {}", address,

               procedure_counter, is_last, data.size());

    tBLE_BD_ADDR ble_bd_addr;

    ResolveAddress(ble_bd_addr, address);
@@ -84,21 +84,40 @@ class RasServerImpl : public bluetooth::ras::RasServer { 
      log::warn("Can't find tracker for {}", ble_bd_addr.bda);

      return;

    }

    std::lock_guard<std::mutex> lock(data_mutex_);

    ClientTracker& tracker = trackers_[ble_bd_addr.bda];

    uint16_t ccc_real_time =

        tracker.ccc_values_[kRasRealTimeRangingDataCharacteristic];

    uint16_t ccc_data_ready =

        tracker.ccc_values_[kRasRangingDataReadyCharacteristic];

    uint16_t ccc_data_over_written =

        tracker.ccc_values_[kRasRangingDataOverWrittenCharacteristic];



    if (ccc_real_time != GATT_CLT_CONFIG_NONE) {

      bool need_confirm = ccc_real_time == GATT_CHAR_CLIENT_CONFIG_INDICTION;

      uint16_t attr_id =

          GetCharacteristic(kRasRealTimeRangingDataCharacteristic)

              ->attribute_handle_;

      log::debug("Send Real-time Ranging Data");

      BTA_GATTS_HandleValueIndication(tracker.conn_id_, attr_id, data,

                                      need_confirm);

    }



    if (ccc_data_ready == GATT_CLT_CONFIG_NONE &&

        ccc_data_over_written == GATT_CLT_CONFIG_NONE) {

      return;

    }

    std::lock_guard<std::mutex> lock(on_demand_ranging_mutex_);

    DataBuffer& data_buffer =

        InitDataBuffer(ble_bd_addr.bda, procedure_counter);

    data_buffer.segments_.push_back(data);



    // Send data ready

    if (is_last) {

      uint16_t ccc_value =

          tracker.ccc_values_[kRasRangingDataReadyCharacteristic];

      if (ccc_value == GATT_CLT_CONFIG_NONE) {

        log::info("Skip Ranging Data Ready");

      if (ccc_data_ready == GATT_CLT_CONFIG_NONE) {

        log::debug("Skip Ranging Data Ready");

      } else {

        bool need_confirm = ccc_value & GATT_CLT_CONFIG_INDICATION;

        log::info("Send data ready, ranging_counter {}", procedure_counter);

        bool need_confirm = ccc_data_ready & GATT_CLT_CONFIG_INDICATION;

        log::debug("Send data ready, ranging_counter {}", procedure_counter);

        uint16_t attr_id = GetCharacteristic(kRasRangingDataReadyCharacteristic)

                               ->attribute_handle_;

        std::vector<uint8_t> value(kRingingCounterSize);
@@ -112,15 +131,13 @@ class RasServerImpl : public bluetooth::ras::RasServer { 
    // Send data overwritten

    if (tracker.buffers_.size() > kBufferSize) {

      auto begin = tracker.buffers_.begin();

      uint16_t ccc_value =

          tracker.ccc_values_[kRasRangingDataOverWrittenCharacteristic];

      if (ccc_value == GATT_CLT_CONFIG_NONE) {

        log::info("Skip Ranging Data Over Written");

      if (ccc_data_over_written == GATT_CLT_CONFIG_NONE) {

        log::debug("Skip Ranging Data Over Written");

        tracker.buffers_.erase(begin);

        return;

      }

      bool need_confirm = ccc_value & GATT_CLT_CONFIG_INDICATION;

      log::info("Send data over written, ranging_counter {}",

      bool need_confirm = ccc_data_over_written & GATT_CLT_CONFIG_INDICATION;

      log::debug("Send data over written, ranging_counter {}",

                 begin->ranging_counter_);

      uint16_t attr_id =

          GetCharacteristic(kRasRangingDataOverWrittenCharacteristic)
@@ -451,7 +468,7 @@ class RasServerImpl : public bluetooth::ras::RasServer { 
        GetCharacteristic(kRasOnDemandDataCharacteristic)->attribute_handle_;

    bool need_confirm = ccc_value & GATT_CLT_CONFIG_INDICATION;



    std::lock_guard<std::mutex> lock(data_mutex_);

    std::lock_guard<std::mutex> lock(on_demand_ranging_mutex_);

    auto it = std::find_if(tracker->buffers_.begin(), tracker->buffers_.end(),

                           [&ranging_counter](const DataBuffer& buffer) {

                             return buffer.ranging_counter_ == ranging_counter;
@@ -470,9 +487,8 @@ class RasServerImpl : public bluetooth::ras::RasServer { 
                ranging_counter);

      std::vector<uint8_t> response(8, 0);

      response[0] = (uint8_t)EventCode::COMPLETE_RANGING_DATA_RESPONSE;

      response[1] = 0;  // Null

      response[2] = (ranging_counter & 0xFF);

      response[3] = (ranging_counter >> 8) & 0xFF;

      response[1] = (ranging_counter & 0xFF);

      response[2] = (ranging_counter >> 8) & 0xFF;

      BTA_GATTS_HandleValueIndication(

          tracker->conn_id_,

          GetCharacteristic(kRasControlPointCharacteristic)->attribute_handle_,
@@ -491,7 +507,7 @@ class RasServerImpl : public bluetooth::ras::RasServer { 
    STREAM_TO_UINT16(ranging_counter, value);

    log::info("ranging_counter:{}", ranging_counter);



    std::lock_guard<std::mutex> lock(data_mutex_);

    std::lock_guard<std::mutex> lock(on_demand_ranging_mutex_);

    auto it = std::find_if(tracker->buffers_.begin(), tracker->buffers_.end(),

                           [&ranging_counter](const DataBuffer& buffer) {

                             return buffer.ranging_counter_ == ranging_counter;
@@ -500,6 +516,7 @@ class RasServerImpl : public bluetooth::ras::RasServer { 
    if (it != tracker->buffers_.end()) {

      tracker->buffers_.erase(it);

      tracker->handling_control_point_command_ = false;

      SendResponseCode(ResponseCodeValue::SUCCESS, tracker);

    } else {

      log::warn("No Records Found");

      SendResponseCode(ResponseCodeValue::NO_RECORDS_FOUND, tracker);
@@ -512,8 +529,7 @@ class RasServerImpl : public bluetooth::ras::RasServer { 
              GetResponseOpcodeValueText(response_code_value));

    std::vector<uint8_t> response(8, 0);

    response[0] = (uint8_t)EventCode::RESPONSE_CODE;

    response[1] = 0;  // Null

    response[2] = (uint8_t)response_code_value;

    response[1] = (uint8_t)response_code_value;

    BTA_GATTS_HandleValueIndication(

        tracker->conn_id_,

        GetCharacteristic(kRasControlPointCharacteristic)->attribute_handle_,
@@ -589,7 +605,7 @@ class RasServerImpl : public bluetooth::ras::RasServer { 
  std::unordered_map<uint16_t, RasCharacteristic> characteristics_;

  // A map to client trackers with address

  std::unordered_map<RawAddress, ClientTracker> trackers_;

  std::mutex data_mutex_;

  std::mutex on_demand_ranging_mutex_;

};



}  // namespace

system/gd/hci/distance_measurement_manager.cc

+5 −5
Original line number Diff line number Diff line
@@ -56,13 +56,13 @@ static constexpr uint8_t kMode0Steps = 
    0x03;  // Maximum number of mode-0 steps to increase success subevent rate

static constexpr uint8_t kChannelMapRepetition = 0x01;  // No repetition

static constexpr uint8_t kCh3cJump = 0x03;              // Skip 3 Channels

static constexpr uint16_t kMaxProcedureLen = 0xFFFF;    // 40.959375s

static constexpr uint16_t kMaxProcedureLen = 0x4E20;    // 12.5s

static constexpr uint16_t kMinProcedureInterval = 0x01;

static constexpr uint16_t kMaxProcedureInterval = 0xFF;

static constexpr uint16_t kMaxProcedureCount = 0x01;

static constexpr uint32_t kMinSubeventLen = 0x0004E2;         // 1250us

static constexpr uint32_t kMaxSubeventLen = 0x3d0900;         // 4s

static constexpr uint8_t kToneAntennaConfigSelection = 0x07;  // 2x2

static constexpr uint8_t kToneAntennaConfigSelection = 0x00;  // 1x1

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
@@ -774,7 +774,7 @@ struct DistanceMeasurementManager::impl { 
    }

  }



  void handle_remote_data(const Address& address, const std::vector<uint8_t> raw_data) {

  void handle_remote_data(const Address address, const std::vector<uint8_t> raw_data) {

    uint16_t connection_handle = acl_manager_->HACK_GetLeHandle(address);

    log::debug(

        "address:{}, connection_handle 0x{:04x}, size:{}",
@@ -938,7 +938,7 @@ struct DistanceMeasurementManager::impl { 
              double i_value = get_iq_value(tone_data.tone_data_[k].i_sample_);

              double q_value = get_iq_value(tone_data.tone_data_[k].q_sample_);

              uint8_t tone_quality_indicator = tone_data.tone_data_[k].tone_quality_indicator_;

              log::debug(

              log::verbose(

                  "antenna_path {}, {:f}, {:f}", (uint16_t)(antenna_path + 1), i_value, q_value);

              if (role == CsRole::INITIATOR) {

                procedure_data->tone_pct_initiator[antenna_path].emplace_back(i_value, q_value);
@@ -1427,7 +1427,7 @@ void DistanceMeasurementManager::StopDistanceMeasurement( 
}



void DistanceMeasurementManager::HandleRemoteData(

    const Address& address, const std::vector<uint8_t> raw_data) {

    const Address& address, const std::vector<uint8_t>& raw_data) {

  CallOn(pimpl_.get(), &impl::handle_remote_data, address, raw_data);

}

system/gd/hci/distance_measurement_manager.h

+1 −1
Original line number Diff line number Diff line
@@ -79,7 +79,7 @@ class DistanceMeasurementManager : public bluetooth::Module { 
  void StartDistanceMeasurement(

      const Address&, uint16_t interval, DistanceMeasurementMethod method);

  void StopDistanceMeasurement(const Address& address, DistanceMeasurementMethod method);

  void HandleRemoteData(const Address& address, const std::vector<uint8_t> raw_data);

  void HandleRemoteData(const Address& address, const std::vector<uint8_t>& raw_data);



  static const ModuleFactory Factory;