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

Commit 8fa4eff6 authored by android-build-team Robot's avatar android-build-team Robot
Browse files

Snap for 5984067 from 5af805ef to rvc-release 

Change-Id: Ic3c0143ff5d74453c9e7b0c3307ab233be4d942f
parents f54477b3 5af805ef

system/gd/cert/grpc_root_server.cc

+1 −0
Original line number Diff line number Diff line
@@ -85,6 +85,7 @@ class RootCertService : public ::bluetooth::cert::RootCert::Service { 


    stack_manager_.GetInstance<GrpcModule>()->StopServer();

    grpc_loop_thread_->join();

    delete grpc_loop_thread_;



    stack_manager_.ShutDown();

    delete stack_thread_;

system/gd/facade/grpc_root_server.cc

+1 −0
Original line number Diff line number Diff line
@@ -86,6 +86,7 @@ class RootFacadeService : public ::bluetooth::facade::RootFacade::Service { 


    stack_manager_.GetInstance<GrpcModule>()->StopServer();

    grpc_loop_thread_->join();

    delete grpc_loop_thread_;



    stack_manager_.ShutDown();

    delete stack_thread_;

system/gd/hci/acl_manager.cc

+49 −13
Original line number Diff line number Diff line
@@ -17,6 +17,7 @@ 
#include "hci/acl_manager.h"



#include <future>

#include <queue>

#include <set>

#include <utility>
@@ -32,7 +33,9 @@ using common::Bind; 
using common::BindOnce;



struct AclManager::acl_connection {

  acl_connection(AddressWithType address_with_type) : address_with_type_(address_with_type) {}

  friend AclConnection;

  AddressWithType address_with_type_;

  std::unique_ptr<AclConnection::Queue> queue_ = std::make_unique<AclConnection::Queue>(10);

  bool is_disconnected_ = false;

  ErrorCode disconnect_reason_;
@@ -170,7 +173,7 @@ struct AclManager::impl { 


  void buffer_packet() {

    unregister_all_connections();

    PacketBoundaryFlag packet_boundary_flag = PacketBoundaryFlag::COMPLETE_PDU;

    PacketBoundaryFlag packet_boundary_flag = PacketBoundaryFlag::FIRST_AUTOMATICALLY_FLUSHABLE;

    BroadcastFlag broadcast_flag = BroadcastFlag::POINT_TO_POINT;

    //   Wrap packet and enqueue it

    uint16_t handle = current_connection_pair_->first;
@@ -244,7 +247,10 @@ struct AclManager::impl { 
      return;

    }

    connecting_.insert(address);

    if (should_accept_connection_.Run(address, request.GetClassOfDevice())) {

    if (is_classic_link_already_connected(address)) {

      auto reason = RejectConnectionReason::UNACCEPTABLE_BD_ADDR;

      this->reject_connection(RejectConnectionRequestBuilder::Create(address, reason));

    } else if (should_accept_connection_.Run(address, request.GetClassOfDevice())) {

      this->accept_connection(address);

    } else {

      auto reason = RejectConnectionReason::LIMITED_RESOURCES;  // TODO: determine reason
@@ -287,7 +293,7 @@ struct AclManager::impl { 
    // TODO: Check and save other connection parameters

    uint16_t handle = connection_complete.GetConnectionHandle();

    ASSERT(acl_connections_.count(handle) == 0);

    acl_connections_[handle] = {};

    acl_connections_.emplace(handle, address_with_type);

    if (acl_connections_.size() == 1 && packet_to_send_ == nullptr) {

      start_round_robin();

    }
@@ -320,7 +326,7 @@ struct AclManager::impl { 
    // TODO: Check and save other connection parameters

    uint16_t handle = connection_complete.GetConnectionHandle();

    ASSERT(acl_connections_.count(handle) == 0);

    acl_connections_[handle] = {};

    acl_connections_.emplace(handle, reporting_address_with_type);

    if (acl_connections_.size() == 1 && packet_to_send_ == nullptr) {

      start_round_robin();

    }
@@ -345,13 +351,27 @@ struct AclManager::impl { 
    }

    uint16_t handle = connection_complete.GetConnectionHandle();

    ASSERT(acl_connections_.count(handle) == 0);

    acl_connections_[handle] = {};

    acl_connections_.emplace(handle, AddressWithType{address, AddressType::PUBLIC_DEVICE_ADDRESS});

    if (acl_connections_.size() == 1 && packet_to_send_ == nullptr) {

      start_round_robin();

    }

    std::unique_ptr<AclConnection> connection_proxy(new AclConnection(&acl_manager_, handle, address));

    client_handler_->Post(common::BindOnce(&ConnectionCallbacks::OnConnectSuccess,

                                           common::Unretained(client_callbacks_), std::move(connection_proxy)));

    while (!pending_outgoing_connections_.empty()) {

      auto create_connection_packet_and_address = std::move(pending_outgoing_connections_.front());

      pending_outgoing_connections_.pop();

      if (!is_classic_link_already_connected(create_connection_packet_and_address.first)) {

        connecting_.insert(create_connection_packet_and_address.first);

        hci_layer_->EnqueueCommand(std::move(create_connection_packet_and_address.second),

                                   common::BindOnce([](CommandStatusView status) {

                                     ASSERT(status.IsValid());

                                     ASSERT(status.GetCommandOpCode() == OpCode::CREATE_CONNECTION);

                                   }),

                                   handler_);

        break;

      }

    }

  }



  void on_disconnection_complete(EventPacketView packet) {
@@ -837,6 +857,15 @@ struct AclManager::impl { 
    }

  }



  bool is_classic_link_already_connected(Address address) {

    for (const auto& connection : acl_connections_) {

      if (connection.second.address_with_type_.GetAddress() == address) {

        return true;

      }

    }

    return false;

  }



  void create_connection(Address address) {

    // TODO: Configure default connection parameters?

    uint16_t packet_type = 0x4408 /* DM 1,3,5 */ | 0x8810 /*DH 1,3,5 */;
@@ -845,16 +874,23 @@ struct AclManager::impl { 
    ClockOffsetValid clock_offset_valid = ClockOffsetValid::INVALID;

    CreateConnectionRoleSwitch allow_role_switch = CreateConnectionRoleSwitch::ALLOW_ROLE_SWITCH;

    ASSERT(client_callbacks_ != nullptr);



    connecting_.insert(address);

    std::unique_ptr<CreateConnectionBuilder> packet = CreateConnectionBuilder::Create(

        address, packet_type, page_scan_repetition_mode, clock_offset, clock_offset_valid, allow_role_switch);



    if (connecting_.empty()) {

      if (is_classic_link_already_connected(address)) {

        LOG_WARN("already connected: %s", address.ToString().c_str());

        return;

      }

      connecting_.insert(address);

      hci_layer_->EnqueueCommand(std::move(packet), common::BindOnce([](CommandStatusView status) {

                                   ASSERT(status.IsValid());

                                   ASSERT(status.GetCommandOpCode() == OpCode::CREATE_CONNECTION);

                                 }),

                                 handler_);

    } else {

      pending_outgoing_connections_.emplace(address, std::move(packet));

    }

  }



  void create_le_connection(AddressWithType address_with_type) {
@@ -892,7 +928,6 @@ struct AclManager::impl { 
      LOG_INFO("Cannot cancel non-existent connection to %s", address.ToString().c_str());

      return;

    }

    connecting_.erase(connecting_addr);

    std::unique_ptr<CreateConnectionCancelBuilder> packet = CreateConnectionCancelBuilder::Create(address);

    hci_layer_->EnqueueCommand(std::move(packet), common::BindOnce([](CommandCompleteView complete) { /* TODO */ }),

                               handler_);
@@ -1562,6 +1597,7 @@ struct AclManager::impl { 
  std::set<Address> connecting_;

  std::set<AddressWithType> connecting_le_;

  common::Callback<bool(Address, ClassOfDevice)> should_accept_connection_;

  std::queue<std::pair<Address, std::unique_ptr<CreateConnectionBuilder>>> pending_outgoing_connections_;

};



AclConnection::QueueUpEnd* AclConnection::GetAclQueueEnd() const {

system/gd/hci/cert/cert.cc

+1 −1
Original line number Diff line number Diff line
@@ -237,7 +237,7 @@ class AclManagerCertService : public AclManagerCert::Service { 
      return ::grpc::Status(::grpc::StatusCode::INVALID_ARGUMENT, "Invalid address");

    }



    constexpr PacketBoundaryFlag packet_boundary_flag = PacketBoundaryFlag::COMPLETE_PDU;

    constexpr PacketBoundaryFlag packet_boundary_flag = PacketBoundaryFlag::FIRST_AUTOMATICALLY_FLUSHABLE;

    constexpr BroadcastFlag broadcast_flag = BroadcastFlag::POINT_TO_POINT;

    std::unique_ptr<RawBuilder> packet = std::make_unique<RawBuilder>();

    auto req_string = request->payload();

system/gd/hci/hci_layer_test.cc

+3 −3
Original line number Diff line number Diff line
@@ -625,7 +625,7 @@ TEST_F(HciTest, createConnectionTest) { 
  ASSERT_EQ(encryption_enabled, connection_complete_view.GetEncryptionEnabled());



  // Send an ACL packet from the remote

  PacketBoundaryFlag packet_boundary_flag = PacketBoundaryFlag::COMPLETE_PDU;

  PacketBoundaryFlag packet_boundary_flag = PacketBoundaryFlag::FIRST_AUTOMATICALLY_FLUSHABLE;

  BroadcastFlag broadcast_flag = BroadcastFlag::POINT_TO_POINT;

  auto acl_payload = std::make_unique<RawBuilder>();

  acl_payload->AddAddress(bd_addr);
@@ -645,7 +645,7 @@ TEST_F(HciTest, createConnectionTest) { 
  ASSERT_EQ(handle, itr.extract<uint16_t>());



  // Send an ACL packet from DependsOnHci

  PacketBoundaryFlag packet_boundary_flag2 = PacketBoundaryFlag::COMPLETE_PDU;

  PacketBoundaryFlag packet_boundary_flag2 = PacketBoundaryFlag::FIRST_AUTOMATICALLY_FLUSHABLE;

  BroadcastFlag broadcast_flag2 = BroadcastFlag::POINT_TO_POINT;

  auto acl_payload2 = std::make_unique<RawBuilder>();

  acl_payload2->AddOctets2(handle);
@@ -671,7 +671,7 @@ TEST_F(HciTest, receiveMultipleAclPackets) { 
  ASSERT_TRUE(Address::FromString("A1:A2:A3:A4:A5:A6", bd_addr));

  uint16_t handle = 0x0001;

  uint16_t num_packets = 100;

  PacketBoundaryFlag packet_boundary_flag = PacketBoundaryFlag::COMPLETE_PDU;

  PacketBoundaryFlag packet_boundary_flag = PacketBoundaryFlag::FIRST_AUTOMATICALLY_FLUSHABLE;

  BroadcastFlag broadcast_flag = BroadcastFlag::POINT_TO_POINT;

  for (uint16_t i = 0; i < num_packets; i++) {

    auto acl_payload = std::make_unique<RawBuilder>();