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

Commit fdb8af19 authored by Jakub Pawlowski's avatar Jakub Pawlowski
Browse files

Move startAdvertising() logic into native code (2/3) 

AdvertiseManager.startAdvertising() was implemented in Java layer for
historical reasons. Now that we have nice native callbacks and tests,
it can be moved into native code, where it will be shared between
Android daemon and bluetoothtbd.

Bug: 30622771
Test: native tests added to cover startAdvertising
Change-Id: Idf5d3c53b6ad21d8c7e239b5b150b88e073bb709
parent 03bd9638

system/btif/src/btif_ble_advertiser.cc

+28 −0
Original line number Diff line number Diff line
@@ -160,6 +160,34 @@ class BleAdvertiserInterfaceImpl : public BleAdvertiserInterface { 
             Bind(&BleAdvertiserInterfaceImpl::EnableTimeoutCb,

                  base::Unretained(this), timeout_cb)));

  }



  void StartAdvertising(uint8_t advertiser_id, Callback cb,

                        AdvertiseParameters params,

                        std::vector<uint8_t> advertise_data,

                        std::vector<uint8_t> scan_response_data, int timeout_s,

                        MultiAdvCb timeout_cb) override {

    VLOG(1) << __func__;



    tBTM_BLE_ADV_PARAMS* p_params = new tBTM_BLE_ADV_PARAMS;

    p_params->adv_int_min = params.min_interval;

    p_params->adv_int_max = params.max_interval;

    p_params->adv_type = params.adv_type;

    p_params->channel_map = params.channel_map;

    p_params->adv_filter_policy = 0;

    p_params->tx_power = ble_map_adv_tx_power(params.tx_power);



    do_in_bta_thread(

        FROM_HERE,

        Bind(&BleAdvertisingManager::StartAdvertising,

             base::Unretained(BleAdvertisingManager::Get()), advertiser_id,

             base::Bind(

                 [](Callback cb, uint8_t status) {

                   do_in_jni_thread(Bind(cb, status));

                 },

                 cb),

             base::Owned(p_params), std::move(advertise_data),

             std::move(scan_response_data), timeout_s, timeout_cb));

  }

};



BleAdvertiserInterface* btLeAdvertiserInstance = nullptr;

system/service/low_energy_advertiser.cc

+17 −158
Original line number Diff line number Diff line
@@ -65,16 +65,8 @@ int GetAdvertisingIntervalUnit(AdvertiseSettings::Mode mode) { 
  return (ms * 1000) / 625;

}



struct AdvertiseParams {

  int min_interval;

  int max_interval;

  int event_type;

  int tx_power_level;

  int timeout_s;

};



void GetAdvertiseParams(const AdvertiseSettings& settings, bool has_scan_rsp,

                        AdvertiseParams* out_params) {

                        AdvertiseParameters* out_params) {

  CHECK(out_params);



  out_params->min_interval = GetAdvertisingIntervalUnit(settings.mode());
@@ -82,14 +74,13 @@ void GetAdvertiseParams(const AdvertiseSettings& settings, bool has_scan_rsp, 
      out_params->min_interval + kAdvertisingIntervalDeltaUnit;



  if (settings.connectable())

    out_params->event_type = kAdvertisingEventTypeConnectable;

    out_params->adv_type = kAdvertisingEventTypeConnectable;

  else if (has_scan_rsp)

    out_params->event_type = kAdvertisingEventTypeScannable;

    out_params->adv_type = kAdvertisingEventTypeScannable;

  else

    out_params->event_type = kAdvertisingEventTypeNonConnectable;

    out_params->adv_type = kAdvertisingEventTypeNonConnectable;



  out_params->tx_power_level = settings.tx_power_level();

  out_params->timeout_s = settings.timeout().InSeconds();

  out_params->channel_map = kAdvertisingChannelAll;

}



void DoNothing(uint8_t status) {}
@@ -102,9 +93,6 @@ void DoNothing(uint8_t status) {} 
LowEnergyAdvertiser::LowEnergyAdvertiser(const UUID& uuid, int advertiser_id) :

      app_identifier_(uuid),

      advertiser_id_(advertiser_id),

      adv_data_needs_update_(false),

      scan_rsp_needs_update_(false),

      is_setting_adv_data_(false),

      adv_started_(false),

      adv_start_callback_(nullptr),

      adv_stop_callback_(nullptr) {
@@ -148,37 +136,24 @@ bool LowEnergyAdvertiser::StartAdvertising(const AdvertiseSettings& settings, 
    return false;

  }



  CHECK(!adv_data_needs_update_.load());

  CHECK(!scan_rsp_needs_update_.load());



  adv_data_ = advertise_data;

  scan_response_ = scan_response;

  advertise_settings_ = settings;



  AdvertiseParams params;

  GetAdvertiseParams(settings, !scan_response_.data().empty(), &params);

  AdvertiseParameters params;

  GetAdvertiseParams(settings, !scan_response.data().empty(), &params);



  hal::BluetoothGattInterface::Get()->

      GetAdvertiserHALInterface()->SetParameters(

  hal::BluetoothGattInterface::Get()

      ->GetAdvertiserHALInterface()

      ->StartAdvertising(

          advertiser_id_,

          params.min_interval,

          params.max_interval,

          params.event_type,

          kAdvertisingChannelAll,

          params.tx_power_level,

          base::Bind(&LowEnergyAdvertiser::SetParamsCallback, base::Unretained(this), advertiser_id_));



  // Always update advertising data.

  adv_data_needs_update_ = true;



  // Update scan response only if it has data, since otherwise we just won't

  // send ADV_SCAN_IND.

  if (!scan_response_.data().empty())

    scan_rsp_needs_update_ = true;

          base::Bind(&LowEnergyAdvertiser::EnableCallback,

                     base::Unretained(this), true, advertiser_id_),

          params, advertise_data.data(), scan_response.data(),

          settings.timeout().InSeconds(),

          base::Bind(&LowEnergyAdvertiser::EnableCallback,

                     base::Unretained(this), false, advertiser_id_));

  ;



  // OK to set this at the end since we're still holding |adv_fields_lock_|.

  adv_start_callback_.reset(new StatusCallback(callback));



  return true;

}
@@ -196,8 +171,6 @@ bool LowEnergyAdvertiser::StopAdvertising(const StatusCallback& callback) { 
    return false;

  }



  CHECK(!adv_start_callback_);



  hal::BluetoothGattInterface::Get()

      ->GetAdvertiserHALInterface()

      ->Enable(
@@ -233,88 +206,6 @@ int LowEnergyAdvertiser::GetInstanceId() const { 
  return advertiser_id_;

}



void LowEnergyAdvertiser::HandleDeferredAdvertiseData() {

  VLOG(2) << __func__;



  CHECK(!IsAdvertisingStarted());

  CHECK(!IsStoppingAdvertising());

  CHECK(IsStartingAdvertising());

  CHECK(!is_setting_adv_data_.load());



  if (adv_data_needs_update_.load()) {

    bt_status_t status = SetAdvertiseData(adv_data_, false);

    if (status != BT_STATUS_SUCCESS) {

      LOG(ERROR) << "Failed setting advertisement data";

      InvokeAndClearStartCallback(GetBLEStatus(status));

    }

    return;

  }



  if (scan_rsp_needs_update_.load()) {

    bt_status_t status = SetAdvertiseData(scan_response_, true);

    if (status != BT_STATUS_SUCCESS) {

      LOG(ERROR) << "Failed setting scan response data";

      InvokeAndClearStartCallback(GetBLEStatus(status));

    }

    return;

  }



  AdvertiseParams params;

  GetAdvertiseParams(advertise_settings_, !scan_response_.data().empty(), &params);



  hal::BluetoothGattInterface::Get()

      ->GetAdvertiserHALInterface()

      ->Enable(

          advertiser_id_, true,

          base::Bind(&LowEnergyAdvertiser::EnableCallback,

                     base::Unretained(this), true, advertiser_id_),

          params.timeout_s,

          base::Bind(&LowEnergyAdvertiser::EnableCallback,

                     base::Unretained(this), false, advertiser_id_));

}



void LowEnergyAdvertiser::SetParamsCallback(

    uint8_t advertiser_id, uint8_t status) {

  if (advertiser_id != advertiser_id_)

    return;



  lock_guard<mutex> lock(adv_fields_lock_);



  VLOG(1) << __func__ << "advertiser_id: " << advertiser_id << " status: " << status;



  // Terminate operation in case of error.

  if (status != BT_STATUS_SUCCESS) {

    LOG(ERROR) << "Failed to set advertising parameters";

    InvokeAndClearStartCallback(GetBLEStatus(status));

    return;

  }



  // Now handle deferred tasks.

  HandleDeferredAdvertiseData();

}



void LowEnergyAdvertiser::SetDataCallback(

    uint8_t advertiser_id, uint8_t status) {

  if (advertiser_id != advertiser_id_)

    return;



  lock_guard<mutex> lock(adv_fields_lock_);



  VLOG(1) << __func__ << "advertiser_id: " << advertiser_id << " status: " << status;



  is_setting_adv_data_ = false;



  // Terminate operation in case of error.

  if (status != BT_STATUS_SUCCESS) {

    LOG(ERROR) << "Failed to set advertising data";

    InvokeAndClearStartCallback(GetBLEStatus(status));

    return;

  }



  // Now handle deferred tasks.

  HandleDeferredAdvertiseData();

}



void LowEnergyAdvertiser::EnableCallback(

    bool enable, uint8_t advertiser_id, uint8_t status) {

  if (advertiser_id != advertiser_id_)
@@ -356,39 +247,7 @@ void LowEnergyAdvertiser::EnableCallback( 
  }

}



bt_status_t LowEnergyAdvertiser::SetAdvertiseData(

    const AdvertiseData& data,

    bool set_scan_rsp) {

  VLOG(2) << __func__;



  if (is_setting_adv_data_.load()) {

    LOG(ERROR) << "Setting advertising data already in progress.";

    return BT_STATUS_FAIL;

  }



  // TODO(armansito): The length fields in the BTIF function below are signed

  // integers so a call to std::vector::size might get capped. This is very

  // unlikely anyway but it's safer to stop using signed-integer types for

  // length in APIs, so we should change that.

  hal::BluetoothGattInterface::Get()->GetAdvertiserHALInterface()->SetData(

      advertiser_id_, set_scan_rsp, data.data(),

      base::Bind(&LowEnergyAdvertiser::SetDataCallback,

                 base::Unretained(this), advertiser_id_));



  if (set_scan_rsp)

    scan_rsp_needs_update_ = false;

  else

    adv_data_needs_update_ = false;



  is_setting_adv_data_ = true;



  return BT_STATUS_SUCCESS;

}



void LowEnergyAdvertiser::InvokeAndClearStartCallback(BLEStatus status) {

  adv_data_needs_update_ = false;

  scan_rsp_needs_update_ = false;



  // We allow NULL callbacks.

  if (*adv_start_callback_)

    (*adv_start_callback_)(status);

system/service/low_energy_advertiser.h

+0 −20
Original line number Diff line number Diff line
@@ -94,16 +94,6 @@ class LowEnergyAdvertiser : public BluetoothInstance { 
  void EnableCallback(

      bool enable, uint8_t advertiser_id, uint8_t status);



  // Helper method called from SetAdvertiseData/SetScanResponse.

  bt_status_t SetAdvertiseData(

      const AdvertiseData& data,

      bool set_scan_rsp);



  // Handles deferred advertise/scan-response data updates. We set the data if

  // there's data to be set, otherwise we either defer it if advertisements

  // aren't enabled or do nothing.

  void HandleDeferredAdvertiseData();



  // Calls and clears the pending callbacks.

  void InvokeAndClearStartCallback(BLEStatus status);

  void InvokeAndClearStopCallback(BLEStatus status);
@@ -115,19 +105,9 @@ class LowEnergyAdvertiser : public BluetoothInstance { 
  // Protects advertising-related members below.

  std::mutex adv_fields_lock_;



  // The advertising and scan response data fields that will be sent to the

  // controller.

  AdvertiseData adv_data_;

  AdvertiseData scan_response_;

  std::atomic_bool adv_data_needs_update_;

  std::atomic_bool scan_rsp_needs_update_;



  // Latest advertising settings.

  AdvertiseSettings advertise_settings_;



  // Whether or not there is a pending call to update advertising or scan

  // response data.

  std::atomic_bool is_setting_adv_data_;



  std::atomic_bool adv_started_;

  std::unique_ptr<StatusCallback> adv_start_callback_;

system/service/test/low_energy_advertiser_unittest.cc

+53 −189
Original line number Diff line number Diff line
@@ -56,6 +56,9 @@ class MockAdvertiserHandler : public BleAdvertiserInterface { 
                             vector<uint8_t> data, Callback cb));

  MOCK_METHOD5(Enable, void(uint8_t advertiser_id, bool enable, Callback cb,

                            int timeout_s, Callback timeout_cb));

  MOCK_METHOD7(StartAdvertising, void(uint8_t advertiser_id, Callback cb,

                                      AdvertiseParameters, std::vector<uint8_t>,

                                      std::vector<uint8_t>, int, Callback));



 private:

  DISALLOW_COPY_AND_ASSIGN(MockAdvertiserHandler);
@@ -140,18 +143,11 @@ class LowEnergyAdvertiserPostRegisterTest : public LowEnergyAdvertiserTest { 
    ASSERT_FALSE(le_advertiser_->IsStartingAdvertising());

    ASSERT_FALSE(le_advertiser_->IsStoppingAdvertising());



    status_cb set_params_cb;

    EXPECT_CALL(*mock_handler_, SetParameters(_, _, _, _, _, _, _))

    status_cb start_advertising_cb;

    EXPECT_CALL(*mock_handler_, StartAdvertising(_, _, _, _, _, _, _))

        .Times(1)

        .WillOnce(SaveArg<6>(&set_params_cb));

        .WillOnce(SaveArg<1>(&start_advertising_cb));

    status_cb set_data_cb;

    EXPECT_CALL(*mock_handler_, SetData(_, _, _, _))

        .Times(1)

        .WillOnce(SaveArg<3>(&set_data_cb));

    status_cb enable_cb;

    EXPECT_CALL(*mock_handler_, Enable(_, true, _, _, _))

        .Times(1)

        .WillOnce(SaveArg<2>(&enable_cb));



    AdvertiseSettings settings;

    AdvertiseData adv, scan_rsp;
@@ -159,9 +155,7 @@ class LowEnergyAdvertiserPostRegisterTest : public LowEnergyAdvertiserTest { 
        settings, adv, scan_rsp, LowEnergyAdvertiser::StatusCallback()));

    ASSERT_TRUE(le_advertiser_->IsStartingAdvertising());



    set_params_cb.Run(BT_STATUS_SUCCESS);

    set_data_cb.Run(BT_STATUS_SUCCESS);

    enable_cb.Run(BT_STATUS_SUCCESS);

    start_advertising_cb.Run(BT_STATUS_SUCCESS);



    ASSERT_TRUE(le_advertiser_->IsAdvertisingStarted());

    ASSERT_FALSE(le_advertiser_->IsStartingAdvertising());
@@ -173,22 +167,10 @@ class LowEnergyAdvertiserPostRegisterTest : public LowEnergyAdvertiserTest { 


    LOG_ASSERT(set_data_cb) << "set_data_cb must be set";



    status_cb set_params_cb;

    EXPECT_CALL(*mock_handler_, SetParameters(_, _, _, _, _, _, _))

        .Times(1)

        .WillOnce(SaveArg<6>(&set_params_cb));



    status_cb enable_cb;

    EXPECT_CALL(*mock_handler_, Enable(_, true, _, _, _))

        .Times(1)

        .WillOnce(SaveArg<2>(&enable_cb));



    EXPECT_TRUE(le_advertiser_->StartAdvertising(

        settings, data, AdvertiseData(), callback));



    set_params_cb.Run(BT_STATUS_SUCCESS);

    set_data_cb->Run(BT_STATUS_SUCCESS);

    enable_cb.Run(BT_STATUS_SUCCESS);



    status_cb disable_cb;

    EXPECT_CALL(*mock_handler_, Enable(_, false, _, _, _))
@@ -294,10 +276,10 @@ TEST_F(LowEnergyAdvertiserPostRegisterTest, StartAdvertisingBasic) { 
    callback_count++;

  };



  status_cb set_params_cb;

  EXPECT_CALL(*mock_handler_, SetParameters(_, _, _, _, _, _, _))

      .Times(3)

      .WillRepeatedly(SaveArg<6>(&set_params_cb));

  status_cb start_advertising_cb;

  EXPECT_CALL(*mock_handler_, StartAdvertising(_, _, _, _, _, _, _))

      .Times(2)

      .WillRepeatedly(SaveArg<1>(&start_advertising_cb));



  // Stack call returns success.

  EXPECT_TRUE(le_advertiser_->StartAdvertising(
@@ -313,7 +295,7 @@ TEST_F(LowEnergyAdvertiserPostRegisterTest, StartAdvertisingBasic) { 
      settings, adv_data, scan_rsp, callback));



  // Notify failure.

  set_params_cb.Run(BT_STATUS_FAIL);

  start_advertising_cb.Run(BT_STATUS_FAIL);



  EXPECT_FALSE(le_advertiser_->IsAdvertisingStarted());

  EXPECT_FALSE(le_advertiser_->IsStartingAdvertising());
@@ -329,49 +311,12 @@ TEST_F(LowEnergyAdvertiserPostRegisterTest, StartAdvertisingBasic) { 
  EXPECT_FALSE(le_advertiser_->IsStoppingAdvertising());

  EXPECT_EQ(1, callback_count);



  // Success notification should trigger advertise data update.

  status_cb set_data_cb;

  EXPECT_CALL(*mock_handler_, SetData(_, false, /* set_scan_rsp */

                                                  _, _))

      .Times(2)

      .WillRepeatedly(SaveArg<3>(&set_data_cb));

  start_advertising_cb.Run(BT_STATUS_SUCCESS);



  // Notify success for set params. the advertise data call should succeed but

  // operation will remain pending.

  set_params_cb.Run(BT_STATUS_SUCCESS);

  EXPECT_FALSE(le_advertiser_->IsAdvertisingStarted());

  EXPECT_TRUE(le_advertiser_->IsStartingAdvertising());

  EXPECT_FALSE(le_advertiser_->IsStoppingAdvertising());

  EXPECT_EQ(1, callback_count);



  // Notify failure from advertising call.

  set_data_cb.Run(BT_STATUS_FAIL);

  EXPECT_FALSE(le_advertiser_->IsAdvertisingStarted());

  EXPECT_FALSE(le_advertiser_->IsStartingAdvertising());

  EXPECT_FALSE(le_advertiser_->IsStoppingAdvertising());

  EXPECT_EQ(2, callback_count);

  EXPECT_EQ(BLE_STATUS_FAILURE, last_status);



  // Try again. Make everything succeed.

  EXPECT_TRUE(le_advertiser_->StartAdvertising(

      settings, adv_data, scan_rsp, callback));

  EXPECT_FALSE(le_advertiser_->IsAdvertisingStarted());

  EXPECT_TRUE(le_advertiser_->IsStartingAdvertising());

  EXPECT_FALSE(le_advertiser_->IsStoppingAdvertising());

  EXPECT_EQ(2, callback_count);



  status_cb enable_cb;

  EXPECT_CALL(*mock_handler_, Enable(_, true, _, _, _))

      .Times(1)

      .WillOnce(SaveArg<2>(&enable_cb));



  set_params_cb.Run(BT_STATUS_SUCCESS);

  set_data_cb.Run(BT_STATUS_SUCCESS);

  enable_cb.Run(BT_STATUS_SUCCESS);

  EXPECT_TRUE(le_advertiser_->IsAdvertisingStarted());

  EXPECT_FALSE(le_advertiser_->IsStartingAdvertising());

  EXPECT_FALSE(le_advertiser_->IsStoppingAdvertising());

  EXPECT_EQ(3, callback_count);

  EXPECT_EQ(2, callback_count);

  EXPECT_EQ(BLE_STATUS_SUCCESS, last_status);



  // Already started.
@@ -462,88 +407,12 @@ TEST_F(LowEnergyAdvertiserPostRegisterTest, InvalidAdvertiseData) { 
  const std::vector<uint8_t> data2{ 0x01, HCI_EIR_MANUFACTURER_SPECIFIC_TYPE };

  AdvertiseData invalid_mfc(data2);



  EXPECT_CALL(*mock_handler_, SetParameters(_, _, _, _, _, _, _))

  EXPECT_CALL(*mock_handler_, StartAdvertising(_, _, _, _, _, _, _))

      .Times(1);

  EXPECT_TRUE(le_advertiser_->StartAdvertising(

      settings, invalid_mfc, valid_adv, LowEnergyAdvertiser::StatusCallback()));

}



TEST_F(LowEnergyAdvertiserPostRegisterTest, ScanResponse) {

  EXPECT_FALSE(le_advertiser_->IsAdvertisingStarted());

  EXPECT_FALSE(le_advertiser_->IsStartingAdvertising());

  EXPECT_FALSE(le_advertiser_->IsStoppingAdvertising());



  AdvertiseSettings settings(

      AdvertiseSettings::MODE_LOW_POWER,

      base::TimeDelta::FromMilliseconds(300),

      AdvertiseSettings::TX_POWER_LEVEL_MEDIUM,

      false /* connectable */);



  const std::vector<uint8_t> data0{0x02, HCI_EIR_TX_POWER_LEVEL_TYPE, 0x00};

  const std::vector<uint8_t> data1{

      0x05, HCI_EIR_COMPLETE_LOCAL_NAME_TYPE, 'a', 'b', 'c', 'd',

      0x04, HCI_EIR_MANUFACTURER_SPECIFIC_TYPE, 0x01, 0x02, 0x00

  };



  int callback_count = 0;

  BLEStatus last_status = BLE_STATUS_FAILURE;

  auto callback = [&](BLEStatus status) {

    last_status = status;

    callback_count++;

  };



  AdvertiseData adv0(data0);

  AdvertiseData adv1(data1);



  status_cb set_params_cb;

  EXPECT_CALL(*mock_handler_,

              SetParameters(le_advertiser_->GetInstanceId(), _, _,

                             kAdvertisingEventTypeScannable,

                             _, _, _))

      .Times(2)

      .WillRepeatedly(SaveArg<6>(&set_params_cb));

  status_cb set_adv_data_cb;

  EXPECT_CALL(

      *mock_handler_,

      SetData(_,

          false,  // set_scan_rsp

          _, _))

      .Times(2)

      .WillRepeatedly(SaveArg<3>(&set_adv_data_cb));

  status_cb set_scan_rsp_cb;

  EXPECT_CALL(*mock_handler_,

              SetData(_, true /* set_scan_rsp */, _, _))

      .Times(2)

      .WillRepeatedly(SaveArg<3>(&set_scan_rsp_cb));



  // Enable success; Adv. data success; Scan rsp. fail.

  EXPECT_TRUE(le_advertiser_->StartAdvertising(settings, adv0, adv1, callback));

  set_params_cb.Run(BT_STATUS_SUCCESS);

  set_adv_data_cb.Run(BT_STATUS_SUCCESS);

  set_adv_data_cb.Run(BT_STATUS_FAIL);



  EXPECT_EQ(1, callback_count);

  EXPECT_EQ(BLE_STATUS_FAILURE, last_status);

  EXPECT_FALSE(le_advertiser_->IsAdvertisingStarted());



  status_cb enable_cb;

  EXPECT_CALL(*mock_handler_,

              Enable(le_advertiser_->GetInstanceId(), true, _, _, _))

      .Times(1)

      .WillOnce(SaveArg<2>(&enable_cb));



  // Second time everything succeeds.

  EXPECT_TRUE(le_advertiser_->StartAdvertising(settings, adv0, adv1, callback));

  set_params_cb.Run(BT_STATUS_SUCCESS);

  set_adv_data_cb.Run(BT_STATUS_SUCCESS);

  set_adv_data_cb.Run(BT_STATUS_SUCCESS);

  enable_cb.Run(BT_STATUS_SUCCESS);



  EXPECT_EQ(2, callback_count);

  EXPECT_EQ(BLE_STATUS_SUCCESS, last_status);

  EXPECT_TRUE(le_advertiser_->IsAdvertisingStarted());

}



TEST_F(LowEnergyAdvertiserPostRegisterTest, AdvertiseDataParsing) {

  const std::vector<uint8_t> kUUID16BitData{

    0x03, HCI_EIR_COMPLETE_16BITS_UUID_TYPE, 0xDE, 0xAD,
@@ -619,20 +488,20 @@ TEST_F(LowEnergyAdvertiserPostRegisterTest, AdvertiseDataParsing) { 
    callback_count++;

  };



  status_cb set_data_cb;

  status_cb start_advertising_cb;

  // Multiple UUID test

  EXPECT_CALL(*mock_handler_, SetData(_, _, _, _))

  EXPECT_CALL(*mock_handler_, StartAdvertising(_, _, _, _, _, _, _))

            .Times(1)

      .WillOnce(SaveArg<3>(&set_data_cb));

  AdvertiseDataTestHelper(multi_uuid_adv, callback, &set_data_cb);

      .WillOnce(SaveArg<1>(&start_advertising_cb));

  AdvertiseDataTestHelper(multi_uuid_adv, callback, &start_advertising_cb);

  EXPECT_EQ(1, callback_count);

  ::testing::Mock::VerifyAndClearExpectations(mock_handler_.get());



  // Multiple Service Data test

  EXPECT_CALL(*mock_handler_, SetData(_, _, _, _))

  EXPECT_CALL(*mock_handler_, StartAdvertising(_, _, _, _, _, _, _))

            .Times(1)

      .WillOnce(SaveArg<3>(&set_data_cb));

  AdvertiseDataTestHelper(multi_service_adv, callback, &set_data_cb);

      .WillOnce(SaveArg<1>(&start_advertising_cb));

  AdvertiseDataTestHelper(multi_service_adv, callback, &start_advertising_cb);

  EXPECT_EQ(2, callback_count);

  ::testing::Mock::VerifyAndClearExpectations(mock_handler_.get());
@@ -641,11 +510,10 @@ TEST_F(LowEnergyAdvertiserPostRegisterTest, AdvertiseDataParsing) { 
  const std::vector<uint8_t> uuid_16bit_canonical{

      0xFB, 0x34, 0x9b, 0x5F, 0x80, 0x00, 0x00, 0x80,

      0x00, 0x10, 0x00, 0x00, 0xDE, 0xAD, 0x00, 0x00};

  EXPECT_CALL(*mock_handler_,

              SetData(_, _, _, _))

  EXPECT_CALL(*mock_handler_, StartAdvertising(_, _, _, _, _, _, _))

            .Times(1)

      .WillOnce(SaveArg<3>(&set_data_cb));

  AdvertiseDataTestHelper(uuid_16bit_adv, callback, &set_data_cb);

      .WillOnce(SaveArg<1>(&start_advertising_cb));

  AdvertiseDataTestHelper(uuid_16bit_adv, callback, &start_advertising_cb);

  EXPECT_EQ(3, callback_count);

  ::testing::Mock::VerifyAndClearExpectations(mock_handler_.get());
@@ -654,11 +522,10 @@ TEST_F(LowEnergyAdvertiserPostRegisterTest, AdvertiseDataParsing) { 
    0xFB, 0x34, 0x9b, 0x5F, 0x80, 0x00, 0x00, 0x80, 0x00, 0x10, 0x00, 0x00,

    0xDE, 0xAD, 0x01, 0x02

  };

  EXPECT_CALL(*mock_handler_,

              SetData(_, _, _, _))

  EXPECT_CALL(*mock_handler_, StartAdvertising(_, _, _, _, _, _, _))

            .Times(1)

      .WillOnce(SaveArg<3>(&set_data_cb));

  AdvertiseDataTestHelper(uuid_32bit_adv, callback, &set_data_cb);

      .WillOnce(SaveArg<1>(&start_advertising_cb));

  AdvertiseDataTestHelper(uuid_32bit_adv, callback, &start_advertising_cb);

  EXPECT_EQ(4, callback_count);

  ::testing::Mock::VerifyAndClearExpectations(mock_handler_.get());
@@ -667,11 +534,10 @@ TEST_F(LowEnergyAdvertiserPostRegisterTest, AdvertiseDataParsing) { 
    0xDE, 0xAD, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06,

    0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E

  };

  EXPECT_CALL(*mock_handler_,

              SetData(_, _, _, _))

  EXPECT_CALL(*mock_handler_, StartAdvertising(_, _, _, _, _, _, _))

            .Times(1)

      .WillOnce(SaveArg<3>(&set_data_cb));

  AdvertiseDataTestHelper(uuid_128bit_adv, callback, &set_data_cb);

      .WillOnce(SaveArg<1>(&start_advertising_cb));

  AdvertiseDataTestHelper(uuid_128bit_adv, callback, &start_advertising_cb);

  EXPECT_EQ(5, callback_count);

  ::testing::Mock::VerifyAndClearExpectations(mock_handler_.get());
@@ -679,46 +545,44 @@ TEST_F(LowEnergyAdvertiserPostRegisterTest, AdvertiseDataParsing) { 


  // Service data with 16bit uuid included, should succeed with

  // uuid and service data parsed out

  EXPECT_CALL(*mock_handler_,

              SetData(_, _, _, _))

  EXPECT_CALL(*mock_handler_, StartAdvertising(_, _, _, _, _, _, _))

            .Times(1)

      .WillOnce(SaveArg<3>(&set_data_cb));

  AdvertiseDataTestHelper(service_16bit_adv, callback, &set_data_cb);

      .WillOnce(SaveArg<1>(&start_advertising_cb));

  AdvertiseDataTestHelper(service_16bit_adv, callback, &start_advertising_cb);

  EXPECT_EQ(6, callback_count);

  ::testing::Mock::VerifyAndClearExpectations(mock_handler_.get());



  // Service data with 32bit uuid included, should succeed with

  // uuid and service data parsed out

  EXPECT_CALL(*mock_handler_,

              SetData(_, _, _, _))

  EXPECT_CALL(*mock_handler_, StartAdvertising(_, _, _, _, _, _, _))

            .Times(1)

      .WillOnce(SaveArg<3>(&set_data_cb));

  AdvertiseDataTestHelper(service_32bit_adv, callback, &set_data_cb);

      .WillOnce(SaveArg<1>(&start_advertising_cb));

  AdvertiseDataTestHelper(service_32bit_adv, callback, &start_advertising_cb);

  EXPECT_EQ(7, callback_count);

  ::testing::Mock::VerifyAndClearExpectations(mock_handler_.get());



  // Service data with 128bit uuid included, should succeed with

  // uuid and service data parsed out

  EXPECT_CALL(*mock_handler_, SetData(_, _, _, _))

  EXPECT_CALL(*mock_handler_, StartAdvertising(_, _, _, _, _, _, _))

            .Times(1)

      .WillOnce(SaveArg<3>(&set_data_cb));

  AdvertiseDataTestHelper(service_128bit_adv, callback, &set_data_cb);

      .WillOnce(SaveArg<1>(&start_advertising_cb));

  AdvertiseDataTestHelper(service_128bit_adv, callback, &start_advertising_cb);

  EXPECT_EQ(8, callback_count);

  ::testing::Mock::VerifyAndClearExpectations(mock_handler_.get());



  // Service data and UUID where the UUID for both match, should succeed.

  EXPECT_CALL(*mock_handler_, SetData(_, _, _, _))

  EXPECT_CALL(*mock_handler_, StartAdvertising(_, _, _, _, _, _, _))

            .Times(1)

      .WillOnce(SaveArg<3>(&set_data_cb));

  AdvertiseDataTestHelper(service_uuid_match, callback, &set_data_cb);

      .WillOnce(SaveArg<1>(&start_advertising_cb));

  AdvertiseDataTestHelper(service_uuid_match, callback, &start_advertising_cb);

  EXPECT_EQ(9, callback_count);

  ::testing::Mock::VerifyAndClearExpectations(mock_handler_.get());



  // Service data and UUID where the UUID for dont match, should fail

  EXPECT_CALL(*mock_handler_, SetData(_, _, _, _))

  EXPECT_CALL(*mock_handler_, StartAdvertising(_, _, _, _, _, _, _))

      .Times(1)

      .WillOnce(SaveArg<3>(&set_data_cb));

  AdvertiseDataTestHelper(service_uuid_match, callback, &set_data_cb);

      .WillOnce(SaveArg<1>(&start_advertising_cb));

  AdvertiseDataTestHelper(service_uuid_match, callback, &start_advertising_cb);

  EXPECT_EQ(10, callback_count);

  ::testing::Mock::VerifyAndClearExpectations(mock_handler_.get());

}

system/stack/btm/btm_ble_multi_adv.cc

+66 −0

File changed.

Preview size limit exceeded, changes collapsed.