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

Commit 02767b1e authored by David Duarte's avatar David Duarte Committed by Automerger Merge Worker
Browse files

Merge "RootCanal: Split HciSocketDevice into HciDevice + HciSocketTransport" am: dc549a84 

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



Change-Id: If12dc116010948bedc9bbac47ce0f92175203bf6
Signed-off-by: default avatarAutomerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
parents d1877938 dc549a84

system/test/rootcanal/bluetooth_hci.cc

+6 −3
Original line number Diff line number Diff line
@@ -25,8 +25,9 @@ 


#include "hci_internals.h"

#include "log/log.h"

#include "model/devices/hci_socket_device.h"

#include "model/devices/hci_device.h"

#include "model/devices/link_layer_socket_device.h"

#include "model/hci/hci_socket_transport.h"



namespace android {

namespace hardware {
@@ -37,7 +38,8 @@ namespace sim { 
using android::hardware::hidl_vec;

using rootcanal::AsyncTaskId;

using rootcanal::DualModeController;

using rootcanal::HciSocketDevice;

using rootcanal::HciDevice;

using rootcanal::HciSocketTransport;

using rootcanal::LinkLayerSocketDevice;

using rootcanal::TaskCallback;
@@ -205,7 +207,8 @@ Return<void> BluetoothHci::initialize_impl( 
    SetUpTestChannel();

    SetUpHciServer([this](std::shared_ptr<AsyncDataChannel> socket,

                          AsyncDataChannelServer* srv) {

      test_model_.AddHciConnection(HciSocketDevice::Create(socket, ""));

      auto transport = HciSocketTransport::Create(socket);

      test_model_.AddHciConnection(HciDevice::Create(transport, ""));

      srv->StartListening();

    });

    SetUpLinkLayerServer([this](std::shared_ptr<AsyncDataChannel> socket,

tools/rootcanal/Android.bp

+9 −8
Original line number Diff line number Diff line
@@ -80,13 +80,14 @@ cc_library_static { 
        "model/controller/security_manager.cc",

        "model/devices/device.cc",

        "model/devices/device_properties.cc",

        "model/devices/h4_data_channel_packetizer.cc",

        "model/devices/h4_packetizer.cc",

        "model/devices/h4_parser.cc",

        "model/devices/hci_protocol.cc",

        "model/devices/hci_socket_device.cc",

        "model/devices/hci_device.cc",

        "model/devices/link_layer_socket_device.cc",

        "model/devices/remote_loopback_device.cc",

        "model/hci/h4_data_channel_packetizer.cc",

        "model/hci/h4_packetizer.cc",

        "model/hci/h4_parser.cc",

        "model/hci/hci_protocol.cc",

        "model/hci/hci_socket_transport.cc",

        "model/setup/async_manager.cc",

        "model/setup/phy_layer_factory.cc",

        "model/setup/test_channel_transport.cc",
@@ -230,9 +231,9 @@ cc_library_static { 
        "gd_defaults",

    ],

    srcs: [

        "model/devices/h4_packetizer.cc",

        "model/devices/h4_parser.cc",

        "model/devices/hci_protocol.cc",

        "model/hci/h4_packetizer.cc",

        "model/hci/h4_parser.cc",

        "model/hci/hci_protocol.cc",

    ],



    local_include_dirs: [

tools/rootcanal/desktop/test_environment.cc

+5 −3
Original line number Diff line number Diff line
@@ -20,8 +20,8 @@ 
#include <utility>      // for move

#include <vector>       // for vector



#include "model/devices/hci_socket_device.h"         // for HciSocketDevice

#include "model/devices/link_layer_socket_device.h"  // for LinkLayerSocketDevice

#include "model/hci/hci_socket_transport.h"          // for HciSocketTransport

#include "net/async_data_channel.h"                  // for AsyncDataChannel

#include "net/async_data_channel_connector.h"  // for AsyncDataChannelConnector

#include "os/log.h"  // for LOG_INFO, LOG_ERROR, LOG_WARN
@@ -31,7 +31,8 @@ namespace bluetooth { 
namespace root_canal {



using rootcanal::AsyncTaskId;

using rootcanal::HciSocketDevice;

using rootcanal::HciDevice;

using rootcanal::HciSocketTransport;

using rootcanal::LinkLayerSocketDevice;

using rootcanal::TaskCallback;
@@ -57,8 +58,9 @@ void TestEnvironment::initialize(std::promise<void> barrier) { 
  SetUpTestChannel();

  SetUpHciServer([this](std::shared_ptr<AsyncDataChannel> socket,

                        AsyncDataChannelServer* srv) {

    auto transport = HciSocketTransport::Create(socket);

    test_model_.AddHciConnection(

        HciSocketDevice::Create(socket, controller_properties_file_));

        HciDevice::Create(transport, controller_properties_file_));

    srv->StartListening();

  });

  SetUpLinkLayerServer();

tools/rootcanal/model/devices/hci_socket_device.cc→tools/rootcanal/model/devices/hci_device.cc

+104 −0
Original line number Diff line number Diff line 
/*

 * Copyright 2018 The Android Open Source Project

 * Copyright 2022 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.
@@ -14,21 +14,15 @@ 
 * limitations under the License.

 */



#include "hci_socket_device.h"

#include "hci_device.h"



#include <chrono>       // for milliseconds

#include <type_traits>  // for remove_extent_t



#include "model/devices/device_properties.h"  // for DeviceProperties

#include "os/log.h"                           // for LOG_INFO, LOG_ALWAYS_FATAL



using std::vector;

#include "os/log.h"



namespace rootcanal {



HciSocketDevice::HciSocketDevice(std::shared_ptr<AsyncDataChannel> socket,

HciDevice::HciDevice(std::shared_ptr<HciTransport> transport,

                     const std::string& properties_filename)

    : DualModeController(properties_filename), socket_(socket) {

    : DualModeController(properties_filename), transport_(transport) {

  advertising_interval_ms_ = std::chrono::milliseconds(1000);



  page_scan_delay_ms_ = std::chrono::milliseconds(600);
@@ -36,7 +30,7 @@ HciSocketDevice::HciSocketDevice(std::shared_ptr<AsyncDataChannel> socket, 
  properties_.SetPageScanRepetitionMode(0);

  properties_.SetClassOfDevice(0x600420);

  properties_.SetExtendedInquiryData({

      16,  // length

      12,  // length

      9,   // Type: Device Name

      'g',

      'D',
@@ -49,10 +43,7 @@ HciSocketDevice::HciSocketDevice(std::shared_ptr<AsyncDataChannel> socket, 
      'h',

      'c',

      'i',

      '_',

      'n',

      'e',

      't',



  });

  properties_.SetName({

      'g',
@@ -66,77 +57,47 @@ HciSocketDevice::HciSocketDevice(std::shared_ptr<AsyncDataChannel> socket, 
      'H',

      'C',

      'I',

      '_',

      'N',

      'e',

      't',

  });



  h4_ = H4DataChannelPacketizer(

      socket,

      [this](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);

        HandleCommand(packet_copy);

      },

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

        LOG_ALWAYS_FATAL("Unexpected Event in HciSocketDevice!");

      },

      [this](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);

        HandleAcl(packet_copy);

      },

      [this](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);

        HandleSco(packet_copy);

      },

      [this](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);

        HandleIso(packet_copy);

      },

      [this]() {

        LOG_INFO("HCI socket device disconnected");

        Close();

  });



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

    SendHci(PacketType::EVENT, packet);

    transport_->SendEvent(*packet);

  });

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

    SendHci(PacketType::ACL, packet);

    transport_->SendAcl(*packet);

  });

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

    SendHci(PacketType::SCO, packet);

    transport_->SendSco(*packet);

  });

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

    SendHci(PacketType::ISO, packet);

    transport_->SendIso(*packet);

  });

}



void HciSocketDevice::TimerTick() {

  h4_.OnDataReady(socket_);

  DualModeController::TimerTick();

  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]() {

        LOG_INFO("HCI transport closed");

        Close();

      });

}



void HciSocketDevice::SendHci(

    PacketType packet_type,

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

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

    LOG_INFO("Closed socket. Dropping packet of type %d",

             static_cast<int>(packet_type));

    return;

  }

  uint8_t type = static_cast<uint8_t>(packet_type);

  h4_.Send(type, packet->data(), packet->size());

void HciDevice::TimerTick() {

  transport_->TimerTick();

  DualModeController::TimerTick();

}



void HciSocketDevice::Close() {

  if (socket_) {

    socket_->Close();

  }

void HciDevice::Close() {

  transport_->Close();

  DualModeController::Close();

}

tools/rootcanal/model/devices/hci_device.h

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

 * Copyright 2022 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>  // for shared_ptr, make_...

#include <string>  // for string



#include "model/controller/dual_mode_controller.h"  // for DualModeController

#include "model/hci/hci_transport.h"                // for HciTransport



namespace rootcanal {



class HciDevice : public DualModeController {

 public:

  HciDevice(std::shared_ptr<HciTransport> transport,

            const std::string& properties_filename);

  ~HciDevice() = default;



  static std::shared_ptr<HciDevice> Create(

      std::shared_ptr<HciTransport> transport,

      const std::string& properties_filename) {

    return std::make_shared<HciDevice>(transport, properties_filename);

  }



  std::string GetTypeString() const override { return "hci_device"; }



  void TimerTick() override;



  void Close() override;



 private:

  std::shared_ptr<HciTransport> transport_;

};



}  // namespace rootcanal