android-10.0.0_r47/s

/*
 * Copyright 2018 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.
 */

#include "packets/hci/event_packet_builder.h"

#include <base/logging.h>
#include "hci.h"
#include "packets/hci/le_meta_event_builder.h"

using std::vector;
using test_vendor_lib::hci::EventCode;
using test_vendor_lib::hci::OpCode;
using test_vendor_lib::hci::Status;

namespace test_vendor_lib {
namespace packets {

EventPacketBuilder::EventPacketBuilder(EventCode event_code)
    : event_code_(event_code), payload_(std::make_unique<RawBuilder>()) {}

EventPacketBuilder::EventPacketBuilder(EventCode event_code, std::unique_ptr<RawBuilder> payload)
    : event_code_(event_code), payload_(std::move(payload)) {}

// Bluetooth Core Specification Version 4.2, Volume 2, Part E, Section 7.7.1
std::unique_ptr<EventPacketBuilder> EventPacketBuilder::CreateInquiryCompleteEvent(hci::Status status) {
  std::unique_ptr<EventPacketBuilder> evt_ptr =
      std::unique_ptr<EventPacketBuilder>(new EventPacketBuilder(EventCode::INQUIRY_COMPLETE));
  CHECK(evt_ptr->AddPayloadOctets1(static_cast<uint8_t>(status)));

  return evt_ptr;
}

// Bluetooth Core Specification Version 4.2, Volume 2, Part E, Section 7.7.14
std::unique_ptr<EventPacketBuilder> EventPacketBuilder::CreateCommandCompleteEvent(
    hci::OpCode command_opcode, const vector<uint8_t>& event_return_parameters) {
  std::unique_ptr<EventPacketBuilder> evt_ptr =
      std::unique_ptr<EventPacketBuilder>(new EventPacketBuilder(EventCode::COMMAND_COMPLETE));

  CHECK(evt_ptr->AddPayloadOctets1(1));  // num_hci_command_packets
  CHECK(evt_ptr->AddPayloadOctets2(static_cast<uint16_t>(command_opcode)));
  CHECK(evt_ptr->AddPayloadOctets(event_return_parameters));

  return evt_ptr;
}

std::unique_ptr<EventPacketBuilder> EventPacketBuilder::CreateCommandCompleteOnlyStatusEvent(hci::OpCode command_opcode,
                                                                                             hci::Status status) {
  std::unique_ptr<EventPacketBuilder> evt_ptr =
      std::unique_ptr<EventPacketBuilder>(new EventPacketBuilder(EventCode::COMMAND_COMPLETE));

  CHECK(evt_ptr->AddPayloadOctets1(1));  // num_hci_command_packets
  CHECK(evt_ptr->AddPayloadOctets2(static_cast<uint16_t>(command_opcode)));
  CHECK(evt_ptr->AddPayloadOctets1(static_cast<uint8_t>(status)));

  return evt_ptr;
}

std::unique_ptr<EventPacketBuilder> EventPacketBuilder::CreateCommandCompleteStatusAndAddressEvent(
    hci::OpCode command_opcode, hci::Status status, const Address& address) {
  std::unique_ptr<EventPacketBuilder> evt_ptr =
      std::unique_ptr<EventPacketBuilder>(new EventPacketBuilder(EventCode::COMMAND_COMPLETE));

  CHECK(evt_ptr->AddPayloadOctets1(1));  // num_hci_command_packets
  CHECK(evt_ptr->AddPayloadOctets2(static_cast<uint16_t>(command_opcode)));
  CHECK(evt_ptr->AddPayloadOctets1(static_cast<uint8_t>(status)));
  CHECK(evt_ptr->AddPayloadAddress(address));

  return evt_ptr;
}

std::unique_ptr<EventPacketBuilder> EventPacketBuilder::CreateCommandCompleteUnknownOpCodeEvent(
    uint16_t command_opcode) {
  std::unique_ptr<EventPacketBuilder> evt_ptr =
      std::unique_ptr<EventPacketBuilder>(new EventPacketBuilder(EventCode::COMMAND_COMPLETE));

  CHECK(evt_ptr->AddPayloadOctets1(1));  // num_hci_command_packets
  CHECK(evt_ptr->AddPayloadOctets2(static_cast<uint16_t>(command_opcode)));
  CHECK(evt_ptr->AddPayloadOctets1(static_cast<uint8_t>(Status::UNKNOWN_COMMAND)));

  return evt_ptr;
}

// Bluetooth Core Specification Version 4.2, Volume 2, Part E, Section 7.7.15
std::unique_ptr<EventPacketBuilder> EventPacketBuilder::CreateCommandStatusEvent(hci::Status status,
                                                                                 hci::OpCode command_opcode) {
  std::unique_ptr<EventPacketBuilder> evt_ptr =
      std::unique_ptr<EventPacketBuilder>(new EventPacketBuilder(EventCode::COMMAND_STATUS));

  CHECK(evt_ptr->AddPayloadOctets1(static_cast<uint8_t>(status)));
  CHECK(evt_ptr->AddPayloadOctets1(1));  // num_hci_command_packets
  CHECK(evt_ptr->AddPayloadOctets2(static_cast<uint16_t>(command_opcode)));

  return evt_ptr;
}

// Bluetooth Core Specification Version 4.2, Volume 2, Part E, Section 7.7.19
std::unique_ptr<EventPacketBuilder> EventPacketBuilder::CreateNumberOfCompletedPacketsEvent(
    uint16_t handle, uint16_t num_completed_packets) {
  std::unique_ptr<RawBuilder> payload = std::make_unique<CountedBuilder>();
  std::unique_ptr<EventPacketBuilder> evt_ptr = std::unique_ptr<EventPacketBuilder>(
      new EventPacketBuilder(EventCode::NUMBER_OF_COMPLETED_PACKETS, std::move(payload)));

  evt_ptr->AddCompletedPackets(handle, num_completed_packets);

  return evt_ptr;
}

void EventPacketBuilder::AddCompletedPackets(uint16_t handle, uint16_t num_completed_packets) {
  CHECK(event_code_ == EventCode::NUMBER_OF_COMPLETED_PACKETS);

  std::unique_ptr<RawBuilder> handle_pair = std::make_unique<RawBuilder>();
  CHECK(handle_pair->AddOctets2(handle));
  CHECK(handle_pair->AddOctets2(num_completed_packets));
  AddBuilder(std::move(handle_pair));
}

// Bluetooth Core Specification Version 4.2, Volume 2, Part E, Section 7.3.10
std::unique_ptr<EventPacketBuilder> EventPacketBuilder::CreateCommandCompleteDeleteStoredLinkKey(
    hci::Status status, uint16_t num_keys_deleted) {
  std::unique_ptr<EventPacketBuilder> evt_ptr =
      EventPacketBuilder::CreateCommandCompleteOnlyStatusEvent(OpCode::DELETE_STORED_LINK_KEY, status);

  CHECK(evt_ptr->AddPayloadOctets2(num_keys_deleted));

  return evt_ptr;
}

// Bluetooth Core Specification Version 4.2, Volume 2, Part E, Section 7.3.12
std::unique_ptr<EventPacketBuilder> EventPacketBuilder::CreateCommandCompleteReadLocalName(
    hci::Status status, const std::vector<uint8_t>& local_name) {
  std::unique_ptr<EventPacketBuilder> evt_ptr =
      EventPacketBuilder::CreateCommandCompleteOnlyStatusEvent(OpCode::READ_LOCAL_NAME, status);

  size_t len = local_name.size();
  if (len > 247) {
    len = 247;
  }
  CHECK(evt_ptr->AddPayloadOctets(len, local_name));
  CHECK(evt_ptr->AddPayloadOctets1(0));  // Null terminated
  for (size_t i = 0; i < 248 - len - 1; i++) CHECK(evt_ptr->AddPayloadOctets1(0xFF));

  return evt_ptr;
}

// Bluetooth Core Specification Version 4.2, Volume 2, Part E, Section 7.3.23
std::unique_ptr<EventPacketBuilder> EventPacketBuilder::CreateCommandCompleteReadAuthenticationEnable(
    hci::Status status, uint8_t enable) {
  std::unique_ptr<EventPacketBuilder> evt_ptr =
      EventPacketBuilder::CreateCommandCompleteOnlyStatusEvent(OpCode::READ_LOCAL_NAME, status);
  CHECK(evt_ptr->AddPayloadOctets1(enable));
  return evt_ptr;
}

// Bluetooth Core Specification Version 4.2, Volume 2, Part E, Section 7.4.1
std::unique_ptr<EventPacketBuilder> EventPacketBuilder::CreateCommandCompleteReadLocalVersionInformation(
    hci::Status status, uint8_t hci_version, uint16_t hci_revision, uint8_t lmp_pal_version, uint16_t manufacturer_name,
    uint16_t lmp_pal_subversion) {
  std::unique_ptr<EventPacketBuilder> evt_ptr =
      EventPacketBuilder::CreateCommandCompleteOnlyStatusEvent(OpCode::READ_LOCAL_VERSION_INFORMATION, status);

  CHECK(evt_ptr->AddPayloadOctets1(hci_version));
  CHECK(evt_ptr->AddPayloadOctets2(hci_revision));
  CHECK(evt_ptr->AddPayloadOctets1(lmp_pal_version));
  CHECK(evt_ptr->AddPayloadOctets2(manufacturer_name));
  CHECK(evt_ptr->AddPayloadOctets2(lmp_pal_subversion));

  return evt_ptr;
}

std::unique_ptr<EventPacketBuilder> EventPacketBuilder::CreateReadRemoteVersionInformationEvent(
    hci::Status status, uint16_t connection_handle, uint8_t lmp_pal_version, uint16_t manufacturer_name,
    uint16_t lmp_pal_subversion) {
  std::unique_ptr<EventPacketBuilder> evt_ptr =
      std::unique_ptr<EventPacketBuilder>(new EventPacketBuilder(EventCode::READ_REMOTE_VERSION_INFORMATION_COMPLETE));

  CHECK(evt_ptr->AddPayloadOctets1(static_cast<uint8_t>(status)));
  CHECK(evt_ptr->AddPayloadOctets2(connection_handle));
  CHECK(evt_ptr->AddPayloadOctets1(lmp_pal_version));
  CHECK(evt_ptr->AddPayloadOctets2(manufacturer_name));
  CHECK(evt_ptr->AddPayloadOctets2(lmp_pal_subversion));

  return evt_ptr;
}
// Bluetooth Core Specification Version 4.2, Volume 2, Part E, Section 7.4.2
std::unique_ptr<EventPacketBuilder> EventPacketBuilder::CreateCommandCompleteReadLocalSupportedCommands(
    hci::Status status, const vector<uint8_t>& supported_commands) {
  std::unique_ptr<EventPacketBuilder> evt_ptr =
      EventPacketBuilder::CreateCommandCompleteOnlyStatusEvent(OpCode::READ_LOCAL_SUPPORTED_COMMANDS, status);

  CHECK(evt_ptr->AddPayloadOctets(64, supported_commands));

  return evt_ptr;
}

// Bluetooth Core Specification Version 4.2, Volume 2, Part E, Section 7.4.4
std::unique_ptr<EventPacketBuilder> EventPacketBuilder::CreateCommandCompleteReadLocalExtendedFeatures(
    hci::Status status, uint8_t page_number, uint8_t maximum_page_number, uint64_t extended_lmp_features) {
  std::unique_ptr<EventPacketBuilder> evt_ptr =
      EventPacketBuilder::CreateCommandCompleteOnlyStatusEvent(OpCode::READ_LOCAL_EXTENDED_FEATURES, status);

  CHECK(evt_ptr->AddPayloadOctets1(page_number));
  CHECK(evt_ptr->AddPayloadOctets1(maximum_page_number));
  CHECK(evt_ptr->AddPayloadOctets8(extended_lmp_features));

  return evt_ptr;
}

std::unique_ptr<EventPacketBuilder> EventPacketBuilder::CreateReadRemoteExtendedFeaturesEvent(
    hci::Status status, uint16_t handle, uint8_t page_number, uint8_t maximum_page_number,
    uint64_t extended_lmp_features) {
  std::unique_ptr<EventPacketBuilder> evt_ptr =
      std::unique_ptr<EventPacketBuilder>(new EventPacketBuilder(EventCode::READ_REMOTE_EXTENDED_FEATURES_COMPLETE));

  CHECK(evt_ptr->AddPayloadOctets1(static_cast<uint8_t>(status)));
  CHECK(evt_ptr->AddPayloadOctets2(handle));
  CHECK(evt_ptr->AddPayloadOctets1(page_number));
  CHECK(evt_ptr->AddPayloadOctets1(maximum_page_number));
  CHECK(evt_ptr->AddPayloadOctets8(extended_lmp_features));

  return evt_ptr;
}

// Bluetooth Core Specification Version 4.2, Volume 2, Part E, Section 7.4.5
std::unique_ptr<EventPacketBuilder> EventPacketBuilder::CreateCommandCompleteReadBufferSize(
    hci::Status status, uint16_t hc_acl_data_packet_length, uint8_t hc_synchronous_data_packet_length,
    uint16_t hc_total_num_acl_data_packets, uint16_t hc_total_synchronous_data_packets) {
  std::unique_ptr<EventPacketBuilder> evt_ptr =
      EventPacketBuilder::CreateCommandCompleteOnlyStatusEvent(OpCode::READ_BUFFER_SIZE, status);

  CHECK(evt_ptr->AddPayloadOctets2(hc_acl_data_packet_length));
  CHECK(evt_ptr->AddPayloadOctets1(hc_synchronous_data_packet_length));
  CHECK(evt_ptr->AddPayloadOctets2(hc_total_num_acl_data_packets));
  CHECK(evt_ptr->AddPayloadOctets2(hc_total_synchronous_data_packets));

  return evt_ptr;
}

// Bluetooth Core Specification Version 4.2, Volume 2, Part E, Section 7.4.6
std::unique_ptr<EventPacketBuilder> EventPacketBuilder::CreateCommandCompleteReadBdAddr(hci::Status status,
                                                                                        const Address& address) {
  std::unique_ptr<EventPacketBuilder> evt_ptr =
      EventPacketBuilder::CreateCommandCompleteOnlyStatusEvent(OpCode::READ_BD_ADDR, status);

  CHECK(evt_ptr->AddPayloadAddress(address));

  return evt_ptr;
}

// Bluetooth Core Specification Version 4.2, Volume 2, Part E, Section 7.4.8
std::unique_ptr<EventPacketBuilder> EventPacketBuilder::CreateCommandCompleteReadLocalSupportedCodecs(
    hci::Status status, const vector<uint8_t>& supported_codecs, const vector<uint32_t>& vendor_specific_codecs) {
  std::unique_ptr<EventPacketBuilder> evt_ptr =
      EventPacketBuilder::CreateCommandCompleteOnlyStatusEvent(OpCode::READ_LOCAL_SUPPORTED_CODECS, status);

  CHECK(evt_ptr->AddPayloadOctets1(supported_codecs.size()));
  CHECK(evt_ptr->AddPayloadOctets(supported_codecs));
  CHECK(evt_ptr->AddPayloadOctets1(vendor_specific_codecs.size()));
  for (size_t i = 0; i < vendor_specific_codecs.size(); i++)
    CHECK(evt_ptr->AddPayloadOctets4(vendor_specific_codecs[i]));

  return evt_ptr;
}

// Bluetooth Core Specification Version 4.2, Volume 2, Part E, Section 7.6.1
std::unique_ptr<EventPacketBuilder> EventPacketBuilder::CreateCommandCompleteReadLoopbackMode(hci::Status status,
                                                                                              hci::LoopbackMode mode) {
  std::unique_ptr<EventPacketBuilder> evt_ptr =
      EventPacketBuilder::CreateCommandCompleteOnlyStatusEvent(OpCode::READ_LOOPBACK_MODE, status);
  CHECK(evt_ptr->AddPayloadOctets1(static_cast<uint8_t>(mode)));

  return evt_ptr;
}

// Bluetooth Core Specification Version 4.2, Volume 2, Part E, Section 7.7.2
std::unique_ptr<EventPacketBuilder> EventPacketBuilder::CreateInquiryResultEvent() {
  std::unique_ptr<RawBuilder> payload = std::unique_ptr<RawBuilder>(new CountedBuilder());
  std::unique_ptr<EventPacketBuilder> evt_ptr(new EventPacketBuilder(EventCode::INQUIRY_RESULT, std::move(payload)));

  return evt_ptr;
}

bool EventPacketBuilder::AddInquiryResult(const Address& address, uint8_t page_scan_repetition_mode,
                                          ClassOfDevice class_of_device, uint16_t clock_offset) {
  CHECK(event_code_ == EventCode::INQUIRY_RESULT);

  if (!CanAddPayloadOctets(14)) return false;

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

  CHECK(result->AddAddress(address));
  CHECK(result->AddOctets1(page_scan_repetition_mode));
  CHECK(result->AddOctets2(0));  // Reserved
  CHECK(result->AddOctets1(class_of_device.cod[0]));
  CHECK(result->AddOctets1(class_of_device.cod[1]));
  CHECK(result->AddOctets1(class_of_device.cod[2]));
  CHECK(!(clock_offset & 0x8000));
  CHECK(result->AddOctets2(clock_offset));
  AddBuilder(std::move(result));
  return true;
}

// Bluetooth Core Specification Version 4.2, Volume 2, Part E, Section 7.7.3
std::unique_ptr<EventPacketBuilder> EventPacketBuilder::CreateConnectionCompleteEvent(
    hci::Status status, uint16_t handle, const Address& address, hci::LinkType link_type, bool encryption_enabled) {
  std::unique_ptr<EventPacketBuilder> evt_ptr =
      std::unique_ptr<EventPacketBuilder>(new EventPacketBuilder(EventCode::CONNECTION_COMPLETE));

  CHECK(evt_ptr->AddPayloadOctets1(static_cast<uint8_t>(status)));
  CHECK((handle & 0xf000) == 0);  // Handles are 12-bit values.
  CHECK(evt_ptr->AddPayloadOctets2(handle));
  CHECK(evt_ptr->AddPayloadAddress(address));
  CHECK(evt_ptr->AddPayloadOctets1(static_cast<uint8_t>(link_type)));
  CHECK(evt_ptr->AddPayloadOctets1(encryption_enabled ? 1 : 0));

  return evt_ptr;
}

// Bluetooth Core Specification Version 4.2, Volume 2, Part E, Section 7.7.4
std::unique_ptr<EventPacketBuilder> EventPacketBuilder::CreateConnectionRequestEvent(const Address& address,
                                                                                     ClassOfDevice class_of_device,
                                                                                     hci::LinkType link_type) {
  std::unique_ptr<EventPacketBuilder> evt_ptr =
      std::unique_ptr<EventPacketBuilder>(new EventPacketBuilder(EventCode::CONNECTION_REQUEST));

  CHECK(evt_ptr->AddPayloadAddress(address));
  CHECK(evt_ptr->AddPayloadOctets1(class_of_device.cod[0]));
  CHECK(evt_ptr->AddPayloadOctets1(class_of_device.cod[1]));
  CHECK(evt_ptr->AddPayloadOctets1(class_of_device.cod[2]));
  CHECK(evt_ptr->AddPayloadOctets1(static_cast<uint8_t>(link_type)));

  return evt_ptr;
}

// Bluetooth Core Specification Version 4.2, Volume 2, Part E, Section 7.7.5
std::unique_ptr<EventPacketBuilder> EventPacketBuilder::CreateDisconnectionCompleteEvent(hci::Status status,
                                                                                         uint16_t handle,
                                                                                         uint8_t reason) {
  std::unique_ptr<EventPacketBuilder> evt_ptr =
      std::unique_ptr<EventPacketBuilder>(new EventPacketBuilder(EventCode::DISCONNECTION_COMPLETE));

  CHECK(evt_ptr->AddPayloadOctets1(static_cast<uint8_t>(status)));
  CHECK((handle & 0xf000) == 0);  // Handles are 12-bit values.
  CHECK(evt_ptr->AddPayloadOctets2(handle));
  CHECK(evt_ptr->AddPayloadOctets1(reason));

  return evt_ptr;
}

// Bluetooth Core Specification Version 4.2, Volume 2, Part E, Section 7.7.6
std::unique_ptr<EventPacketBuilder> EventPacketBuilder::CreateAuthenticationCompleteEvent(hci::Status status,
                                                                                          uint16_t handle) {
  std::unique_ptr<EventPacketBuilder> evt_ptr =
      std::unique_ptr<EventPacketBuilder>(new EventPacketBuilder(EventCode::AUTHENTICATION_COMPLETE));
  CHECK(evt_ptr->AddPayloadOctets1(static_cast<uint8_t>(status)));
  CHECK((handle & 0xf000) == 0);  // Handles are 12-bit values.
  CHECK(evt_ptr->AddPayloadOctets2(handle));
  return evt_ptr;
}

// Bluetooth Core Specification Version 4.2, Volume 2, Part E, Section 7.7.7
std::unique_ptr<EventPacketBuilder> EventPacketBuilder::CreateRemoteNameRequestCompleteEvent(
    hci::Status status, const Address& address, const std::string& remote_name) {
  std::unique_ptr<EventPacketBuilder> evt_ptr =
      std::unique_ptr<EventPacketBuilder>(new EventPacketBuilder(EventCode::REMOTE_NAME_REQUEST_COMPLETE));

  CHECK(evt_ptr->AddPayloadOctets1(static_cast<uint8_t>(status)));
  CHECK(evt_ptr->AddPayloadAddress(address));
  for (size_t i = 0; i < remote_name.length(); i++) CHECK(evt_ptr->AddPayloadOctets1(remote_name[i]));
  CHECK(evt_ptr->AddPayloadOctets1(0));  // Null terminated
  for (size_t i = 0; i < 248 - remote_name.length() - 1; i++) CHECK(evt_ptr->AddPayloadOctets1(0xFF));

  return evt_ptr;
}

// Bluetooth Core Specification Version 4.2, Volume 2, Part E, Section 7.7.23
std::unique_ptr<EventPacketBuilder> EventPacketBuilder::CreateLinkKeyRequestEvent(const Address& remote) {
  std::unique_ptr<EventPacketBuilder> evt_ptr =
      std::unique_ptr<EventPacketBuilder>(new EventPacketBuilder(EventCode::LINK_KEY_REQUEST));
  CHECK(evt_ptr->AddPayloadAddress(remote));
  return evt_ptr;
}

// Bluetooth Core Specification Version 4.2, Volume 2, Part E, Section 7.7.24
std::unique_ptr<EventPacketBuilder> EventPacketBuilder::CreateLinkKeyNotificationEvent(const Address& remote,
                                                                                       const std::vector<uint8_t>& key,
                                                                                       uint8_t key_type) {
  std::unique_ptr<EventPacketBuilder> evt_ptr =
      std::unique_ptr<EventPacketBuilder>(new EventPacketBuilder(EventCode::LINK_KEY_NOTIFICATION));
  CHECK(evt_ptr->AddPayloadAddress(remote));
  CHECK(key.size() == 16);
  CHECK(evt_ptr->AddPayloadOctets(key));
  CHECK(evt_ptr->AddPayloadOctets1(key_type));
  return evt_ptr;
}

// Bluetooth Core Specification Version 4.2, Volume 2, Part E, Section 7.7.25
std::unique_ptr<EventPacketBuilder> EventPacketBuilder::CreateLoopbackCommandEvent(hci::OpCode opcode,
                                                                                   PacketView<true> payload) {
  std::unique_ptr<EventPacketBuilder> evt_ptr =
      std::unique_ptr<EventPacketBuilder>(new EventPacketBuilder(EventCode::LOOPBACK_COMMAND));
  CHECK(evt_ptr->AddPayloadOctets2(static_cast<uint16_t>(opcode)));
  for (const auto& payload_byte : payload)  // Fill the packet.
    evt_ptr->AddPayloadOctets1(payload_byte);
  return evt_ptr;
}

// Bluetooth Core Specification Version 4.2, Volume 2, Part E, Section 7.7.28
std::unique_ptr<EventPacketBuilder> EventPacketBuilder::CreateReadClockOffsetEvent(hci::Status status, uint16_t handle,
                                                                                   uint16_t offset) {
  std::unique_ptr<EventPacketBuilder> evt_ptr =
      std::unique_ptr<EventPacketBuilder>(new EventPacketBuilder(EventCode::READ_CLOCK_OFFSET_COMPLETE));
  CHECK(evt_ptr->AddPayloadOctets1(static_cast<uint8_t>(status)));
  CHECK(evt_ptr->AddPayloadOctets2(handle));
  CHECK(evt_ptr->AddPayloadOctets2(offset));
  return evt_ptr;
}

// Bluetooth Core Specification Version 4.2, Volume 2, Part E, Section 7.7.29
std::unique_ptr<EventPacketBuilder> EventPacketBuilder::CreateConnectionPacketTypeChangedEvent(hci::Status status,
                                                                                               uint16_t handle,
                                                                                               uint16_t packet_type) {
  std::unique_ptr<EventPacketBuilder> evt_ptr =
      std::unique_ptr<EventPacketBuilder>(new EventPacketBuilder(EventCode::CONNECTION_PACKET_TYPE_CHANGE));
  CHECK(evt_ptr->AddPayloadOctets1(static_cast<uint8_t>(status)));
  CHECK(evt_ptr->AddPayloadOctets2(handle));
  CHECK(evt_ptr->AddPayloadOctets2(packet_type));
  return evt_ptr;
}

// Bluetooth Core Specification Version 4.2, Volume 2, Part E, Section 7.7.37
std::unique_ptr<EventPacketBuilder> EventPacketBuilder::CreateSniffSubratingEvent(const hci::Status status,
                                                                                  uint16_t handle) {
  std::unique_ptr<EventPacketBuilder> evt_ptr =
      EventPacketBuilder::CreateCommandCompleteOnlyStatusEvent(OpCode::SNIFF_SUBRATING, status);

  CHECK(evt_ptr->AddPayloadOctets2(handle));
  return evt_ptr;
}

// Bluetooth Core Specification Version 4.2, Volume 2, Part E, Section 7.7.38
std::unique_ptr<EventPacketBuilder> EventPacketBuilder::CreateExtendedInquiryResultEvent(
    const Address& address, uint8_t page_scan_repetition_mode, ClassOfDevice class_of_device, uint16_t clock_offset,
    uint8_t rssi, const vector<uint8_t>& extended_inquiry_response) {
  std::unique_ptr<EventPacketBuilder> evt_ptr =
      std::unique_ptr<EventPacketBuilder>(new EventPacketBuilder(EventCode::EXTENDED_INQUIRY_RESULT));

  CHECK(evt_ptr->AddPayloadOctets1(1));  // Always contains a single response

  CHECK(evt_ptr->AddPayloadAddress(address));
  CHECK(evt_ptr->AddPayloadOctets1(page_scan_repetition_mode));
  CHECK(evt_ptr->AddPayloadOctets1(0));  // Reserved
  CHECK(evt_ptr->AddPayloadOctets1(class_of_device.cod[0]));
  CHECK(evt_ptr->AddPayloadOctets1(class_of_device.cod[1]));
  CHECK(evt_ptr->AddPayloadOctets1(class_of_device.cod[2]));
  CHECK(!(clock_offset & 0x8000));
  CHECK(evt_ptr->AddPayloadOctets2(clock_offset));
  CHECK(evt_ptr->AddPayloadOctets1(rssi));
  CHECK(evt_ptr->AddPayloadOctets(extended_inquiry_response));
  evt_ptr->AddPayloadOctets1(0x00);  // End marker
  while (evt_ptr->AddPayloadOctets1(0x00))
    ;  // Fill packet
  return evt_ptr;
}

// Bluetooth Core Specification Version 4.2, Volume 2, Part E, Section 7.7.40
std::unique_ptr<EventPacketBuilder> EventPacketBuilder::CreateIoCapabilityRequestEvent(const Address& peer) {
  std::unique_ptr<EventPacketBuilder> evt_ptr =
      std::unique_ptr<EventPacketBuilder>(new EventPacketBuilder(EventCode::IO_CAPABILITY_REQUEST));

  CHECK(evt_ptr->AddPayloadAddress(peer));
  return evt_ptr;
}  // namespace packets

// Bluetooth Core Specification Version 4.2, Volume 2, Part E, Section 7.7.41
std::unique_ptr<EventPacketBuilder> EventPacketBuilder::CreateIoCapabilityResponseEvent(
    const Address& peer, uint8_t io_capability, bool oob_data_present, uint8_t authentication_requirements) {
  std::unique_ptr<EventPacketBuilder> evt_ptr =
      std::unique_ptr<EventPacketBuilder>(new EventPacketBuilder(EventCode::IO_CAPABILITY_RESPONSE));

  CHECK(evt_ptr->AddPayloadAddress(peer));
  CHECK(evt_ptr->AddPayloadOctets1(io_capability));
  CHECK(evt_ptr->AddPayloadOctets1(oob_data_present));
  CHECK(evt_ptr->AddPayloadOctets1(authentication_requirements));
  return evt_ptr;
}  // namespace test_vendor_lib

// Bluetooth Core Specification Version 4.2, Volume 2, Part E, Section 7.7.42
std::unique_ptr<EventPacketBuilder> EventPacketBuilder::CreateUserConfirmationRequestEvent(const Address& peer,
                                                                                           uint32_t numeric_value) {
  std::unique_ptr<EventPacketBuilder> evt_ptr =
      std::unique_ptr<EventPacketBuilder>(new EventPacketBuilder(EventCode::USER_CONFIRMATION_REQUEST));

  CHECK(evt_ptr->AddPayloadAddress(peer));
  CHECK(evt_ptr->AddPayloadOctets4(numeric_value));
  return evt_ptr;
}

// Bluetooth Core Specification Version 4.2, Volume 2, Part E, Section 7.7.43
std::unique_ptr<EventPacketBuilder> EventPacketBuilder::CreateUserPasskeyRequestEvent(const Address& peer) {
  std::unique_ptr<EventPacketBuilder> evt_ptr =
      std::unique_ptr<EventPacketBuilder>(new EventPacketBuilder(EventCode::USER_PASSKEY_REQUEST));

  CHECK(evt_ptr->AddPayloadAddress(peer));
  return evt_ptr;
}

// Bluetooth Core Specification Version 4.2, Volume 2, Part E, Section 7.7.44
std::unique_ptr<EventPacketBuilder> EventPacketBuilder::CreateRemoteOobDataRequestEvent(const Address& peer) {
  std::unique_ptr<EventPacketBuilder> evt_ptr =
      std::unique_ptr<EventPacketBuilder>(new EventPacketBuilder(EventCode::REMOTE_OOB_DATA_REQUEST));

  CHECK(evt_ptr->AddPayloadAddress(peer));
  return evt_ptr;
}

// Bluetooth Core Specification Version 4.2, Volume 2, Part E, Section 7.7.45
std::unique_ptr<EventPacketBuilder> EventPacketBuilder::CreateSimplePairingCompleteEvent(hci::Status status,
                                                                                         const Address& peer) {
  std::unique_ptr<EventPacketBuilder> evt_ptr =
      std::unique_ptr<EventPacketBuilder>(new EventPacketBuilder(EventCode::SIMPLE_PAIRING_COMPLETE));

  CHECK(evt_ptr->AddPayloadOctets1(static_cast<uint8_t>(status)));
  CHECK(evt_ptr->AddPayloadAddress(peer));
  return evt_ptr;
}

// Bluetooth Core Specification Version 4.2, Volume 2, Part E, Section 7.7.48
std::unique_ptr<EventPacketBuilder> EventPacketBuilder::CreateUserPasskeyNotificationEvent(const Address& peer,
                                                                                           uint32_t passkey) {
  std::unique_ptr<EventPacketBuilder> evt_ptr =
      std::unique_ptr<EventPacketBuilder>(new EventPacketBuilder(EventCode::USER_PASSKEY_NOTIFICATION));

  CHECK(evt_ptr->AddPayloadAddress(peer));
  CHECK(evt_ptr->AddPayloadOctets4(passkey));
  return evt_ptr;
}

// Bluetooth Core Specification Version 4.2, Volume 2, Part E, Section 7.7.49
std::unique_ptr<EventPacketBuilder> EventPacketBuilder::CreateKeypressNotificationEvent(const Address& peer,
                                                                                        uint8_t notification_type) {
  std::unique_ptr<EventPacketBuilder> evt_ptr =
      std::unique_ptr<EventPacketBuilder>(new EventPacketBuilder(EventCode::KEYPRESS_NOTIFICATION));

  CHECK(evt_ptr->AddPayloadAddress(peer));
  CHECK(evt_ptr->AddPayloadOctets1(notification_type));
  return evt_ptr;
}

// Bluetooth Core Specification Version 4.2, Volume 2, Part E, Section 7.7.65.1
std::unique_ptr<EventPacketBuilder> EventPacketBuilder::CreateLeConnectionCompleteEvent(
    hci::Status status, uint16_t handle, uint8_t role, uint8_t peer_address_type, const Address& peer,
    uint16_t interval, uint16_t latency, uint16_t supervision_timeout) {
  std::unique_ptr<RawBuilder> meta_evt = LeMetaEventBuilder::CreateLeConnectionCompleteEvent(
      status, handle, role, peer_address_type, peer, interval, latency, supervision_timeout);

  return std::unique_ptr<EventPacketBuilder>(new EventPacketBuilder(EventCode::LE_META_EVENT, std::move(meta_evt)));
}

std::unique_ptr<EventPacketBuilder> EventPacketBuilder::CreateLeEnhancedConnectionCompleteEvent(
    hci::Status status, uint16_t handle, uint8_t role, uint8_t peer_address_type, const Address& peer,
    const Address& local_private_address, const Address& peer_private_address, uint16_t interval, uint16_t latency,
    uint16_t supervision_timeout) {
  std::unique_ptr<RawBuilder> meta_evt = LeMetaEventBuilder::CreateLeEnhancedConnectionCompleteEvent(
      status, handle, role, peer_address_type, peer, local_private_address, peer_private_address, interval, latency,
      supervision_timeout);

  return std::unique_ptr<EventPacketBuilder>(new EventPacketBuilder(EventCode::LE_META_EVENT, std::move(meta_evt)));
}

std::unique_ptr<EventPacketBuilder> EventPacketBuilder::CreateLeConnectionUpdateCompleteEvent(
    hci::Status status, uint16_t handle, uint16_t interval, uint16_t latency, uint16_t supervision_timeout) {
  std::unique_ptr<RawBuilder> meta_evt =
      LeMetaEventBuilder::CreateLeConnectionUpdateCompleteEvent(status, handle, interval, latency, supervision_timeout);

  return std::unique_ptr<EventPacketBuilder>(new EventPacketBuilder(EventCode::LE_META_EVENT, std::move(meta_evt)));
}

// Bluetooth Core Specification Version 4.2, Volume 2, Part E, Section 7.7.65.2
std::unique_ptr<EventPacketBuilder> EventPacketBuilder::CreateLeAdvertisingReportEvent() {
  std::unique_ptr<RawBuilder> meta_evt = LeMetaEventBuilder::CreateLeAdvertisingReportEvent();

  return std::unique_ptr<EventPacketBuilder>(new EventPacketBuilder(EventCode::LE_META_EVENT, std::move(meta_evt)));
}

bool EventPacketBuilder::AddLeAdvertisingReport(LeAdvertisement::AdvertisementType event_type,
                                                LeAdvertisement::AddressType addr_type, const Address& addr,
                                                const vector<uint8_t>& data, uint8_t rssi) {
  CHECK(event_code_ == EventCode::LE_META_EVENT);

  // Upcast the payload to add the next report.
  LeMetaEventBuilder* meta_ptr = static_cast<LeMetaEventBuilder*>(payload_.get());
  return meta_ptr->AddLeAdvertisingReport(event_type, addr_type, addr, data, rssi);
}

// Bluetooth Core Specification Version 4.2, Volume 2, Part E, Section 7.7.65.4
std::unique_ptr<EventPacketBuilder> EventPacketBuilder::CreateLeRemoteUsedFeaturesEvent(hci::Status status,
                                                                                        uint16_t handle,
                                                                                        uint64_t features) {
  std::unique_ptr<RawBuilder> meta_evt = LeMetaEventBuilder::CreateLeRemoteUsedFeaturesEvent(status, handle, features);
  return std::unique_ptr<EventPacketBuilder>(new EventPacketBuilder(EventCode::LE_META_EVENT, std::move(meta_evt)));
}

std::unique_ptr<EventPacketBuilder> EventPacketBuilder::CreateRemoteSupportedFeaturesEvent(hci::Status status,
                                                                                           uint16_t handle,
                                                                                           uint64_t features) {
  std::unique_ptr<EventPacketBuilder> evt_ptr =
      std::unique_ptr<EventPacketBuilder>(new EventPacketBuilder(EventCode::READ_REMOTE_SUPPORTED_FEATURES_COMPLETE));

  CHECK(evt_ptr->AddPayloadOctets1(static_cast<uint8_t>(status)));
  CHECK(evt_ptr->AddPayloadOctets2(handle));
  CHECK(evt_ptr->AddPayloadOctets8(features));

  return evt_ptr;
}

std::unique_ptr<EventPacketBuilder> EventPacketBuilder::CreateCommandCompleteLinkKeyRequestReply(hci::Status status,
                                                                                                 Address address) {
  std::unique_ptr<EventPacketBuilder> evt_ptr =
      EventPacketBuilder::CreateCommandCompleteOnlyStatusEvent(OpCode::LINK_KEY_REQUEST_REPLY, status);

  CHECK(evt_ptr->AddPayloadAddress(address));

  return evt_ptr;
}

std::unique_ptr<EventPacketBuilder> EventPacketBuilder::CreateCommandCompleteLinkKeyRequestNegativeReply(
    hci::Status status, Address address) {
  std::unique_ptr<EventPacketBuilder> evt_ptr =
      EventPacketBuilder::CreateCommandCompleteOnlyStatusEvent(OpCode::LINK_KEY_REQUEST_NEGATIVE_REPLY, status);

  CHECK(evt_ptr->AddPayloadAddress(address));

  return evt_ptr;
}

std::unique_ptr<EventPacketBuilder> EventPacketBuilder::CreateCommandCompleteWriteLinkPolicySettings(hci::Status status,
                                                                                                     uint16_t handle) {
  std::unique_ptr<EventPacketBuilder> evt_ptr =
      EventPacketBuilder::CreateCommandCompleteOnlyStatusEvent(OpCode::WRITE_LINK_POLICY_SETTINGS, status);

  CHECK(evt_ptr->AddPayloadOctets2(handle));

  return evt_ptr;
}

std::unique_ptr<EventPacketBuilder> EventPacketBuilder::CreateCommandCompleteWriteLinkSupervisionTimeout(
    hci::Status status, uint16_t handle) {
  std::unique_ptr<EventPacketBuilder> evt_ptr =
      EventPacketBuilder::CreateCommandCompleteOnlyStatusEvent(OpCode::WRITE_LINK_SUPERVISION_TIMEOUT, status);

  CHECK(evt_ptr->AddPayloadOctets2(handle));

  return evt_ptr;
}

// Bluetooth Core Specification Version 4.2, Volume 2, Part E, Section 7.8.2
std::unique_ptr<EventPacketBuilder> EventPacketBuilder::CreateCommandCompleteLeReadBufferSize(
    hci::Status status, uint16_t hc_le_data_packet_length, uint8_t hc_total_num_le_data_packets) {
  std::unique_ptr<EventPacketBuilder> evt_ptr =
      EventPacketBuilder::CreateCommandCompleteOnlyStatusEvent(OpCode::LE_READ_BUFFER_SIZE, status);

  CHECK(evt_ptr->AddPayloadOctets2(hc_le_data_packet_length));
  CHECK(evt_ptr->AddPayloadOctets1(hc_total_num_le_data_packets));

  return evt_ptr;
}

// Bluetooth Core Specification Version 4.2, Volume 2, Part E, Section 7.8.3
std::unique_ptr<EventPacketBuilder> EventPacketBuilder::CreateCommandCompleteLeReadLocalSupportedFeatures(
    hci::Status status, uint64_t le_features) {
  std::unique_ptr<EventPacketBuilder> evt_ptr =
      EventPacketBuilder::CreateCommandCompleteOnlyStatusEvent(OpCode::LE_READ_LOCAL_SUPPORTED_FEATURES, status);

  CHECK(evt_ptr->AddPayloadOctets8(le_features));

  return evt_ptr;
}

// Bluetooth Core Specification Version 4.2, Volume 2, Part E, Section 7.8.14
std::unique_ptr<EventPacketBuilder> EventPacketBuilder::CreateCommandCompleteLeReadWhiteListSize(
    hci::Status status, uint8_t white_list_size) {
  std::unique_ptr<EventPacketBuilder> evt_ptr =
      EventPacketBuilder::CreateCommandCompleteOnlyStatusEvent(OpCode::LE_READ_WHITE_LIST_SIZE, status);

  CHECK(evt_ptr->AddPayloadOctets8(white_list_size));

  return evt_ptr;
}

// Bluetooth Core Specification Version 4.2, Volume 2, Part E, Section 7.8.23
std::unique_ptr<EventPacketBuilder> EventPacketBuilder::CreateCommandCompleteLeRand(hci::Status status,
                                                                                    uint64_t random_val) {
  std::unique_ptr<EventPacketBuilder> evt_ptr =
      EventPacketBuilder::CreateCommandCompleteOnlyStatusEvent(OpCode::LE_RAND, status);

  CHECK(evt_ptr->AddPayloadOctets8(random_val));

  return evt_ptr;
}

// Bluetooth Core Specification Version 4.2, Volume 2, Part E, Section 7.8.27
std::unique_ptr<EventPacketBuilder> EventPacketBuilder::CreateCommandCompleteLeReadSupportedStates(hci::Status status,
                                                                                                   uint64_t le_states) {
  std::unique_ptr<EventPacketBuilder> evt_ptr =
      EventPacketBuilder::CreateCommandCompleteOnlyStatusEvent(OpCode::LE_READ_SUPPORTED_STATES, status);

  CHECK(evt_ptr->AddPayloadOctets8(le_states));

  return evt_ptr;
}

// Vendor-specific commands

std::unique_ptr<EventPacketBuilder> EventPacketBuilder::CreateCommandCompleteLeGetVendorCapabilities(
    hci::Status status, const vector<uint8_t>& vendor_cap) {
  std::unique_ptr<EventPacketBuilder> evt_ptr =
      EventPacketBuilder::CreateCommandCompleteOnlyStatusEvent(OpCode::LE_GET_VENDOR_CAPABILITIES, status);

  CHECK(evt_ptr->AddPayloadOctets(vendor_cap));

  return evt_ptr;
}

std::unique_ptr<EventPacketBuilder> EventPacketBuilder::CreateEncryptionChange(hci::Status status, uint16_t handle,
                                                                               uint8_t encryption_enable) {
  std::unique_ptr<EventPacketBuilder> evt_ptr =
      std::unique_ptr<EventPacketBuilder>(new EventPacketBuilder(EventCode::ENCRYPTION_CHANGE));

  CHECK(evt_ptr->AddPayloadOctets1(static_cast<uint8_t>(status)));
  CHECK(evt_ptr->AddPayloadOctets2(handle));
  CHECK(evt_ptr->AddPayloadOctets1(encryption_enable));

  return evt_ptr;
}

size_t EventPacketBuilder::size() const {
  size_t header_size = 2;  // Event code and payload size
  return header_size + payload_->size();
}

void EventPacketBuilder::Serialize(std::back_insert_iterator<std::vector<uint8_t>> it) const {
  insert(static_cast<uint8_t>(event_code_), it);
  uint8_t payload_size = size() - 2;  // Event code and payload size
  CHECK(size() - 2 == static_cast<size_t>(payload_size)) << "Payload too large for an event: " << size();
  insert(payload_size, it);
  payload_->Serialize(it);
}

bool EventPacketBuilder::CanAddPayloadOctets(size_t octets) {
  return payload_->CanAddOctets(octets);
}

bool EventPacketBuilder::AddPayloadOctets(size_t octets, const std::vector<uint8_t>& bytes) {
  return payload_->AddOctets(octets, bytes);
}

bool EventPacketBuilder::AddPayloadOctets(const std::vector<uint8_t>& bytes) {
  return payload_->AddOctets(bytes);
}

bool EventPacketBuilder::AddPayloadOctets1(uint8_t value) {
  return payload_->AddOctets1(value);
}

bool EventPacketBuilder::AddPayloadOctets2(uint16_t value) {
  return payload_->AddOctets2(value);
}

bool EventPacketBuilder::AddPayloadOctets3(uint32_t value) {
  return payload_->AddOctets3(value);
}

bool EventPacketBuilder::AddPayloadOctets4(uint32_t value) {
  return payload_->AddOctets4(value);
}

bool EventPacketBuilder::AddPayloadOctets6(uint64_t value) {
  return payload_->AddOctets6(value);
}

bool EventPacketBuilder::AddPayloadOctets8(uint64_t value) {
  return payload_->AddOctets8(value);
}

bool EventPacketBuilder::AddPayloadAddress(Address address) {
  return payload_->AddAddress(address);
}

bool EventPacketBuilder::AddBuilder(std::unique_ptr<BasePacketBuilder> builder) {
  // Upcast the payload to add the next builder.
  CountedBuilder* temp_ptr = static_cast<CountedBuilder*>(payload_.get());
  temp_ptr->Add(std::move(builder));
  return true;
}

}  // namespace packets
}  // namespace test_vendor_lib