RootCanal: Support LE 4.1 advertisingtemp_140451723

am: 99aea892f9

Change-Id: I4347c329a9a2986dd407d15fa0a64e77af63cb95

9 files changed, 134 insertions, 23 deletions

diff --git a/vendor_libs/test_vendor_lib/include/hci/op_code.h b/vendor_libs/test_vendor_lib/include/hci/op_code.h
index 931145d31..64f9947c3 100644
--- a/vendor_libs/test_vendor_lib/include/hci/op_code.h
+++ b/vendor_libs/test_vendor_lib/include/hci/op_code.h
@@ -193,7 +193,7 @@ enum class OpCode : uint16_t {
   LE_SET_ADVERTISING_PARAMETERS = LE_CONTROLLER | 0x0006,
   LE_READ_ADVERTISING_CHANNEL_TX_POWER = LE_CONTROLLER | 0x0007,
   LE_SET_ADVERTISING_DATA = LE_CONTROLLER | 0x0008,
-  LE_SET_SCAN_RSPONSE_DATA = LE_CONTROLLER | 0x0009,
+  LE_SET_SCAN_RESPONSE_DATA = LE_CONTROLLER | 0x0009,
   LE_SET_ADVERTISING_ENABLE = LE_CONTROLLER | 0x000A,
   LE_SET_SCAN_PARAMETERS = LE_CONTROLLER | 0x000B,
   LE_SET_SCAN_ENABLE = LE_CONTROLLER | 0x000C,
diff --git a/vendor_libs/test_vendor_lib/model/controller/dual_mode_controller.cc b/vendor_libs/test_vendor_lib/model/controller/dual_mode_controller.cc
index 7a2374f15..facf67a30 100644
--- a/vendor_libs/test_vendor_lib/model/controller/dual_mode_controller.cc
+++ b/vendor_libs/test_vendor_lib/model/controller/dual_mode_controller.cc
@@ -198,8 +198,10 @@ DualModeController::DualModeController(const std::string& properties_filename, u
   SET_HANDLER(OpCode::LE_READ_BUFFER_SIZE, HciLeReadBufferSize);
   SET_HANDLER(OpCode::LE_READ_LOCAL_SUPPORTED_FEATURES, HciLeReadLocalSupportedFeatures);
   SET_HANDLER(OpCode::LE_SET_RANDOM_ADDRESS, HciLeSetRandomAddress);
-  SET_HANDLER(OpCode::LE_SET_ADVERTISING_DATA, HciLeSetAdvertisingData);
   SET_HANDLER(OpCode::LE_SET_ADVERTISING_PARAMETERS, HciLeSetAdvertisingParameters);
+  SET_HANDLER(OpCode::LE_SET_ADVERTISING_DATA, HciLeSetAdvertisingData);
+  SET_HANDLER(OpCode::LE_SET_SCAN_RESPONSE_DATA, HciLeSetScanResponseData);
+  SET_HANDLER(OpCode::LE_SET_ADVERTISING_ENABLE, HciLeSetAdvertisingEnable);
   SET_HANDLER(OpCode::LE_SET_SCAN_PARAMETERS, HciLeSetScanParameters);
   SET_HANDLER(OpCode::LE_SET_SCAN_ENABLE, HciLeSetScanEnable);
   SET_HANDLER(OpCode::LE_CREATE_CONNECTION, HciLeCreateConnection);
@@ -287,7 +289,8 @@ void DualModeController::HandleCommand(std::shared_ptr<std::vector<uint8_t>> pac
     active_hci_commands_[opcode](command_packet.GetPayload());
   } else {
     SendCommandCompleteUnknownOpCodeEvent(opcode);
-    LOG_INFO(LOG_TAG, "Command opcode: 0x%04X, OGF: 0x%04X, OCF: 0x%04X", opcode, opcode & 0xFC00, opcode & 0x03FF);
+    LOG_INFO(LOG_TAG, "Command opcode: 0x%04X, OGF: 0x%04X, OCF: 0x%04X", opcode, (opcode & 0xFC00) >> 10,
+             opcode & 0x03FF);
   }
 }
 
@@ -817,15 +820,36 @@ void DualModeController::HciLeSetRandomAddress(packets::PacketView<true> args) {
 
 void DualModeController::HciLeSetAdvertisingParameters(packets::PacketView<true> args) {
   CHECK(args.size() == 15) << __func__ << " size=" << args.size();
+  auto args_itr = args.begin();
+  properties_.SetLeAdvertisingParameters(
+      args_itr.extract<uint16_t>() /* AdverisingIntervalMin */,
+      args_itr.extract<uint16_t>() /* AdverisingIntervalMax */, args_itr.extract<uint8_t>() /* AdverisingType */,
+      args_itr.extract<uint8_t>() /* OwnAddressType */, args_itr.extract<uint8_t>() /* PeerAddressType */,
+      args_itr.extract<Address>() /* PeerAddress */, args_itr.extract<uint8_t>() /* AdvertisingChannelMap */,
+      args_itr.extract<uint8_t>() /* AdvertisingFilterPolicy */
+  );
 
   SendCommandCompleteSuccess(OpCode::LE_SET_ADVERTISING_PARAMETERS);
 }
 
 void DualModeController::HciLeSetAdvertisingData(packets::PacketView<true> args) {
-  CHECK(args.size() > 0);
+  CHECK(args.size() == 32) << __func__ << " size=" << args.size();
+  properties_.SetLeAdvertisement(std::vector<uint8_t>(args.begin() + 1, args.end()));
   SendCommandCompleteSuccess(OpCode::LE_SET_ADVERTISING_DATA);
 }
 
+void DualModeController::HciLeSetScanResponseData(packets::PacketView<true> args) {
+  CHECK(args.size() == 32) << __func__ << " size=" << args.size();
+  properties_.SetLeScanResponse(std::vector<uint8_t>(args.begin() + 1, args.end()));
+  SendCommandCompleteSuccess(OpCode::LE_SET_SCAN_RESPONSE_DATA);
+}
+
+void DualModeController::HciLeSetAdvertisingEnable(packets::PacketView<true> args) {
+  CHECK(args.size() == 1) << __func__ << " size=" << args.size();
+  hci::Status status = link_layer_controller_.SetLeAdvertisingEnable(args.begin().extract<uint8_t>());
+  SendCommandCompleteOnlyStatus(OpCode::LE_SET_ADVERTISING_ENABLE, status);
+}
+
 void DualModeController::HciLeSetScanParameters(packets::PacketView<true> args) {
   CHECK(args.size() == 7) << __func__ << " size=" << args.size();
   link_layer_controller_.SetLeScanType(args[0]);
diff --git a/vendor_libs/test_vendor_lib/model/controller/dual_mode_controller.h b/vendor_libs/test_vendor_lib/model/controller/dual_mode_controller.h
index dfe3696af..8c531143d 100644
--- a/vendor_libs/test_vendor_lib/model/controller/dual_mode_controller.h
+++ b/vendor_libs/test_vendor_lib/model/controller/dual_mode_controller.h
@@ -307,6 +307,12 @@ class DualModeController : public Device {
   // 7.8.7
   void HciLeSetAdvertisingData(packets::PacketView<true> args);
 
+  // 7.8.8
+  void HciLeSetScanResponseData(packets::PacketView<true> args);
+
+  // 7.8.9
+  void HciLeSetAdvertisingEnable(packets::PacketView<true> args);
+
   // 7.8.10
   void HciLeSetScanParameters(packets::PacketView<true> args);
 
diff --git a/vendor_libs/test_vendor_lib/model/controller/link_layer_controller.cc b/vendor_libs/test_vendor_lib/model/controller/link_layer_controller.cc
index ecb5d4a61..65b1e7e4c 100644
--- a/vendor_libs/test_vendor_lib/model/controller/link_layer_controller.cc
+++ b/vendor_libs/test_vendor_lib/model/controller/link_layer_controller.cc
@@ -55,7 +55,7 @@ static uint8_t GetRssi() {
   return -(rssi);
 }
 
-void LinkLayerController::SendLELinkLayerPacket(std::shared_ptr<LinkLayerPacketBuilder> packet) {
+void LinkLayerController::SendLeLinkLayerPacket(std::shared_ptr<LinkLayerPacketBuilder> packet) {
   if (schedule_task_) {
     schedule_task_(milliseconds(50), [this, packet]() { send_to_remote_(packet, Phy::Type::LOW_ENERGY); });
   } else {
@@ -523,7 +523,7 @@ void LinkLayerController::IncomingLeAdvertisementPacket(LinkLayerPacketView inco
   if (le_scan_enable_ && le_scan_type_ == 1) {
     std::shared_ptr<LinkLayerPacketBuilder> to_send =
         LinkLayerPacketBuilder::WrapLeScan(properties_.GetLeAddress(), incoming.GetSourceAddress());
-    SendLELinkLayerPacket(to_send);
+    SendLeLinkLayerPacket(to_send);
   }
 }
 
@@ -535,7 +535,7 @@ void LinkLayerController::IncomingLeScanPacket(LinkLayerPacketView incoming) {
       properties_.GetLeScanResponse());
   std::shared_ptr<LinkLayerPacketBuilder> to_send = LinkLayerPacketBuilder::WrapLeScanResponse(
       std::move(response), properties_.GetLeAddress(), incoming.GetSourceAddress());
-  SendLELinkLayerPacket(to_send);
+  SendLeLinkLayerPacket(to_send);
 }
 
 void LinkLayerController::IncomingLeScanResponsePacket(LinkLayerPacketView incoming) {
@@ -649,9 +649,40 @@ void LinkLayerController::IncomingResponsePacket(LinkLayerPacketView incoming) {
 void LinkLayerController::TimerTick() {
   if (inquiry_state_ == Inquiry::InquiryState::INQUIRY) Inquiry();
   if (inquiry_state_ == Inquiry::InquiryState::INQUIRY) PageScan();
+  LeAdvertising();
   Connections();
 }
 
+void LinkLayerController::LeAdvertising() {
+  if (!le_advertising_enable_) {
+    return;
+  }
+  steady_clock::time_point now = steady_clock::now();
+  if (duration_cast<milliseconds>(now - last_le_advertisement_) < milliseconds(200)) {
+    return;
+  }
+
+  LeAdvertisement::AddressType own_address_type =
+      static_cast<LeAdvertisement::AddressType>(properties_.GetLeAdvertisingOwnAddressType());
+  std::shared_ptr<packets::LinkLayerPacketBuilder> to_send;
+  std::unique_ptr<packets::LeAdvertisementBuilder> ad;
+  if (own_address_type == LeAdvertisement::AddressType::PUBLIC) {
+    ad = packets::LeAdvertisementBuilder::Create(
+        LeAdvertisement::AddressType::PUBLIC,
+        static_cast<LeAdvertisement::AdvertisementType>(properties_.GetLeAdvertisementType()),
+        properties_.GetLeAdvertisement());
+    to_send = packets::LinkLayerPacketBuilder::WrapLeAdvertisement(std::move(ad), properties_.GetAddress());
+  } else if (own_address_type == LeAdvertisement::AddressType::RANDOM) {
+    ad = packets::LeAdvertisementBuilder::Create(
+        LeAdvertisement::AddressType::RANDOM,
+        static_cast<LeAdvertisement::AdvertisementType>(properties_.GetLeAdvertisementType()),
+        properties_.GetLeAdvertisement());
+    to_send = packets::LinkLayerPacketBuilder::WrapLeAdvertisement(std::move(ad), properties_.GetLeAddress());
+  }
+  CHECK(to_send != nullptr);
+  SendLeLinkLayerPacket(to_send);
+}
+
 void LinkLayerController::Connections() {
   // TODO: Keep connections alive?
 }
diff --git a/vendor_libs/test_vendor_lib/model/controller/link_layer_controller.h b/vendor_libs/test_vendor_lib/model/controller/link_layer_controller.h
index 382889179..5e0954d03 100644
--- a/vendor_libs/test_vendor_lib/model/controller/link_layer_controller.h
+++ b/vendor_libs/test_vendor_lib/model/controller/link_layer_controller.h
@@ -104,12 +104,20 @@ class LinkLayerController {
   void PageScan();
   void Connections();
 
+  void LeAdvertising();
+
   void LeWhiteListClear();
   void LeWhiteListAddDevice(Address addr, uint8_t addr_type);
   void LeWhiteListRemoveDevice(Address addr, uint8_t addr_type);
   bool LeWhiteListContainsDevice(Address addr, uint8_t addr_type);
   bool LeWhiteListFull();
 
+  hci::Status SetLeAdvertisingEnable(uint8_t le_advertising_enable) {
+    le_advertising_enable_ = le_advertising_enable;
+    // TODO: Check properties and return errors
+    return hci::Status::SUCCESS;
+  }
+
   void SetLeScanEnable(uint8_t le_scan_enable) {
     le_scan_enable_ = le_scan_enable;
   }
@@ -180,7 +188,7 @@ class LinkLayerController {
   hci::Status WriteLinkSupervisionTimeout(uint16_t handle, uint16_t timeout);
 
  protected:
-  void SendLELinkLayerPacket(std::shared_ptr<packets::LinkLayerPacketBuilder> packet);
+  void SendLeLinkLayerPacket(std::shared_ptr<packets::LinkLayerPacketBuilder> packet);
   void SendLinkLayerPacket(std::shared_ptr<packets::LinkLayerPacketBuilder> packet);
   void IncomingAclPacket(packets::LinkLayerPacketView packet);
   void IncomingAclAckPacket(packets::LinkLayerPacketView packet);
@@ -232,7 +240,10 @@ class LinkLayerController {
 
   std::vector<std::tuple<Address, uint8_t>> le_white_list_;
 
-  uint8_t le_scan_enable_;
+  uint8_t le_advertising_enable_{false};
+  std::chrono::steady_clock::time_point last_le_advertisement_;
+
+  uint8_t le_scan_enable_{false};
   uint8_t le_scan_type_;
   uint16_t le_scan_interval_;
   uint16_t le_scan_window_;
diff --git a/vendor_libs/test_vendor_lib/model/devices/device_properties.h b/vendor_libs/test_vendor_lib/model/devices/device_properties.h
index 69605536f..710236b73 100644
--- a/vendor_libs/test_vendor_lib/model/devices/device_properties.h
+++ b/vendor_libs/test_vendor_lib/model/devices/device_properties.h
@@ -190,6 +190,47 @@ class DeviceProperties {
     return le_advertisement_type_;
   }
 
+  uint16_t GetLeAdvertisingIntervalMin() const {
+    return le_advertising_interval_min_;
+  }
+
+  uint16_t GetLeAdvertisingIntervalMax() const {
+    return le_advertising_interval_max_;
+  }
+
+  uint8_t GetLeAdvertisingOwnAddressType() const {
+    return le_advertising_own_address_type_;
+  }
+
+  uint8_t GetLeAdvertisingPeerAddressType() const {
+    return le_advertising_peer_address_type_;
+  }
+
+  Address GetLeAdvertisingPeerAddress() const {
+    return le_advertising_peer_address_;
+  }
+
+  uint8_t GetLeAdvertisingChannelMap() const {
+    return le_advertising_channel_map_;
+  }
+
+  uint8_t GetLeAdvertisingFilterPolicy() const {
+    return le_advertising_filter_policy_;
+  }
+
+  void SetLeAdvertisingParameters(uint16_t interval_min, uint16_t interval_max, uint8_t ad_type,
+                                  uint8_t own_address_type, uint8_t peer_address_type, Address peer_address,
+                                  uint8_t channel_map, uint8_t filter_policy) {
+    le_advertisement_type_ = ad_type;
+    le_advertising_interval_min_ = interval_min;
+    le_advertising_interval_max_ = interval_max;
+    le_advertising_own_address_type_ = own_address_type;
+    le_advertising_peer_address_type_ = peer_address_type;
+    le_advertising_peer_address_ = peer_address;
+    le_advertising_channel_map_ = channel_map;
+    le_advertising_filter_policy_ = filter_policy;
+  }
+
   void SetLeAdvertisementType(uint8_t ad_type) {
     le_advertisement_type_ = ad_type;
   }
@@ -278,6 +319,14 @@ class DeviceProperties {
   std::vector<uint8_t> le_vendor_cap_;
   Address le_address_;
   uint8_t le_address_type_;
+
+  uint16_t le_advertising_interval_min_;
+  uint16_t le_advertising_interval_max_;
+  uint8_t le_advertising_own_address_type_;
+  uint8_t le_advertising_peer_address_type_;
+  Address le_advertising_peer_address_;
+  uint8_t le_advertising_channel_map_;
+  uint8_t le_advertising_filter_policy_;
   uint8_t le_advertisement_type_;
   std::vector<uint8_t> le_advertisement_;
   std::vector<uint8_t> le_scan_response_;
diff --git a/vendor_libs/test_vendor_lib/model/devices/h4_packetizer.cc b/vendor_libs/test_vendor_lib/model/devices/h4_packetizer.cc
index 3c2cde490..07f2f2743 100644
--- a/vendor_libs/test_vendor_lib/model/devices/h4_packetizer.cc
+++ b/vendor_libs/test_vendor_lib/model/devices/h4_packetizer.cc
@@ -80,7 +80,6 @@ size_t H4Packetizer::Send(uint8_t type, const uint8_t* data, size_t length) {
 }
 
 void H4Packetizer::OnPacketReady() {
-  ALOGE("%s: before switch", __func__);
   switch (hci_packet_type_) {
     case hci::PacketType::COMMAND:
       command_cb_(packet_);
@@ -156,8 +155,6 @@ void H4Packetizer::OnDataReady(int fd) {
           size_t packet_length = HciGetPacketLengthForType(hci_packet_type_, preamble_);
           packet_.resize(preamble_bytes + packet_length);
           memcpy(packet_.data(), preamble_, preamble_bytes);
-          ALOGI("%s: Read a preamble of size %d length %d %0x %0x %0x", __func__, static_cast<int>(bytes_read_),
-                static_cast<int>(packet_length), preamble_[0], preamble_[1], preamble_[2]);
           bytes_remaining_ = packet_length;
           if (bytes_remaining_ == 0) {
             OnPacketReady();
diff --git a/vendor_libs/test_vendor_lib/model/devices/hci_socket_device.cc b/vendor_libs/test_vendor_lib/model/devices/hci_socket_device.cc
index 04029d1c9..d86dc41a1 100644
--- a/vendor_libs/test_vendor_lib/model/devices/hci_socket_device.cc
+++ b/vendor_libs/test_vendor_lib/model/devices/hci_socket_device.cc
@@ -31,7 +31,7 @@ using std::vector;
 namespace test_vendor_lib {
 
 HciSocketDevice::HciSocketDevice(int file_descriptor) : socket_file_descriptor_(file_descriptor) {
-  advertising_interval_ms_ = std::chrono::milliseconds(0);
+  advertising_interval_ms_ = std::chrono::milliseconds(1000);
 
   page_scan_delay_ms_ = std::chrono::milliseconds(600);
 
@@ -77,7 +77,6 @@ HciSocketDevice::HciSocketDevice(int file_descriptor) : socket_file_descriptor_(
   h4_ = hci::H4Packetizer(
       socket_file_descriptor_,
       [this](const std::vector<uint8_t>& raw_command) {
-        LOG_INFO(LOG_TAG, "Rx Command");
         std::shared_ptr<std::vector<uint8_t>> packet_copy = std::make_shared<std::vector<uint8_t>>(raw_command);
         HandleCommand(packet_copy);
       },
@@ -85,12 +84,10 @@ HciSocketDevice::HciSocketDevice(int file_descriptor) : socket_file_descriptor_(
         CHECK(false) << "Unexpected Event in HciSocketDevice!";
       },
       [this](const std::vector<uint8_t>& raw_acl) {
-        LOG_INFO(LOG_TAG, "Rx 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) {
-        LOG_INFO(LOG_TAG, "Rx SCO");
         std::shared_ptr<std::vector<uint8_t>> packet_copy = std::make_shared<std::vector<uint8_t>>(raw_sco);
         HandleSco(packet_copy);
       },
@@ -100,21 +97,17 @@ HciSocketDevice::HciSocketDevice(int file_descriptor) : socket_file_descriptor_(
       });
 
   RegisterEventChannel([this](std::shared_ptr<std::vector<uint8_t>> packet) {
-    LOG_INFO(LOG_TAG, "Tx Event");
     SendHci(hci::PacketType::EVENT, packet);
   });
   RegisterAclChannel([this](std::shared_ptr<std::vector<uint8_t>> packet) {
-    LOG_INFO(LOG_TAG, "Tx ACL");
     SendHci(hci::PacketType::ACL, packet);
   });
   RegisterScoChannel([this](std::shared_ptr<std::vector<uint8_t>> packet) {
-    LOG_INFO(LOG_TAG, "Tx SCO");
     SendHci(hci::PacketType::SCO, packet);
   });
 }
 
 void HciSocketDevice::TimerTick() {
-  LOG_INFO(LOG_TAG, "TimerTick fd = %d", socket_file_descriptor_);
   h4_.OnDataReady(socket_file_descriptor_);
   DualModeController::TimerTick();
 }
@@ -128,11 +121,11 @@ void HciSocketDevice::SendHci(hci::PacketType packet_type, const std::shared_ptr
   int bytes_written;
   bytes_written = write(socket_file_descriptor_, &type, sizeof(type));
   if (bytes_written != sizeof(type)) {
-    LOG_INFO(LOG_TAG, "bytes_written %d != sizeof(type)", bytes_written);
+    LOG_WARN(LOG_TAG, "bytes_written %d != sizeof(type)", bytes_written);
   }
   bytes_written = write(socket_file_descriptor_, packet->data(), packet->size());
   if (static_cast<size_t>(bytes_written) != packet->size()) {
-    LOG_INFO(LOG_TAG, "bytes_written %d != packet->size", bytes_written);
+    LOG_WARN(LOG_TAG, "bytes_written %d != packet->size", bytes_written);
   }
 }
 
diff --git a/vendor_libs/test_vendor_lib/scripts/simple_stack.py b/vendor_libs/test_vendor_lib/scripts/simple_stack.py
index 4f42bf2c6..95d973a2f 100644
--- a/vendor_libs/test_vendor_lib/scripts/simple_stack.py
+++ b/vendor_libs/test_vendor_lib/scripts/simple_stack.py
@@ -146,7 +146,7 @@ class RawPort(object):
 
   def receive_response(self):
     ready_to_read, ready_to_write, in_error = \
-               select.select(
+               select(
                   [ self._connection._socket ],
                   [ ],
                   [ self._connection._socket ],