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

Commit 1093dc8c authored by Henri Chataing's avatar Henri Chataing Committed by Automerger Merge Worker
Browse files

Merge "RootCanal: Simplify HciTransport interface" into main am: c3dcae45 

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



Change-Id: I72e45be965401da251e081ccf152c536663f5b8e
Signed-off-by: default avatarAutomerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
parents 421d91cc c3dcae45

tools/rootcanal/model/devices/hci_device.cc

+23 −15
Original line number Diff line number Diff line
@@ -54,30 +54,38 @@ HciDevice::HciDevice(std::shared_ptr<HciTransport> transport, 
  }));



  RegisterEventChannel([this](std::shared_ptr<std::vector<uint8_t>> packet) {

    transport_->SendEvent(*packet);

    transport_->Send(PacketType::EVENT, *packet);

  });

  RegisterAclChannel([this](std::shared_ptr<std::vector<uint8_t>> packet) {

    transport_->SendAcl(*packet);

    transport_->Send(PacketType::ACL, *packet);

  });

  RegisterScoChannel([this](std::shared_ptr<std::vector<uint8_t>> packet) {

    transport_->SendSco(*packet);

    transport_->Send(PacketType::SCO, *packet);

  });

  RegisterIsoChannel([this](std::shared_ptr<std::vector<uint8_t>> packet) {

    transport_->SendIso(*packet);

    transport_->Send(PacketType::ISO, *packet);

  });



  transport_->RegisterCallbacks(

      [this](const std::shared_ptr<std::vector<uint8_t>> command) {

        HandleCommand(command);

      },

      [this](const std::shared_ptr<std::vector<uint8_t>> acl) {

        HandleAcl(acl);

      },

      [this](const std::shared_ptr<std::vector<uint8_t>> sco) {

        HandleSco(sco);

      },

      [this](const std::shared_ptr<std::vector<uint8_t>> iso) {

        HandleIso(iso);

      [this](PacketType packet_type,

             const std::shared_ptr<std::vector<uint8_t>> packet) {

        switch (packet_type) {

          case PacketType::COMMAND:

            HandleCommand(packet);

            break;

          case PacketType::ACL:

            HandleAcl(packet);

            break;

          case PacketType::SCO:

            HandleSco(packet);

            break;

          case PacketType::ISO:

            HandleIso(packet);

            break;

          default:

            ASSERT(false);

            break;

        }

      },

      [this]() {

        INFO(id_, "HCI transport closed");

tools/rootcanal/model/hci/hci_sniffer.cc

+10 −41
Original line number Diff line number Diff line
@@ -73,32 +73,14 @@ void HciSniffer::AppendRecord(PacketDirection packet_direction, 
  output_->flush();

}



void HciSniffer::RegisterCallbacks(PacketCallback command_callback,

                                   PacketCallback acl_callback,

                                   PacketCallback sco_callback,

                                   PacketCallback iso_callback,

void HciSniffer::RegisterCallbacks(PacketCallback packet_callback,

                                   CloseCallback close_callback) {

  transport_->RegisterCallbacks(

      [this,

       command_callback](const std::shared_ptr<std::vector<uint8_t>> command) {

        AppendRecord(PacketDirection::HOST_TO_CONTROLLER, PacketType::COMMAND,

                     *command);

        command_callback(command);

      },

      [this, acl_callback](const std::shared_ptr<std::vector<uint8_t>> acl) {

        AppendRecord(PacketDirection::HOST_TO_CONTROLLER, PacketType::ACL,

                     *acl);

        acl_callback(acl);

      },

      [this, sco_callback](const std::shared_ptr<std::vector<uint8_t>> sco) {

        AppendRecord(PacketDirection::HOST_TO_CONTROLLER, PacketType::SCO,

                     *sco);

        sco_callback(sco);

      },

      [this, iso_callback](const std::shared_ptr<std::vector<uint8_t>> iso) {

        AppendRecord(PacketDirection::HOST_TO_CONTROLLER, PacketType::ISO,

                     *iso);

        iso_callback(iso);

      [this, packet_callback](

          PacketType packet_type,

          const std::shared_ptr<std::vector<uint8_t>> packet) {

        AppendRecord(PacketDirection::HOST_TO_CONTROLLER, packet_type, *packet);

        packet_callback(packet_type, packet);

      },

      close_callback);

}
@@ -112,23 +94,10 @@ void HciSniffer::Close() { 
  }

}



void HciSniffer::SendEvent(const std::vector<uint8_t>& packet) {

  AppendRecord(PacketDirection::CONTROLLER_TO_HOST, PacketType::EVENT, packet);

  transport_->SendEvent(packet);

}



void HciSniffer::SendAcl(const std::vector<uint8_t>& packet) {

  AppendRecord(PacketDirection::CONTROLLER_TO_HOST, PacketType::ACL, packet);

  transport_->SendAcl(packet);

}



void HciSniffer::SendSco(const std::vector<uint8_t>& packet) {

  AppendRecord(PacketDirection::CONTROLLER_TO_HOST, PacketType::SCO, packet);

  transport_->SendSco(packet);

void HciSniffer::Send(PacketType packet_type,

                      const std::vector<uint8_t>& packet) {

  AppendRecord(PacketDirection::CONTROLLER_TO_HOST, packet_type, packet);

  transport_->Send(packet_type, packet);

}



void HciSniffer::SendIso(const std::vector<uint8_t>& packet) {

  AppendRecord(PacketDirection::CONTROLLER_TO_HOST, PacketType::ISO, packet);

  transport_->SendIso(packet);

}

}  // namespace rootcanal

tools/rootcanal/model/hci/hci_sniffer.h

+3 −12
Original line number Diff line number Diff line
@@ -52,22 +52,13 @@ class HciSniffer : public HciTransport { 
  void SetOutputStream(std::shared_ptr<std::ostream> outputStream);

  void SetPcapFilter(std::shared_ptr<PcapFilter> filter);



  void SendEvent(const std::vector<uint8_t>& packet) override;

  void Send(PacketType packet_type,

            const std::vector<uint8_t>& packet) override;



  void SendAcl(const std::vector<uint8_t>& packet) override;



  void SendSco(const std::vector<uint8_t>& packet) override;



  void SendIso(const std::vector<uint8_t>& packet) override;



  void RegisterCallbacks(PacketCallback command_callback,

                         PacketCallback acl_callback,

                         PacketCallback sco_callback,

                         PacketCallback iso_callback,

  void RegisterCallbacks(PacketCallback packet_callback,

                         CloseCallback close_callback) override;



  void Tick() override;



  void Close() override;



 private:

tools/rootcanal/model/hci/hci_socket_transport.cc

+11 −30
Original line number Diff line number Diff line
@@ -23,43 +23,40 @@ namespace rootcanal { 
HciSocketTransport::HciSocketTransport(std::shared_ptr<AsyncDataChannel> socket)

    : socket_(socket) {}



void HciSocketTransport::RegisterCallbacks(PacketCallback command_callback,

                                           PacketCallback acl_callback,

                                           PacketCallback sco_callback,

                                           PacketCallback iso_callback,

void HciSocketTransport::RegisterCallbacks(PacketCallback packet_callback,

                                           CloseCallback close_callback) {

  // TODO: Avoid the copy here by using new buffer in H4DataChannel

  h4_ = H4DataChannelPacketizer(

      socket_,

      [command_callback](const std::vector<uint8_t>& raw_command) {

      [packet_callback](const std::vector<uint8_t>& raw_command) {

        std::shared_ptr<std::vector<uint8_t>> packet_copy =

            std::make_shared<std::vector<uint8_t>>(raw_command);

        command_callback(packet_copy);

        packet_callback(PacketType::COMMAND, packet_copy);

      },

      [](const std::vector<uint8_t>&) {

        FATAL("Unexpected Event in HciSocketTransport!");

      },

      [acl_callback](const std::vector<uint8_t>& raw_acl) {

      [packet_callback](const std::vector<uint8_t>& raw_acl) {

        std::shared_ptr<std::vector<uint8_t>> packet_copy =

            std::make_shared<std::vector<uint8_t>>(raw_acl);

        acl_callback(packet_copy);

        packet_callback(PacketType::ACL, packet_copy);

      },

      [sco_callback](const std::vector<uint8_t>& raw_sco) {

      [packet_callback](const std::vector<uint8_t>& raw_sco) {

        std::shared_ptr<std::vector<uint8_t>> packet_copy =

            std::make_shared<std::vector<uint8_t>>(raw_sco);

        sco_callback(packet_copy);

        packet_callback(PacketType::SCO, packet_copy);

      },

      [iso_callback](const std::vector<uint8_t>& raw_iso) {

      [packet_callback](const std::vector<uint8_t>& raw_iso) {

        std::shared_ptr<std::vector<uint8_t>> packet_copy =

            std::make_shared<std::vector<uint8_t>>(raw_iso);

        iso_callback(packet_copy);

        packet_callback(PacketType::ISO, packet_copy);

      },

      close_callback);

}



void HciSocketTransport::Tick() { h4_.OnDataReady(socket_); }



void HciSocketTransport::SendHci(PacketType packet_type,

void HciSocketTransport::Send(PacketType packet_type,

                              const std::vector<uint8_t>& packet) {

  if (!socket_ || !socket_->Connected()) {

    INFO("Closed socket. Dropping packet of type {}", packet_type);
@@ -69,22 +66,6 @@ void HciSocketTransport::SendHci(PacketType packet_type, 
  h4_.Send(type, packet.data(), packet.size());

}



void HciSocketTransport::SendEvent(const std::vector<uint8_t>& packet) {

  SendHci(PacketType::EVENT, packet);

}



void HciSocketTransport::SendAcl(const std::vector<uint8_t>& packet) {

  SendHci(PacketType::ACL, packet);

}



void HciSocketTransport::SendSco(const std::vector<uint8_t>& packet) {

  SendHci(PacketType::SCO, packet);

}



void HciSocketTransport::SendIso(const std::vector<uint8_t>& packet) {

  SendHci(PacketType::ISO, packet);

}



void HciSocketTransport::Close() { socket_->Close(); }



}  // namespace rootcanal

tools/rootcanal/model/hci/hci_socket_transport.h

+3 −14
Original line number Diff line number Diff line
@@ -36,27 +36,16 @@ class HciSocketTransport : public HciTransport { 
    return std::make_shared<HciSocketTransport>(socket);

  }



  void SendEvent(const std::vector<uint8_t>& packet) override;

  void Send(PacketType packet_type,

            const std::vector<uint8_t>& packet) override;



  void SendAcl(const std::vector<uint8_t>& packet) override;



  void SendSco(const std::vector<uint8_t>& packet) override;



  void SendIso(const std::vector<uint8_t>& packet) override;



  void RegisterCallbacks(PacketCallback command_callback,

                         PacketCallback acl_callback,

                         PacketCallback sco_callback,

                         PacketCallback iso_callback,

  void RegisterCallbacks(PacketCallback packet_callback,

                         CloseCallback close_callback) override;



  void Tick() override;



  void Close() override;



 private:

  void SendHci(PacketType packet_type, const std::vector<uint8_t>& packet);



  std::shared_ptr<AsyncDataChannel> socket_;

  H4DataChannelPacketizer h4_{socket_,

                              [](const std::vector<uint8_t>&) {},