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

Commit 2636d278 authored by Ben's avatar Ben
Browse files

HCI: Use enum for LeExtendedAdvertisingResponse.event_type 

Use a bitmask enum for the LeExtendedAdvertisingResponse.event_type
field. This simplifies parsing and enables duplicated bitmask
definitions to be deleted. This is not intended to change
behavior.

Bug: 315496838
Test: atest LeScanningManagerTest
Test: atest LeScanningReassemblerTest
Flag: EXEMPT no logic change, just moving definitions
Change-Id: Ie4609653cfacb14332181f2bb4dd24957eccadd8
parent 609efa2e

system/gd/hci/enum_helper.h

+18 −1
Original line number Diff line number Diff line
@@ -30,6 +30,23 @@ enum DeviceType { UNKNOWN = 0, BR_EDR = 1, LE = 2, DUAL = 3 }; 
// Scan mode from legacy stack, which is different from hci::ScanEnable

enum LegacyScanMode { BT_SCAN_MODE_NONE = 0, BT_SCAN_MODE_CONNECTABLE = 1, BT_SCAN_MODE_CONNECTABLE_DISCOVERABLE = 2 };



inline DataStatus DataStatusFromAdvertisingEventType(ExtendedAdvertisingEventType event_type) {

  constexpr uint8_t kDataStatusBits = 5;

  return DataStatus(((uint16_t)event_type >> kDataStatusBits) & 0x3);

}



inline ExtendedAdvertisingEventType operator|(

    const ExtendedAdvertisingEventType& a, const ExtendedAdvertisingEventType& b) {

  return static_cast<ExtendedAdvertisingEventType>(

      static_cast<uint16_t>(a) | static_cast<uint16_t>(b));

}



inline ExtendedAdvertisingEventType operator&(

    const ExtendedAdvertisingEventType& a, const ExtendedAdvertisingEventType& b) {

  return static_cast<ExtendedAdvertisingEventType>(

      static_cast<uint16_t>(a) & static_cast<uint16_t>(b));

}



}  // namespace hci



// Must be defined in bluetooth namespace

system/gd/hci/le_scanning_manager.cc

+25 −43
Original line number Diff line number Diff line
@@ -21,6 +21,7 @@ 
#include "android_bluetooth_flags.h"

#include "hci/acl_manager.h"

#include "hci/controller.h"

#include "hci/enum_helper.h"

#include "hci/event_checkers.h"

#include "hci/hci_layer.h"

#include "hci/hci_packets.h"
@@ -51,12 +52,6 @@ constexpr uint16_t kLeScanIntervalMax = 0x4000; 
constexpr uint16_t kDefaultLeExtendedScanInterval = 4800;

constexpr uint16_t kLeExtendedScanIntervalMax = 0xFFFF;



constexpr uint8_t kScannableBit = 1;

constexpr uint8_t kDirectedBit = 2;

constexpr uint8_t kScanResponseBit = 3;

constexpr uint8_t kLegacyBit = 4;

constexpr uint8_t kDataStatusBits = 5;



// system properties

const std::string kLeRxPathLossCompProperty = "bluetooth.hardware.radio.le_rx_path_loss_comp_db";
@@ -295,16 +290,6 @@ struct LeScanningManager::impl : public LeAddressManagerCallback { 
    }

  }



  struct ExtendedEventTypeOptions {

    bool connectable{false};

    bool scannable{false};

    bool directed{false};

    bool scan_response{false};

    bool legacy{false};

    bool continuing{false};

    bool truncated{false};

  };



  int8_t get_rx_path_loss_compensation() {

    int8_t compensation = 0;

    auto compensation_prop = os::GetSystemProperty(kLeRxPathLossCompProperty);
@@ -337,13 +322,6 @@ struct LeScanningManager::impl : public LeAddressManagerCallback { 
    return calibrated_rssi;

  }



  uint16_t transform_to_extended_event_type(ExtendedEventTypeOptions o) {

    return (o.connectable ? 0x0001 << 0 : 0) | (o.scannable ? 0x0001 << 1 : 0) |

           (o.directed ? 0x0001 << 2 : 0) | (o.scan_response ? 0x0001 << 3 : 0) |

           (o.legacy ? 0x0001 << 4 : 0) | (o.continuing ? 0x0001 << 5 : 0) |

           (o.truncated ? 0x0001 << 6 : 0);

  }



  void handle_advertising_report(LeAdvertisingReportRawView event_view) {

    if (!event_view.IsValid()) {

      LOG_INFO("Dropping invalid advertising event");
@@ -356,32 +334,38 @@ struct LeScanningManager::impl : public LeAddressManagerCallback { 
    }



    for (LeAdvertisingResponseRaw report : reports) {

      uint16_t extended_event_type = 0;

      ExtendedAdvertisingEventType extended_event_type =

          static_cast<ExtendedAdvertisingEventType>(0);

      switch (report.event_type_) {

        case AdvertisingEventType::ADV_IND:

          extended_event_type = transform_to_extended_event_type(

              {.connectable = true, .scannable = true, .legacy = true});

          extended_event_type = ExtendedAdvertisingEventType::LEGACY |

                                ExtendedAdvertisingEventType::CONNECTABLE |

                                ExtendedAdvertisingEventType::SCANNABLE;

          break;

        case AdvertisingEventType::ADV_DIRECT_IND:

          extended_event_type = transform_to_extended_event_type(

              {.connectable = true, .directed = true, .legacy = true});

          extended_event_type = ExtendedAdvertisingEventType::LEGACY |

                                ExtendedAdvertisingEventType::CONNECTABLE |

                                ExtendedAdvertisingEventType::DIRECTED;

          break;

        case AdvertisingEventType::ADV_SCAN_IND:

          extended_event_type =

              transform_to_extended_event_type({.scannable = true, .legacy = true});

              ExtendedAdvertisingEventType::LEGACY | ExtendedAdvertisingEventType::SCANNABLE;

          break;

        case AdvertisingEventType::ADV_NONCONN_IND:

          extended_event_type = transform_to_extended_event_type({.legacy = true});

          extended_event_type = ExtendedAdvertisingEventType::LEGACY;

          break;

        case AdvertisingEventType::SCAN_RESPONSE:

          if (IS_FLAG_ENABLED(fix_nonconnectable_scannable_advertisement)) {

            // We don't know if the initial advertising report was connectable or not.

            // LeScanningReassembler fixes the connectable field.

            extended_event_type = transform_to_extended_event_type(

                {.scannable = true, .scan_response = true, .legacy = true});

            extended_event_type = ExtendedAdvertisingEventType::LEGACY |

                                  ExtendedAdvertisingEventType::SCAN_RESPONSE |

                                  ExtendedAdvertisingEventType::SCANNABLE;

          } else {

            extended_event_type = transform_to_extended_event_type(

                {.connectable = true, .scannable = true, .scan_response = true, .legacy = true});

            extended_event_type = ExtendedAdvertisingEventType::CONNECTABLE |

                                  ExtendedAdvertisingEventType::LEGACY |

                                  ExtendedAdvertisingEventType::SCAN_RESPONSE |

                                  ExtendedAdvertisingEventType::SCANNABLE;

          }

          break;

        default:
@@ -420,11 +404,8 @@ struct LeScanningManager::impl : public LeAddressManagerCallback { 
    }



    for (LeExtendedAdvertisingResponseRaw& report : reports) {

      uint16_t event_type = report.connectable_ | (report.scannable_ << kScannableBit) |

                            (report.directed_ << kDirectedBit) | (report.scan_response_ << kScanResponseBit) |

                            (report.legacy_ << kLegacyBit) | ((uint16_t)report.data_status_ << kDataStatusBits);

      process_advertising_package_content(

          event_type,

          report.event_type_,

          (uint8_t)report.address_type_,

          report.address_,

          (uint8_t)report.primary_phy_,
@@ -438,7 +419,7 @@ struct LeScanningManager::impl : public LeAddressManagerCallback { 
  }



  void process_advertising_package_content(

      uint16_t event_type,

      ExtendedAdvertisingEventType event_type,

      uint8_t address_type,

      Address address,

      uint8_t primary_phy,
@@ -474,12 +455,13 @@ struct LeScanningManager::impl : public LeAddressManagerCallback { 
          break;

      }



      const uint16_t result_event_type = IS_FLAG_ENABLED(fix_nonconnectable_scannable_advertisement)

      const ExtendedAdvertisingEventType result_event_type =

          IS_FLAG_ENABLED(fix_nonconnectable_scannable_advertisement)

              ? processed_report->extended_event_type

              : event_type;



      scanning_callbacks_->OnScanResult(

          result_event_type,

          static_cast<uint16_t>(result_event_type),

          address_type,

          address,

          primary_phy,

system/gd/hci/le_scanning_manager_test.cc

+5 −5
Original line number Diff line number Diff line
@@ -34,6 +34,7 @@ 
#include "hci/acl_manager.h"

#include "hci/address.h"

#include "hci/controller.h"

#include "hci/enum_helper.h"

#include "hci/hci_layer.h"

#include "hci/hci_layer_fake.h"

#include "hci/uuid.h"
@@ -731,8 +732,7 @@ TEST_F(LeScanningManagerExtendedTest, start_scan_test) { 
  ASSERT_EQ(OpCode::LE_SET_EXTENDED_SCAN_ENABLE, test_hci_layer_->GetCommand().GetOpCode());

  test_hci_layer_->IncomingEvent(LeSetExtendedScanEnableCompleteBuilder::Create(uint8_t{1}, ErrorCode::SUCCESS));

  LeExtendedAdvertisingResponse report{};

  report.connectable_ = 1;

  report.scannable_ = 0;

  report.event_type_ = ExtendedAdvertisingEventType::CONNECTABLE;

  report.address_type_ = DirectAdvertisingAddressType::PUBLIC_DEVICE_ADDRESS;

  Address::FromString("12:34:56:78:9a:bc", report.address_);

  std::vector<LengthAndData> adv_data{};
@@ -856,8 +856,8 @@ TEST_F(LeScanningManagerExtendedTest, drop_insignificant_bytes_test) { 


  // Prepare advertisement report

  LeExtendedAdvertisingResponse advertisement_report{};

  advertisement_report.connectable_ = 1;

  advertisement_report.scannable_ = 1;

  advertisement_report.event_type_ =

      ExtendedAdvertisingEventType::CONNECTABLE | ExtendedAdvertisingEventType::SCANNABLE;

  advertisement_report.address_type_ = DirectAdvertisingAddressType::PUBLIC_DEVICE_ADDRESS;

  Address::FromString("12:34:56:78:9a:bc", advertisement_report.address_);

  std::vector<LengthAndData> adv_data{};
@@ -878,7 +878,7 @@ TEST_F(LeScanningManagerExtendedTest, drop_insignificant_bytes_test) { 


  // Prepare scan response report

  auto scan_response_report = advertisement_report;

  scan_response_report.scan_response_ = true;

  scan_response_report.event_type_ = ExtendedAdvertisingEventType::SCAN_RESPONSE;

  LengthAndData extra_data{};

  extra_data.data_.push_back(static_cast<uint8_t>(GapDataType::MANUFACTURER_SPECIFIC_DATA));

  for (auto octet : "manufacturer specific") {

system/gd/hci/le_scanning_reassembler.cc

+13 −10
Original line number Diff line number Diff line
@@ -34,15 +34,16 @@ namespace bluetooth::hci { 


std::optional<LeScanningReassembler::CompleteAdvertisingData>

LeScanningReassembler::ProcessAdvertisingReport(

    uint16_t event_type,

    ExtendedAdvertisingEventType event_type,

    uint8_t address_type,

    Address address,

    uint8_t advertising_sid,

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

  bool is_scannable = event_type & (1 << kScannableBit);

  bool is_scan_response = event_type & (1 << kScanResponseBit);

  bool is_legacy = event_type & (1 << kLegacyBit);

  DataStatus data_status = DataStatus((event_type >> kDataStatusBits) & 0x3);

  bool is_scannable = static_cast<uint16_t>(event_type & ExtendedAdvertisingEventType::SCANNABLE);

  bool is_scan_response =

      static_cast<uint16_t>(event_type & ExtendedAdvertisingEventType::SCAN_RESPONSE);

  bool is_legacy = static_cast<uint16_t>(event_type & ExtendedAdvertisingEventType::LEGACY);

  DataStatus data_status = DataStatusFromAdvertisingEventType(event_type);



  if (address_type != (uint8_t)DirectAdvertisingAddressType::NO_ADDRESS_PROVIDED &&

      address == Address::kEmpty) {
@@ -144,15 +145,17 @@ bool LeScanningReassembler::AdvertisingKey::operator==(const AdvertisingKey& oth 
/// dropping the oldest advertiser.

std::list<LeScanningReassembler::AdvertisingFragment>::iterator

LeScanningReassembler::AppendFragment(

    const AdvertisingKey& key, uint16_t extended_event_type, const std::vector<uint8_t>& data) {

    const AdvertisingKey& key,

    ExtendedAdvertisingEventType extended_event_type,

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

  auto it = FindFragment(key);

  if (it != cache_.end()) {

    // Legacy scan responses don't contain a 'connectable' bit, so this adds the

    // 'connectable' bit from the initial report.

    if ((extended_event_type & (1 << kLegacyBit)) &&

        (extended_event_type & (1 << kScanResponseBit))) {

      it->extended_event_type =

          extended_event_type | (it->extended_event_type & (1 << kConnectableBit));

    if (static_cast<uint16_t>(extended_event_type & ExtendedAdvertisingEventType::LEGACY) &&

        static_cast<uint16_t>(extended_event_type & ExtendedAdvertisingEventType::SCAN_RESPONSE)) {

      it->extended_event_type = extended_event_type | (it->extended_event_type &

                                                       ExtendedAdvertisingEventType::CONNECTABLE);

    } else {

      it->extended_event_type = extended_event_type;

    }

system/gd/hci/le_scanning_reassembler.h

+9 −13
Original line number Diff line number Diff line
@@ -36,7 +36,7 @@ namespace bluetooth::hci { 
class LeScanningReassembler {

 public:

  struct CompleteAdvertisingData {

    uint16_t extended_event_type;

    ExtendedAdvertisingEventType extended_event_type;

    std::vector<uint8_t> data;

  };
@@ -52,7 +52,7 @@ class LeScanningReassembler { 
  /// Returns the completed advertising data if the event was complete, or the

  /// completion of a fragmented advertising event.

  std::optional<CompleteAdvertisingData> ProcessAdvertisingReport(

      uint16_t event_type,

      ExtendedAdvertisingEventType event_type,

      uint8_t address_type,

      Address address,

      uint8_t advertising_sid,
@@ -68,14 +68,6 @@ class LeScanningReassembler { 
  /// Determine if scan responses should be processed or ignored.

  bool ignore_scan_responses_{false};



  /// Constants for parsing event_type.

  static constexpr uint8_t kConnectableBit = 0;

  static constexpr uint8_t kScannableBit = 1;

  static constexpr uint8_t kDirectedBit = 2;

  static constexpr uint8_t kScanResponseBit = 3;

  static constexpr uint8_t kLegacyBit = 4;

  static constexpr uint8_t kDataStatusBits = 5;



  /// Packs the information necessary to disambiguate advertising events:

  /// - For legacy advertising events, the advertising address and

  ///   advertising address type are used to disambiguate advertisers.
@@ -97,11 +89,13 @@ class LeScanningReassembler { 
  /// Packs incomplete advertising data.

  struct AdvertisingFragment {

    AdvertisingKey key;

    uint16_t extended_event_type;

    ExtendedAdvertisingEventType extended_event_type;

    std::vector<uint8_t> data;



    AdvertisingFragment(

        const AdvertisingKey& key, uint16_t extended_event_type, const std::vector<uint8_t>& data)

        const AdvertisingKey& key,

        ExtendedAdvertisingEventType extended_event_type,

        const std::vector<uint8_t>& data)

        : key(key), extended_event_type(extended_event_type), data(data.begin(), data.end()) {}

  };
@@ -115,7 +109,9 @@ class LeScanningReassembler { 


  /// Advertising cache management methods.

  std::list<AdvertisingFragment>::iterator AppendFragment(

      const AdvertisingKey& key, uint16_t extended_event_type, const std::vector<uint8_t>& data);

      const AdvertisingKey& key,

      ExtendedAdvertisingEventType extended_event_type,

      const std::vector<uint8_t>& data);



  void RemoveFragment(const AdvertisingKey& key);