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

Commit a260cdb3 authored by Jakub Pawlowski's avatar Jakub Pawlowski Committed by android-build-merger
Browse files

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

am: fdb8af19

Change-Id: Id4350dc5b6ba474106026eb1d781c341ceee8c78
parents 77d3c056 fdb8af19

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.