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

Commit 9dfe56c7 authored by Chienyuan Huang's avatar Chienyuan Huang
Browse files

RAS: Update to d0.9r13_PR 

* Update ras code to fit d0.9r13_PR
* Prevent RAS client from holding ACL link

Bug: 324185011
Bug: 357468205
Test: m com.android.btservices
Change-Id: I2f539a6805be632d31347155182a65bd683cf3d4
parent 0ed8ea93

system/bta/ras/ras_client.cc

+7 −10
Original line number Original line Diff line number Diff line
@@ -120,7 +120,7 @@ public: 
      callbacks_->OnConnected(address, att_handle, tracker->vendor_specific_characteristics_);

      callbacks_->OnConnected(address, att_handle, tracker->vendor_specific_characteristics_);

      return;

      return;

    }

    }

    BTA_GATTC_Open(gatt_if_, ble_bd_addr.bda, BTM_BLE_DIRECT_CONNECTION, false);

    BTA_GATTC_Open(gatt_if_, ble_bd_addr.bda, BTM_BLE_DIRECT_CONNECTION, true);

  }

  }





  void SendVendorSpecificReply(

  void SendVendorSpecificReply(
@@ -142,7 +142,7 @@ public: 
      log::debug("write to remote, uuid {}, len {}",

      log::debug("write to remote, uuid {}, len {}",

                 vendor_specific_characteristic.characteristicUuid_,

                 vendor_specific_characteristic.characteristicUuid_,

                 vendor_specific_characteristic.value_.size());

                 vendor_specific_characteristic.value_.size());

      BTA_GATTC_WriteCharValue(tracker->conn_id_, characteristic->value_handle, GATT_WRITE,

      BTA_GATTC_WriteCharValue(tracker->conn_id_, characteristic->value_handle, GATT_WRITE_NO_RSP,

                               vendor_specific_characteristic.value_, GATT_AUTH_REQ_NO_MITM,

                               vendor_specific_characteristic.value_, GATT_AUTH_REQ_NO_MITM,

                               GattWriteCallback, &gatt_write_callback_data_);

                               GattWriteCallback, &gatt_write_callback_data_);

    }

    }
@@ -206,7 +206,7 @@ public: 
      BTA_GATTC_Close(evt.conn_id);

      BTA_GATTC_Close(evt.conn_id);

      return;

      return;

    }

    }

    tracker->is_connected_ = false;

    trackers_.remove(tracker);

  }

  }





  void OnGattServiceSearchComplete(const tBTA_GATTC_SEARCH_CMPL& evt) {

  void OnGattServiceSearchComplete(const tBTA_GATTC_SEARCH_CMPL& evt) {
@@ -364,8 +364,8 @@ public: 
    value[0] = (uint8_t)Opcode::GET_RANGING_DATA;

    value[0] = (uint8_t)Opcode::GET_RANGING_DATA;

    value[1] = (uint8_t)(ranging_counter & 0xFF);

    value[1] = (uint8_t)(ranging_counter & 0xFF);

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

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

    BTA_GATTC_WriteCharValue(tracker->conn_id_, characteristic->value_handle, GATT_WRITE, value,

    BTA_GATTC_WriteCharValue(tracker->conn_id_, characteristic->value_handle, GATT_WRITE_NO_RSP,

                             GATT_AUTH_REQ_NO_MITM, GattWriteCallback, nullptr);

                             value, GATT_AUTH_REQ_NO_MITM, GattWriteCallback, nullptr);

  }

  }





  void AckRangingData(uint16_t ranging_counter, std::shared_ptr<RasTracker> tracker) {

  void AckRangingData(uint16_t ranging_counter, std::shared_ptr<RasTracker> tracker) {
@@ -380,8 +380,8 @@ public: 
    value[0] = (uint8_t)Opcode::ACK_RANGING_DATA;

    value[0] = (uint8_t)Opcode::ACK_RANGING_DATA;

    value[1] = (uint8_t)(ranging_counter & 0xFF);

    value[1] = (uint8_t)(ranging_counter & 0xFF);

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

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

    BTA_GATTC_WriteCharValue(tracker->conn_id_, characteristic->value_handle, GATT_WRITE, value,

    BTA_GATTC_WriteCharValue(tracker->conn_id_, characteristic->value_handle, GATT_WRITE_NO_RSP,

                             GATT_AUTH_REQ_NO_MITM, GattWriteCallback, nullptr);

                             value, GATT_AUTH_REQ_NO_MITM, GattWriteCallback, nullptr);

    if (ranging_counter != tracker->latest_ranging_counter_) {

    if (ranging_counter != tracker->latest_ranging_counter_) {

      GetRangingData(tracker->latest_ranging_counter_, tracker);

      GetRangingData(tracker->latest_ranging_counter_, tracker);

    }

    }
@@ -612,9 +612,6 @@ public: 
      if ((value & kFilterRangingData) != 0) {

      if ((value & kFilterRangingData) != 0) {

        ss << "|Filter Ranging Data";

        ss << "|Filter Ranging Data";

      }

      }

      if ((value & kPctPhaseFormat) != 0) {

        ss << "|PCT Phase Format";

      }

    }

    }

    return ss.str();

    return ss.str();

  }

  }

system/bta/ras/ras_server.cc

+45 −10
Original line number Original line Diff line number Diff line
@@ -69,6 +69,8 @@ public: 
    bool handling_control_point_command_ = false;

    bool handling_control_point_command_ = false;

    uint8_t vendor_specific_reply_counter_ = 0;

    uint8_t vendor_specific_reply_counter_ = 0;

    PendingWriteResponse pending_write_response_;

    PendingWriteResponse pending_write_response_;

    uint16_t last_ready_procedure_ = 0;

    uint16_t last_overwritten_procedure_ = 0;

  };

  };





  void Initialize() {

  void Initialize() {
@@ -138,6 +140,7 @@ public: 
    std::lock_guard<std::mutex> lock(on_demand_ranging_mutex_);

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

    DataBuffer& data_buffer = InitDataBuffer(ble_bd_addr.bda, procedure_counter);

    DataBuffer& data_buffer = InitDataBuffer(ble_bd_addr.bda, procedure_counter);

    data_buffer.segments_.push_back(data);

    data_buffer.segments_.push_back(data);

    tracker.last_ready_procedure_ = procedure_counter;





    // Send data ready

    // Send data ready

    if (is_last) {

    if (is_last) {
@@ -158,6 +161,7 @@ public: 
    // Send data overwritten

    // Send data overwritten

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

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

      auto begin = tracker.buffers_.begin();

      auto begin = tracker.buffers_.begin();

      tracker.last_overwritten_procedure_ = begin->ranging_counter_;

      if (ccc_data_over_written == GATT_CLT_CONFIG_NONE || ccc_real_time != GATT_CLT_CONFIG_NONE) {

      if (ccc_data_over_written == GATT_CLT_CONFIG_NONE || ccc_real_time != GATT_CLT_CONFIG_NONE) {

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

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

        tracker.buffers_.erase(begin);

        tracker.buffers_.erase(begin);
@@ -181,6 +185,9 @@ public: 
      case BTA_GATTS_CONNECT_EVT: {

      case BTA_GATTS_CONNECT_EVT: {

        OnGattConnect(p_data);

        OnGattConnect(p_data);

      } break;

      } break;

      case BTA_GATTS_DISCONNECT_EVT: {

        OnGattDisconnect(p_data);

      } break;

      case BTA_GATTS_REG_EVT: {

      case BTA_GATTS_REG_EVT: {

        OnGattServerRegister(p_data);

        OnGattServerRegister(p_data);

      } break;

      } break;
@@ -215,6 +222,14 @@ public: 
    trackers_[address].conn_id_ = p_data->conn.conn_id;

    trackers_[address].conn_id_ = p_data->conn.conn_id;

  }

  }





  void OnGattDisconnect(tBTA_GATTS* p_data) {

    auto address = p_data->conn.remote_bda;

    log::info("Address: {}, conn_id:{}", address, p_data->conn.conn_id);

    if (trackers_.find(address) != trackers_.end()) {

      trackers_.erase(address);

    }

  }



  void OnGattServerRegister(tBTA_GATTS* p_data) {

  void OnGattServerRegister(tBTA_GATTS* p_data) {

    tGATT_STATUS status = p_data->reg_oper.status;

    tGATT_STATUS status = p_data->reg_oper.status;

    log::info("status: {}", gatt_status_text(p_data->reg_oper.status));

    log::info("status: {}", gatt_status_text(p_data->reg_oper.status));
@@ -279,7 +294,7 @@ public: 
    ranging_data_ready_characteristic.uuid = kRasRangingDataReadyCharacteristic;

    ranging_data_ready_characteristic.uuid = kRasRangingDataReadyCharacteristic;

    ranging_data_ready_characteristic.type = BTGATT_DB_CHARACTERISTIC;

    ranging_data_ready_characteristic.type = BTGATT_DB_CHARACTERISTIC;

    ranging_data_ready_characteristic.properties =

    ranging_data_ready_characteristic.properties =

            GATT_CHAR_PROP_BIT_NOTIFY | GATT_CHAR_PROP_BIT_INDICATE;

            GATT_CHAR_PROP_BIT_READ | GATT_CHAR_PROP_BIT_NOTIFY | GATT_CHAR_PROP_BIT_INDICATE;

    ranging_data_ready_characteristic.permissions = GATT_PERM_READ_ENCRYPTED | key_mask;

    ranging_data_ready_characteristic.permissions = GATT_PERM_READ_ENCRYPTED | key_mask;

    service.push_back(ranging_data_ready_characteristic);

    service.push_back(ranging_data_ready_characteristic);

    service.push_back(ccc_descriptor);

    service.push_back(ccc_descriptor);
@@ -289,7 +304,7 @@ public: 
    ranging_data_overwritten_characteristic.uuid = kRasRangingDataOverWrittenCharacteristic;

    ranging_data_overwritten_characteristic.uuid = kRasRangingDataOverWrittenCharacteristic;

    ranging_data_overwritten_characteristic.type = BTGATT_DB_CHARACTERISTIC;

    ranging_data_overwritten_characteristic.type = BTGATT_DB_CHARACTERISTIC;

    ranging_data_overwritten_characteristic.properties =

    ranging_data_overwritten_characteristic.properties =

            GATT_CHAR_PROP_BIT_NOTIFY | GATT_CHAR_PROP_BIT_INDICATE;

            GATT_CHAR_PROP_BIT_READ | GATT_CHAR_PROP_BIT_NOTIFY | GATT_CHAR_PROP_BIT_INDICATE;

    ranging_data_overwritten_characteristic.permissions = GATT_PERM_READ_ENCRYPTED | key_mask;

    ranging_data_overwritten_characteristic.permissions = GATT_PERM_READ_ENCRYPTED | key_mask;

    service.push_back(ranging_data_overwritten_characteristic);

    service.push_back(ranging_data_overwritten_characteristic);

    service.push_back(ccc_descriptor);

    service.push_back(ccc_descriptor);
@@ -337,6 +352,13 @@ public: 
      return;

      return;

    }

    }

    log::info("Read uuid, {}", getUuidName(uuid));

    log::info("Read uuid, {}", getUuidName(uuid));

    ClientTracker* tracker = &trackers_[p_data->req_data.remote_bda];

    if (trackers_.find(p_data->req_data.remote_bda) == trackers_.end()) {

      log::warn("Can't find tracker for {}", p_data->req_data.remote_bda);

      BTA_GATTS_SendRsp(p_data->req_data.conn_id, p_data->req_data.trans_id, GATT_ILLEGAL_PARAMETER,

                        &p_msg);

      return;

    }





    // Check Characteristic UUID

    // Check Characteristic UUID

    switch (uuid.As16Bit()) {

    switch (uuid.As16Bit()) {
@@ -344,6 +366,20 @@ public: 
        p_msg.attr_value.len = kFeatureSize;

        p_msg.attr_value.len = kFeatureSize;

        memcpy(p_msg.attr_value.value, &kSupportedFeatures, sizeof(uint32_t));

        memcpy(p_msg.attr_value.value, &kSupportedFeatures, sizeof(uint32_t));

      } break;

      } break;

      case kRasRangingDataReadyCharacteristic16bit: {

        p_msg.attr_value.len = kRingingCounterSize;

        std::vector<uint8_t> value(kRingingCounterSize);

        if (tracker->buffers_.size() > 0) {

          p_msg.attr_value.value[0] = (tracker->last_ready_procedure_ & 0xFF);

          p_msg.attr_value.value[1] = (tracker->last_ready_procedure_ >> 8) & 0xFF;

        }

      } break;

      case kRasRangingDataOverWrittenCharacteristic16bit: {

        p_msg.attr_value.len = kRingingCounterSize;

        std::vector<uint8_t> value(kRingingCounterSize);

        p_msg.attr_value.value[0] = (tracker->last_overwritten_procedure_ & 0xFF);

        p_msg.attr_value.value[1] = (tracker->last_overwritten_procedure_ >> 8) & 0xFF;

      } break;

      default:

      default:

        log::warn("Unhandled uuid {}", uuid.ToString());

        log::warn("Unhandled uuid {}", uuid.ToString());

        BTA_GATTS_SendRsp(p_data->req_data.conn_id, p_data->req_data.trans_id,

        BTA_GATTS_SendRsp(p_data->req_data.conn_id, p_data->req_data.trans_id,
@@ -418,8 +454,8 @@ public: 
        }

        }

        ClientTracker* tracker = &trackers_[p_data->req_data.remote_bda];

        ClientTracker* tracker = &trackers_[p_data->req_data.remote_bda];

        if (tracker->handling_control_point_command_) {

        if (tracker->handling_control_point_command_) {

          log::warn("Procedure Already In Progress");

          log::warn("Server busy");

          BTA_GATTS_SendRsp(conn_id, p_data->req_data.trans_id, GATT_PRC_IN_PROGRESS, &p_msg);

          SendResponseCode(ResponseCodeValue::SERVER_BUSY, tracker);

          return;

          return;

        }

        }

        if (need_rsp) {

        if (need_rsp) {
@@ -532,20 +568,19 @@ public: 
    tracker->handling_control_point_command_ = true;

    tracker->handling_control_point_command_ = true;





    switch (command.opcode_) {

    switch (command.opcode_) {

      case Opcode::GET_RANGING_DATA: {

      case Opcode::GET_RANGING_DATA:

        OnGetRangingData(&command, tracker);

        OnGetRangingData(&command, tracker);

      } break;

        break;

      case Opcode::ACK_RANGING_DATA: {

      case Opcode::ACK_RANGING_DATA:

        OnAckRangingData(&command, tracker);

        OnAckRangingData(&command, tracker);

      } break;

        break;

      case Opcode::RETRIEVE_LOST_RANGING_DATA_SEGMENTS:

      case Opcode::RETRIEVE_LOST_RANGING_DATA_SEGMENTS:

      case Opcode::ABORT_OPERATION:

      case Opcode::ABORT_OPERATION:

      case Opcode::FILTER:

      case Opcode::FILTER:

      case Opcode::PCT_FORMAT: {

        log::warn("Unsupported opcode:0x{:02x}, {}", (uint16_t)command.opcode_,

        log::warn("Unsupported opcode:0x{:02x}, {}", (uint16_t)command.opcode_,

                  GetOpcodeText(command.opcode_));

                  GetOpcodeText(command.opcode_));

        SendResponseCode(ResponseCodeValue::OP_CODE_NOT_SUPPORTED, tracker);

        SendResponseCode(ResponseCodeValue::OP_CODE_NOT_SUPPORTED, tracker);

      } break;

        break;

      default:

      default:

        log::warn("Unknown opcode:0x{:02x}", (uint16_t)command.opcode_);

        log::warn("Unknown opcode:0x{:02x}", (uint16_t)command.opcode_);

        SendResponseCode(ResponseCodeValue::OP_CODE_NOT_SUPPORTED, tracker);

        SendResponseCode(ResponseCodeValue::OP_CODE_NOT_SUPPORTED, tracker);

system/bta/ras/ras_types.h

+1 −3
Original line number Original line Diff line number Diff line
@@ -58,7 +58,6 @@ static const uint32_t kRealTimeRangingData = 0x01; 
static const uint32_t kRetrieveLostRangingDataSegments = 0x02;

static const uint32_t kRetrieveLostRangingDataSegments = 0x02;

static const uint32_t kAbortOperation = 0x04;

static const uint32_t kAbortOperation = 0x04;

static const uint32_t kFilterRangingData = 0x08;

static const uint32_t kFilterRangingData = 0x08;

static const uint32_t kPctPhaseFormat = 0xA0;

}  // namespace feature

}  // namespace feature





enum class Opcode : uint8_t {

enum class Opcode : uint8_t {
@@ -67,7 +66,6 @@ enum class Opcode : uint8_t { 
  RETRIEVE_LOST_RANGING_DATA_SEGMENTS = 0x02,

  RETRIEVE_LOST_RANGING_DATA_SEGMENTS = 0x02,

  ABORT_OPERATION = 0x03,

  ABORT_OPERATION = 0x03,

  FILTER = 0x04,

  FILTER = 0x04,

  PCT_FORMAT = 0x05,

};

};





static const uint8_t OPERATOR_NULL = 0x00;

static const uint8_t OPERATOR_NULL = 0x00;
@@ -88,7 +86,7 @@ enum class ResponseCodeValue : uint8_t { 
  PERSISTED = 0x04,

  PERSISTED = 0x04,

  ABORT_UNSUCCESSFUL = 0x05,

  ABORT_UNSUCCESSFUL = 0x05,

  PROCEDURE_NOT_COMPLETED = 0x06,

  PROCEDURE_NOT_COMPLETED = 0x06,

  OPERAND_NOT_SUPPORTED = 0x07,

  SERVER_BUSY = 0x07,

  NO_RECORDS_FOUND = 0x08,

  NO_RECORDS_FOUND = 0x08,

};

};

system/bta/ras/ras_utils.cc

+7 −14
Original line number Original line Diff line number Diff line
@@ -64,23 +64,18 @@ bool ParseControlPointCommand(ControlPointCommand* command, const uint8_t* value 
        return false;

        return false;

      }

      }

      break;

      break;

    case (uint8_t)Opcode::PCT_FORMAT: {

      if (len != 2) {

        return false;

      }

    } break;

    case (uint8_t)Opcode::GET_RANGING_DATA:

    case (uint8_t)Opcode::GET_RANGING_DATA:

    case (uint8_t)Opcode::ACK_RANGING_DATA:

    case (uint8_t)Opcode::ACK_RANGING_DATA:

    case (uint8_t)Opcode::FILTER: {

    case (uint8_t)Opcode::FILTER:

      if (len != 3) {

      if (len != 3) {

        return false;

        return false;

      }

      }

    } break;

      break;

    case (uint8_t)Opcode::RETRIEVE_LOST_RANGING_DATA_SEGMENTS: {

    case (uint8_t)Opcode::RETRIEVE_LOST_RANGING_DATA_SEGMENTS:

      if (len != 5) {

      if (len != 5) {

        return false;

        return false;

      }

      }

    } break;

      break;

    default:

    default:

      log::warn("unknown opcode 0x{:02x}", value[0]);

      log::warn("unknown opcode 0x{:02x}", value[0]);

      return false;

      return false;
@@ -102,8 +97,6 @@ std::string GetOpcodeText(Opcode opcode) { 
      return "ABORT_OPERATION";

      return "ABORT_OPERATION";

    case Opcode::FILTER:

    case Opcode::FILTER:

      return "FILTER";

      return "FILTER";

    case Opcode::PCT_FORMAT:

      return "PCT_FORMAT";

    default:

    default:

      return "Unknown Opcode";

      return "Unknown Opcode";

  }

  }
@@ -125,12 +118,12 @@ std::string GetResponseOpcodeValueText(ResponseCodeValue response_code_value) { 
      return "ABORT_UNSUCCESSFUL";

      return "ABORT_UNSUCCESSFUL";

    case ResponseCodeValue::PROCEDURE_NOT_COMPLETED:

    case ResponseCodeValue::PROCEDURE_NOT_COMPLETED:

      return "PROCEDURE_NOT_COMPLETED";

      return "PROCEDURE_NOT_COMPLETED";

    case ResponseCodeValue::OPERAND_NOT_SUPPORTED:

    case ResponseCodeValue::SERVER_BUSY:

      return "OPERAND_NOT_SUPPORTED";

      return "SERVER_BUSY";

    case ResponseCodeValue::NO_RECORDS_FOUND:

    case ResponseCodeValue::NO_RECORDS_FOUND:

      return "NO_RECORDS_FOUND";

      return "NO_RECORDS_FOUND";

    default:

    default:

      return "Unknown Opcode";

      return "Reserved for Future Use";

  }

  }

}

}