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

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

Snap for 5900950 from c84e005b to rvc-release 

Change-Id: Iadb06b7da1886c87ea88ea952037db212feff527
parents 125d6b2b c84e005b

system/gd/Android.bp

+2 −0
Original line number Diff line number Diff line
@@ -310,10 +310,12 @@ genrule { 
    srcs: [

        "hci/hci_packets.pdl",

        "l2cap/l2cap_packets.pdl",

        "smp/smp_packets.pdl",

    ],

    out: [

        "hci/hci_packets.h",

        "l2cap/l2cap_packets.h",

        "smp/smp_packets.h",

    ],

}

system/gd/common/testing/wired_pair_of_bidi_queues.h

0 → 100644
+97 −0
Original line number Diff line number Diff line 
/******************************************************************************

 *

 *  Copyright 2019 The Android Open Source Project

 *

 *  Licensed under the Apache License, Version 2.0 (the "License");

 *  you may not use this file except in compliance with the License.

 *  You may obtain a copy of the License at:

 *

 *  http://www.apache.org/licenses/LICENSE-2.0

 *

 *  Unless required by applicable law or agreed to in writing, software

 *  distributed under the License is distributed on an "AS IS" BASIS,

 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 *  See the License for the specific language governing permissions and

 *  limitations under the License.

 *

 ******************************************************************************/



#pragma once



#include <memory>



#include "common/bidi_queue.h"

#include "os/handler.h"

#include "packet/base_packet_builder.h"

#include "packet/bit_inserter.h"

#include "packet/packet_view.h"



namespace bluetooth {

namespace common {

namespace testing {



/* This class is a pair of BiDiQueues, that have down ends "wired" together. It can be used i.e. to mock L2cap

 * interface, and provide two queues, where each sends packets of type A, and receives packets of type B */

template <class A, class B, std::unique_ptr<B> (*A_TO_B)(std::unique_ptr<A>)>

class WiredPairOfBiDiQueues {

  void dequeue_callback_a() {

    auto down_thing = queue_a_.GetDownEnd()->TryDequeue();

    if (!down_thing) LOG_ERROR("Received dequeue, but no data ready...");



    down_buffer_b_.Enqueue(A_TO_B(std::move(down_thing)), handler_);

  }



  void dequeue_callback_b() {

    auto down_thing = queue_b_.GetDownEnd()->TryDequeue();

    if (!down_thing) LOG_ERROR("Received dequeue, but no data ready...");



    down_buffer_a_.Enqueue(A_TO_B(std::move(down_thing)), handler_);

  }



  os::Handler* handler_;

  common::BidiQueue<B, A> queue_a_{10};

  common::BidiQueue<B, A> queue_b_{10};

  os::EnqueueBuffer<B> down_buffer_a_{queue_a_.GetDownEnd()};

  os::EnqueueBuffer<B> down_buffer_b_{queue_b_.GetDownEnd()};



 public:

  WiredPairOfBiDiQueues(os::Handler* handler) : handler_(handler) {

    queue_a_.GetDownEnd()->RegisterDequeue(

        handler_, common::Bind(&WiredPairOfBiDiQueues::dequeue_callback_a, common::Unretained(this)));

    queue_b_.GetDownEnd()->RegisterDequeue(

        handler_, common::Bind(&WiredPairOfBiDiQueues::dequeue_callback_b, common::Unretained(this)));

  }



  ~WiredPairOfBiDiQueues() {

    queue_a_.GetDownEnd()->UnregisterDequeue();

    queue_b_.GetDownEnd()->UnregisterDequeue();

  }



  /* This methd returns the UpEnd of queue A */

  common::BidiQueueEnd<A, B>* GetQueueAUpEnd() {

    return queue_a_.GetUpEnd();

  }



  /* This methd returns the UpEnd of queue B */

  common::BidiQueueEnd<A, B>* GetQueueBUpEnd() {

    return queue_b_.GetUpEnd();

  }

};



namespace {

std::unique_ptr<packet::PacketView<packet::kLittleEndian>> BuilderToView(

    std::unique_ptr<packet::BasePacketBuilder> up_thing) {

  auto bytes = std::make_shared<std::vector<uint8_t>>();

  bluetooth::packet::BitInserter i(*bytes);

  bytes->reserve(up_thing->size());

  up_thing->Serialize(i);

  return std::make_unique<packet::PacketView<packet::kLittleEndian>>(bytes);

}

}  // namespace



using WiredPairOfL2capQueues =

    WiredPairOfBiDiQueues<packet::BasePacketBuilder, packet::PacketView<packet::kLittleEndian>, BuilderToView>;



}  // namespace testing

}  // namespace common

}  // namespace bluetooth

system/gd/hci/acl_manager.cc

+1011 −0

File changed.

Preview size limit exceeded, changes collapsed.

system/gd/hci/acl_manager.h

+77 −0
Original line number Diff line number Diff line
@@ -31,6 +31,53 @@ namespace hci { 


class AclManager;



class ConnectionManagementCallbacks {

 public:

  virtual ~ConnectionManagementCallbacks() = default;

  // Invoked when controller sends Connection Packet Type Changed event with Success error code

  virtual void OnConnectionPacketTypeChanged(uint16_t packet_type) = 0;

  // Invoked when controller sends Authentication Complete event with Success error code

  virtual void OnAuthenticationComplete() = 0;

  // Invoked when controller sends Encryption Change event with Success error code

  virtual void OnEncryptionChange(EncryptionEnabled enabled) = 0;

  // Invoked when controller sends Change Connection Link Key Complete event with Success error code

  virtual void OnChangeConnectionLinkKeyComplete() = 0;

  // Invoked when controller sends Read Clock Offset Complete event with Success error code

  virtual void OnReadClockOffsetComplete() = 0;

  // Invoked when controller sends Mode Change event with Success error code

  virtual void OnModeChange(Mode current_mode, uint16_t interval) = 0;

  // Invoked when controller sends QoS Setup Complete event with Success error code

  virtual void OnQosSetupComplete(ServiceType service_type, uint32_t token_rate, uint32_t peak_bandwidth,

                                  uint32_t latency, uint32_t delay_variation) = 0;

  // Invoked when controller sends Flow Specification Complete event with Success error code

  virtual void OnFlowSpecificationComplete(FlowDirection flow_direction, ServiceType service_type, uint32_t token_rate,

                                           uint32_t token_bucket_size, uint32_t peak_bandwidth,

                                           uint32_t access_latency) = 0;

  // Invoked when controller sends Flush Occurred event

  virtual void OnFlushOccurred() = 0;

  // Invoked when controller sends Command Complete event for Role Discovery command with Success error code

  virtual void OnRoleDiscoveryComplete(Role current_role) = 0;

  // Invoked when controller sends Command Complete event for Read Link Policy Settings command with Success error code

  virtual void OnReadLinkPolicySettingsComplete(uint16_t link_policy_settings) = 0;

  // Invoked when controller sends Command Complete event for Read Automatic Flush Timeout command with Success error

  // code

  virtual void OnReadAutomaticFlushTimeoutComplete(uint16_t flush_timeout) = 0;

  // Invoked when controller sends Command Complete event for Read Transmit Power Level command with Success error code

  virtual void OnReadTransmitPowerLevelComplete(uint8_t transmit_power_level) = 0;

  // Invoked when controller sends Command Complete event for Read Link Supervision Time out command with Success error

  // code

  virtual void OnReadLinkSupervisionTimeoutComplete(uint16_t link_supervision_timeout) = 0;

  // Invoked when controller sends Command Complete event for Read Failed Contact Counter command with Success error

  // code

  virtual void OnReadFailedContactCounterComplete(uint16_t failed_contact_counter) = 0;

  // Invoked when controller sends Command Complete event for Read Link Quality command with Success error code

  virtual void OnReadLinkQualityComplete(uint8_t link_quality) = 0;

  // Invoked when controller sends Command Complete event for Read RSSI command with Success error code

  virtual void OnReadRssiComplete(uint8_t rssi) = 0;

  // Invoked when controller sends Command Complete event for Read Clock command with Success error code

  virtual void OnReadClockComplete(uint32_t clock, uint16_t accuracy) = 0;

};



class AclConnection {

 public:

  AclConnection() : manager_(nullptr), handle_(0), address_(Address::kEmpty){};
@@ -48,8 +95,38 @@ class AclConnection { 
  using QueueUpEnd = common::BidiQueueEnd<BasePacketBuilder, PacketView<kLittleEndian>>;

  using QueueDownEnd = common::BidiQueueEnd<PacketView<kLittleEndian>, BasePacketBuilder>;

  virtual QueueUpEnd* GetAclQueueEnd() const;

  virtual void RegisterCallbacks(ConnectionManagementCallbacks* callbacks, os::Handler* handler);

  virtual void RegisterDisconnectCallback(common::OnceCallback<void(ErrorCode)> on_disconnect, os::Handler* handler);

  virtual bool Disconnect(DisconnectReason reason);

  virtual bool ChangeConnectionPacketType(uint16_t packet_type);

  virtual bool AuthenticationRequested();

  virtual bool SetConnectionEncryption(Enable enable);

  virtual bool ChangeConnectionLinkKey();

  virtual bool ReadClockOffset();

  virtual bool HoldMode(uint16_t max_interval, uint16_t min_interval);

  virtual bool SniffMode(uint16_t max_interval, uint16_t min_interval, uint16_t attempt, uint16_t timeout);

  virtual bool ExitSniffMode();

  virtual bool QosSetup(ServiceType service_type, uint32_t token_rate, uint32_t peak_bandwidth, uint32_t latency,

                        uint32_t delay_variation);

  virtual bool RoleDiscovery();

  virtual bool ReadLinkPolicySettings();

  virtual bool WriteLinkPolicySettings(uint16_t link_policy_settings);

  virtual bool FlowSpecification(FlowDirection flow_direction, ServiceType service_type, uint32_t token_rate,

                                 uint32_t token_bucket_size, uint32_t peak_bandwidth, uint32_t access_latency);

  virtual bool SniffSubrating(uint16_t maximum_latency, uint16_t minimum_remote_timeout,

                              uint16_t minimum_local_timeout);

  virtual bool Flush();

  virtual bool ReadAutomaticFlushTimeout();

  virtual bool WriteAutomaticFlushTimeout(uint16_t flush_timeout);

  virtual bool ReadTransmitPowerLevel(TransmitPowerLevelType type);

  virtual bool ReadLinkSupervisionTimeout();

  virtual bool WriteLinkSupervisionTimeout(uint16_t link_supervision_timeout);

  virtual bool ReadFailedContactCounter();

  virtual bool ResetFailedContactCounter();

  virtual bool ReadLinkQuality();

  virtual bool ReadRssi();

  virtual bool ReadClock(WhichClock which_clock);



  // Ask AclManager to clean me up. Must invoke after on_disconnect is called

  virtual void Finish();

system/gd/hci/cert/cert.cc

+13 −0
Original line number Diff line number Diff line
@@ -58,6 +58,13 @@ class AclManagerCertService : public AclManagerCert::Service { 
    hci_layer_->RegisterEventHandler(EventCode::CONNECTION_REQUEST,

                                     Bind(&AclManagerCertService::on_incoming_connection, common::Unretained(this)),

                                     handler_);

    hci_layer_->RegisterEventHandler(

        EventCode::CONNECTION_PACKET_TYPE_CHANGED,

        Bind(&AclManagerCertService::on_connection_packet_type_changed, common::Unretained(this)), handler_);

    hci_layer_->RegisterEventHandler(EventCode::QOS_SETUP_COMPLETE,

                                     Bind(&AclManagerCertService::on_qos_setup_complete, common::Unretained(this)),

                                     handler_);



    controller_->RegisterCompletedAclPacketsCallback(common::Bind([](uint16_t, uint16_t) { /* TODO check */ }),

                                                     handler_);

    acl_queue_end_->RegisterDequeue(handler_,
@@ -139,6 +146,12 @@ class AclManagerCertService : public AclManagerCert::Service { 
    }

  }



  void on_connection_packet_type_changed(EventPacketView packet) { /*TODO*/

  }



  void on_qos_setup_complete(EventPacketView packet) { /*TODO*/

  }



  using EventStream = ::bluetooth::grpc::GrpcEventStream<AclData, AclPacketView>;



  ::grpc::Status SetPageScanMode(::grpc::ServerContext* context, const ::bluetooth::hci::cert::PageScanMode* request,