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

Commit 63c4d588 authored by Treehugger Robot's avatar Treehugger Robot Committed by Automerger Merge Worker
Browse files

Merge "[DCK] Manage all advertiser IDs inside the handler thread" am:... 

Merge "[DCK] Manage all advertiser IDs inside the handler thread" am: bcc66e11 am: 79821b77 am: 1108a6d2 am: c746bb31

Original change: https://android-review.googlesource.com/c/platform/packages/modules/Bluetooth/+/2572794



Change-Id: I8d99633b5906c7bf7ab6bcfa17b66ebb706fb714
Signed-off-by: default avatarAutomerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
parents 14ad9d0e c746bb31

android/app/jni/com_android_bluetooth_gatt.cpp

+13 −10
Original line number Diff line number Diff line
@@ -2329,11 +2329,19 @@ static PeriodicAdvertisingParameters parsePeriodicParams(JNIEnv* env, 
  return p;

}



static void ble_advertising_set_started_cb(int reg_id, uint8_t advertiser_id,

static void ble_advertising_set_started_cb(int reg_id, int server_if,

                                           uint8_t advertiser_id,

                                           int8_t tx_power, uint8_t status) {

  std::shared_lock<std::shared_mutex> lock(callbacks_mutex);

  CallbackEnv sCallbackEnv(__func__);

  if (!sCallbackEnv.valid() || !mAdvertiseCallbacksObj) return;



  // tie advertiser ID to server_if, once the advertisement has started

  if (status == 0 /* AdvertisingCallback::AdvertisingStatus::SUCCESS */ &&

      server_if != 0) {

    bluetooth::gatt::associate_server_with_advertiser(server_if, advertiser_id);

  }



  sCallbackEnv->CallVoidMethod(mAdvertiseCallbacksObj,

                               method_onAdvertisingSetStarted, reg_id,

                               advertiser_id, tx_power, status);
@@ -2376,15 +2384,10 @@ static void startAdvertisingSetNative( 
      periodic_data_data, periodic_data_data + periodic_data_len);

  env->ReleaseByteArrayElements(periodic_data, periodic_data_data, JNI_ABORT);



  auto advertiser_id = sGattIf->advertiser->StartAdvertisingSet(

      reg_id, base::Bind(&ble_advertising_set_started_cb, reg_id), params,

      data_vec, scan_resp_vec, periodicParams, periodic_data_vec, duration,

      maxExtAdvEvents, base::Bind(ble_advertising_set_timeout_cb));



  // tie advertiser ID to server_if

  if (server_if != 0) {

    bluetooth::gatt::associate_server_with_advertiser(server_if, advertiser_id);

  }

  sGattIf->advertiser->StartAdvertisingSet(

      reg_id, base::Bind(&ble_advertising_set_started_cb, reg_id, server_if),

      params, data_vec, scan_resp_vec, periodicParams, periodic_data_vec,

      duration, maxExtAdvEvents, base::Bind(ble_advertising_set_timeout_cb));

}



static void stopAdvertisingSetNative(JNIEnv* env, jobject object,

system/btif/src/btif_ble_advertiser.cc

+10 −10
Original line number Diff line number Diff line
@@ -190,7 +190,7 @@ class BleAdvertiserInterfaceImpl : public BleAdvertiserInterface { 
             timeout_s * 100, jni_thread_wrapper(FROM_HERE, timeout_cb)));

  }



  uint8_t StartAdvertisingSet(int reg_id, IdTxPowerStatusCallback cb,

  void StartAdvertisingSet(int reg_id, IdTxPowerStatusCallback cb,

                           AdvertiseParameters params,

                           std::vector<uint8_t> advertise_data,

                           std::vector<uint8_t> scan_response_data,
@@ -200,7 +200,7 @@ class BleAdvertiserInterfaceImpl : public BleAdvertiserInterface { 
                           IdStatusCallback timeout_cb) override {

    VLOG(1) << __func__;



    if (!BleAdvertisingManager::IsInitialized()) return {};

    if (!BleAdvertisingManager::IsInitialized()) return;

    tBTM_BLE_ADV_PARAMS* p_params = new tBTM_BLE_ADV_PARAMS;

    parseParams(p_params, params);
@@ -216,7 +216,7 @@ class BleAdvertiserInterfaceImpl : public BleAdvertiserInterface { 
             std::move(periodic_data), duration, maxExtAdvEvents,

             jni_thread_wrapper(FROM_HERE, timeout_cb)));



    return {};

    return;

  }



  void SetPeriodicAdvertisingParameters(

system/gd/hci/facade/le_advertising_manager_facade.cc

+17 −3
Original line number Diff line number Diff line
@@ -218,6 +218,7 @@ class LeAdvertisingManagerFacadeService : public LeAdvertisingManagerFacade::Ser 
      : le_advertising_manager_(le_advertising_manager), facade_handler_(facade_handler) {

    ASSERT(le_advertising_manager_ != nullptr);

    ASSERT(facade_handler_ != nullptr);

    le_advertising_manager_->RegisterAdvertisingCallback(this);

  }



  ::grpc::Status CreateAdvertiser(::grpc::ServerContext* context, const CreateAdvertiserRequest* request,
@@ -229,7 +230,10 @@ class LeAdvertisingManagerFacadeService : public LeAdvertisingManagerFacade::Ser 
      return ::grpc::Status(::grpc::StatusCode::INVALID_ARGUMENT, "Error while parsing advertising config");

    }

    LeAdvertiser le_advertiser(config);

    auto advertiser_id = le_advertising_manager_->ExtendedCreateAdvertiser(



    pending_advertiser_id_ = std::promise<AdvertiserId>();

    auto future = pending_advertiser_id_->get_future();

    le_advertising_manager_->ExtendedCreateAdvertiser(

        0,

        config,

        common::Bind(&LeAdvertiser::ScanCallback, common::Unretained(&le_advertiser)),
@@ -237,6 +241,8 @@ class LeAdvertisingManagerFacadeService : public LeAdvertisingManagerFacade::Ser 
        0,

        0,

        facade_handler_);



    auto advertiser_id = future.get();

    if (advertiser_id != LeAdvertisingManager::kInvalidId) {

      le_advertiser.SetAdvertiserId(advertiser_id);

      le_advertisers_.push_back(le_advertiser);
@@ -257,7 +263,9 @@ class LeAdvertisingManagerFacadeService : public LeAdvertisingManagerFacade::Ser 
      return ::grpc::Status(::grpc::StatusCode::INVALID_ARGUMENT, "Error while parsing advertising config");

    }

    LeAdvertiser le_advertiser(config);

    auto advertiser_id = le_advertising_manager_->ExtendedCreateAdvertiser(

    pending_advertiser_id_ = std::promise<AdvertiserId>();

    auto future = pending_advertiser_id_->get_future();

    le_advertising_manager_->ExtendedCreateAdvertiser(

        0,

        config,

        common::Bind(&LeAdvertiser::ScanCallback, common::Unretained(&le_advertiser)),
@@ -265,6 +273,8 @@ class LeAdvertisingManagerFacadeService : public LeAdvertisingManagerFacade::Ser 
        0,

        0,

        facade_handler_);



    auto advertiser_id = future.get();

    if (advertiser_id != LeAdvertisingManager::kInvalidId) {

      le_advertiser.SetAdvertiserId(advertiser_id);

      le_advertisers_.push_back(le_advertiser);
@@ -377,7 +387,6 @@ class LeAdvertisingManagerFacadeService : public LeAdvertisingManagerFacade::Ser 
      ::grpc::ServerContext* context,

      const ::google::protobuf::Empty* request,

      ::grpc::ServerWriter<AdvertisingCallbackMsg>* writer) override {

    le_advertising_manager_->RegisterAdvertisingCallback(this);

    return callback_events_.RunLoop(context, writer);

  }
@@ -389,6 +398,10 @@ class LeAdvertisingManagerFacadeService : public LeAdvertisingManagerFacade::Ser 
  }



  void OnAdvertisingSetStarted(int reg_id, uint8_t advertiser_id, int8_t tx_power, AdvertisingStatus status) {

    if (pending_advertiser_id_.has_value()) {

      pending_advertiser_id_->set_value(advertiser_id);

      pending_advertiser_id_.reset();

    }

    AdvertisingCallbackMsg msg;

    msg.set_message_type(AdvertisingCallbackMsgType::ADVERTISING_SET_STARTED);

    msg.set_advertiser_id(advertiser_id);
@@ -469,6 +482,7 @@ class LeAdvertisingManagerFacadeService : public LeAdvertisingManagerFacade::Ser 


  std::vector<LeAdvertiser> le_advertisers_;

  LeAdvertisingManager* le_advertising_manager_;

  std::optional<std::promise<AdvertiserId>> pending_advertiser_id_;

  os::Handler* facade_handler_;

  ::bluetooth::grpc::GrpcEventQueue<AdvertisingCallbackMsg> callback_events_{"callback events"};

  ::bluetooth::grpc::GrpcEventQueue<AddressMsg> address_events_{"address events"};

system/gd/hci/le_advertising_manager.cc

+103 −85
Original line number Diff line number Diff line
@@ -330,8 +330,6 @@ struct LeAdvertisingManager::impl : public bluetooth::hci::LeAddressManagerCallb 
  AdvertiserId allocate_advertiser() {

    // number of LE_MULTI_ADVT start from 1

    AdvertiserId id = advertising_api_type_ == AdvertisingApiType::ANDROID_HCI ? 1 : 0;

    {

      std::unique_lock lock(id_mutex_);

    while (id < num_instances_ && advertising_sets_.count(id) != 0) {

      id++;

    }
@@ -340,7 +338,6 @@ struct LeAdvertisingManager::impl : public bluetooth::hci::LeAddressManagerCallb 
      return kInvalidId;

    }

    advertising_sets_[id].in_use = true;

    }

    return id;

  }
@@ -393,11 +390,27 @@ struct LeAdvertisingManager::impl : public bluetooth::hci::LeAddressManagerCallb 
  }



  void create_advertiser(

      int reg_id,

      const AdvertisingConfig config,

      common::Callback<void(Address, AddressType)> scan_callback,

      common::Callback<void(ErrorCode, uint8_t, uint8_t)> set_terminated_callback,

      os::Handler* handler) {

    AdvertiserId id = allocate_advertiser();

    if (id == kInvalidId) {

      LOG_WARN("Number of max instances reached");

      start_advertising_fail(reg_id, AdvertisingCallback::AdvertisingStatus::TOO_MANY_ADVERTISERS);

      return;

    }



    create_advertiser_with_id(reg_id, id, config, scan_callback, set_terminated_callback, handler);

  }



  void create_advertiser_with_id(

      int reg_id,

      AdvertiserId id,

      const AdvertisingConfig config,

      const common::Callback<void(Address, AddressType)>& scan_callback,

      const common::Callback<void(ErrorCode, uint8_t, uint8_t)>& set_terminated_callback,

      common::Callback<void(Address, AddressType)> scan_callback,

      common::Callback<void(ErrorCode, uint8_t, uint8_t)> set_terminated_callback,

      os::Handler* handler) {

    // check advertising data is valid before start advertising

    if (!check_advertising_data(config.advertisement, config.connectable && config.discoverable) ||
@@ -465,28 +478,55 @@ struct LeAdvertisingManager::impl : public bluetooth::hci::LeAddressManagerCallb 
      uint16_t duration,

      base::OnceCallback<void(uint8_t /* status */)> status_callback,

      base::OnceCallback<void(uint8_t /* status */)> timeout_callback,

      const common::Callback<void(Address, AddressType)>& scan_callback,

      const common::Callback<void(ErrorCode, uint8_t, uint8_t)>& set_terminated_callback,

      const common::Callback<void(Address, AddressType)> scan_callback,

      const common::Callback<void(ErrorCode, uint8_t, uint8_t)> set_terminated_callback,

      os::Handler* handler) {

    advertising_sets_[id].status_callback = std::move(status_callback);

    advertising_sets_[id].timeout_callback = std::move(timeout_callback);



    create_extended_advertiser(kIdLocal, id, config, scan_callback, set_terminated_callback, duration, 0, handler);

    create_extended_advertiser_with_id(

        kIdLocal, id, config, scan_callback, set_terminated_callback, duration, 0, handler);

  }



  void create_extended_advertiser(

      int reg_id,

      const AdvertisingConfig config,

      common::Callback<void(Address, AddressType)> scan_callback,

      common::Callback<void(ErrorCode, uint8_t, uint8_t)> set_terminated_callback,

      uint16_t duration,

      uint8_t max_ext_adv_events,

      os::Handler* handler) {

    AdvertiserId id = allocate_advertiser();

    if (id == kInvalidId) {

      LOG_WARN("Number of max instances reached");

      start_advertising_fail(reg_id, AdvertisingCallback::AdvertisingStatus::TOO_MANY_ADVERTISERS);

      return;

    }

    create_extended_advertiser_with_id(

        reg_id,

        id,

        config,

        scan_callback,

        set_terminated_callback,

        duration,

        max_ext_adv_events,

        handler);

  }



  void create_extended_advertiser_with_id(

      int reg_id,

      AdvertiserId id,

      const AdvertisingConfig config,

      const common::Callback<void(Address, AddressType)>& scan_callback,

      const common::Callback<void(ErrorCode, uint8_t, uint8_t)>& set_terminated_callback,

      common::Callback<void(Address, AddressType)> scan_callback,

      common::Callback<void(ErrorCode, uint8_t, uint8_t)> set_terminated_callback,

      uint16_t duration,

      uint8_t max_ext_adv_events,

      os::Handler* handler) {

    id_map_[id] = reg_id;



    if (advertising_api_type_ != AdvertisingApiType::EXTENDED) {

      create_advertiser(reg_id, id, config, scan_callback, set_terminated_callback, handler);

      create_advertiser_with_id(

          reg_id, id, config, scan_callback, set_terminated_callback, handler);

      return;

    }
@@ -661,6 +701,16 @@ struct LeAdvertisingManager::impl : public bluetooth::hci::LeAddressManagerCallb 
        le_address_manager_->GetNextPrivateAddressIntervalMs());

  }



  void register_advertiser(

      common::ContextualOnceCallback<void(uint8_t /* inst_id */, uint8_t /* status */)> callback) {

    AdvertiserId id = allocate_advertiser();

    if (id == kInvalidId) {

      callback.Invoke(kInvalidId, AdvertisingCallback::AdvertisingStatus::TOO_MANY_ADVERTISERS);

    } else {

      callback.Invoke(id, AdvertisingCallback::AdvertisingStatus::SUCCESS);

    }

  }



  void get_own_address(AdvertiserId advertiser_id) {

    if (advertising_sets_.find(advertiser_id) == advertising_sets_.end()) {

      LOG_INFO("Unknown advertising id %u", advertiser_id);
@@ -1588,54 +1638,38 @@ size_t LeAdvertisingManager::GetNumberOfAdvertisingInstances() const { 
  return pimpl_->GetNumberOfAdvertisingInstances();

}



AdvertiserId LeAdvertisingManager::create_advertiser(

void LeAdvertisingManager::ExtendedCreateAdvertiser(

    int reg_id,

    const AdvertisingConfig config,

    const common::Callback<void(Address, AddressType)>& scan_callback,

    const common::Callback<void(ErrorCode, uint8_t, uint8_t)>& set_terminated_callback,

    common::Callback<void(Address, AddressType)> scan_callback,

    common::Callback<void(ErrorCode, uint8_t, uint8_t)> set_terminated_callback,

    uint16_t duration,

    uint8_t max_extended_advertising_events,

    os::Handler* handler) {

  AdvertisingApiType advertising_api_type = pimpl_->get_advertising_api_type();

  if (advertising_api_type != AdvertisingApiType::EXTENDED) {

    if (config.peer_address == Address::kEmpty) {

      if (config.advertising_type == hci::AdvertisingType::ADV_DIRECT_IND_HIGH ||

          config.advertising_type == hci::AdvertisingType::ADV_DIRECT_IND_LOW) {

        LOG_WARN("Peer address can not be empty for directed advertising");

      CallOn(

          pimpl_.get(), &impl::start_advertising_fail, reg_id, AdvertisingCallback::AdvertisingStatus::INTERNAL_ERROR);

      return kInvalidId;

    }

  }

  AdvertiserId id = pimpl_->allocate_advertiser();

  if (id == kInvalidId) {

    LOG_WARN("Number of max instances reached");

        CallOn(

            pimpl_.get(),

            &impl::start_advertising_fail,

            reg_id,

        AdvertisingCallback::AdvertisingStatus::TOO_MANY_ADVERTISERS);

    return id;

            AdvertisingCallback::AdvertisingStatus::INTERNAL_ERROR);

        return;

      }

    }

    GetHandler()->Post(common::BindOnce(

        &impl::create_advertiser,

        common::Unretained(pimpl_.get()),

        reg_id,

      id,

        config,

        scan_callback,

        set_terminated_callback,

        handler));

  return id;

}



AdvertiserId LeAdvertisingManager::ExtendedCreateAdvertiser(

    int reg_id,

    const AdvertisingConfig config,

    const common::Callback<void(Address, AddressType)>& scan_callback,

    const common::Callback<void(ErrorCode, uint8_t, uint8_t)>& set_terminated_callback,

    uint16_t duration,

    uint8_t max_extended_advertising_events,

    os::Handler* handler) {

  AdvertisingApiType advertising_api_type = pimpl_->get_advertising_api_type();

  if (advertising_api_type != AdvertisingApiType::EXTENDED) {

    return create_advertiser(reg_id, config, scan_callback, set_terminated_callback, handler);

    return;

  };



  if (config.directed) {
@@ -1643,55 +1677,44 @@ AdvertiserId LeAdvertisingManager::ExtendedCreateAdvertiser( 
      LOG_INFO("Peer address can not be empty for directed advertising");

      CallOn(

          pimpl_.get(), &impl::start_advertising_fail, reg_id, AdvertisingCallback::AdvertisingStatus::INTERNAL_ERROR);

      return kInvalidId;

      return;

    }

  }

  if (config.channel_map == 0) {

    LOG_INFO("At least one channel must be set in the map");

    CallOn(pimpl_.get(), &impl::start_advertising_fail, reg_id, AdvertisingCallback::AdvertisingStatus::INTERNAL_ERROR);

    return kInvalidId;

    return;

  }

  if (!config.legacy_pdus) {

    if (config.connectable && config.scannable) {

      LOG_INFO("Extended advertising PDUs can not be connectable and scannable");

      CallOn(

          pimpl_.get(), &impl::start_advertising_fail, reg_id, AdvertisingCallback::AdvertisingStatus::INTERNAL_ERROR);

      return kInvalidId;

      return;

    }

    if (config.high_duty_directed_connectable) {

      LOG_INFO("Extended advertising PDUs can not be high duty cycle");

      CallOn(

          pimpl_.get(), &impl::start_advertising_fail, reg_id, AdvertisingCallback::AdvertisingStatus::INTERNAL_ERROR);

      return kInvalidId;

      return;

    }

  }

  if (config.interval_min > config.interval_max) {

    LOG_INFO("Advertising interval: min (%hu) > max (%hu)", config.interval_min, config.interval_max);

    CallOn(pimpl_.get(), &impl::start_advertising_fail, reg_id, AdvertisingCallback::AdvertisingStatus::INTERNAL_ERROR);

    return kInvalidId;

  }

  AdvertiserId id = pimpl_->allocate_advertiser();

  if (id == kInvalidId) {

    LOG_WARN("Number of max instances reached");

    CallOn(

        pimpl_.get(),

        &impl::start_advertising_fail,

        reg_id,

        AdvertisingCallback::AdvertisingStatus::TOO_MANY_ADVERTISERS);

    return id;

    return;

  }

  CallOn(

      pimpl_.get(),

      &impl::create_extended_advertiser,

      reg_id,

      id,

      config,

      scan_callback,

      set_terminated_callback,

      duration,

      max_extended_advertising_events,

      handler);

  return id;

  return;

}



void LeAdvertisingManager::StartAdvertising(
@@ -1700,8 +1723,8 @@ void LeAdvertisingManager::StartAdvertising( 
    uint16_t duration,

    base::OnceCallback<void(uint8_t /* status */)> status_callback,

    base::OnceCallback<void(uint8_t /* status */)> timeout_callback,

    const common::Callback<void(Address, AddressType)>& scan_callback,

    const common::Callback<void(ErrorCode, uint8_t, uint8_t)>& set_terminated_callback,

    common::Callback<void(Address, AddressType)> scan_callback,

    common::Callback<void(ErrorCode, uint8_t, uint8_t)> set_terminated_callback,

    os::Handler* handler) {

  CallOn(

      pimpl_.get(),
@@ -1717,13 +1740,8 @@ void LeAdvertisingManager::StartAdvertising( 
}



void LeAdvertisingManager::RegisterAdvertiser(

    base::OnceCallback<void(uint8_t /* inst_id */, uint8_t /* status */)> callback) {

  AdvertiserId id = pimpl_->allocate_advertiser();

  if (id == kInvalidId) {

    std::move(callback).Run(kInvalidId, AdvertisingCallback::AdvertisingStatus::TOO_MANY_ADVERTISERS);

  } else {

    std::move(callback).Run(id, AdvertisingCallback::AdvertisingStatus::SUCCESS);

  }

    common::ContextualOnceCallback<void(uint8_t /* inst_id */, uint8_t /* status */)> callback) {

  CallOn(pimpl_.get(), &impl::register_advertiser, std::move(callback));

}



void LeAdvertisingManager::GetOwnAddress(uint8_t advertiser_id) {

system/gd/hci/le_advertising_manager.h

+7 −13
Original line number Diff line number Diff line
@@ -111,11 +111,11 @@ class LeAdvertisingManager : public bluetooth::Module { 


  size_t GetNumberOfAdvertisingInstances() const;



  AdvertiserId ExtendedCreateAdvertiser(

  void ExtendedCreateAdvertiser(

      int reg_id,

      const AdvertisingConfig config,

      const common::Callback<void(Address, AddressType)>& scan_callback,

      const common::Callback<void(ErrorCode, uint8_t, uint8_t)>& set_terminated_callback,

      common::Callback<void(Address, AddressType)> scan_callback,

      common::Callback<void(ErrorCode, uint8_t, uint8_t)> set_terminated_callback,

      uint16_t duration,

      uint8_t max_extended_advertising_events,

      os::Handler* handler);
@@ -126,13 +126,14 @@ class LeAdvertisingManager : public bluetooth::Module { 
      uint16_t duration,

      base::OnceCallback<void(uint8_t /* status */)> status_callback,

      base::OnceCallback<void(uint8_t /* status */)> timeout_callback,

      const common::Callback<void(Address, AddressType)>& scan_callback,

      const common::Callback<void(ErrorCode, uint8_t, uint8_t)>& set_terminated_callback,

      common::Callback<void(Address, AddressType)> scan_callback,

      common::Callback<void(ErrorCode, uint8_t, uint8_t)> set_terminated_callback,

      os::Handler* handler);



  void GetOwnAddress(uint8_t advertiser_id);



  void RegisterAdvertiser(base::OnceCallback<void(uint8_t /* inst_id */, uint8_t /* status */)> callback);

  void RegisterAdvertiser(

      common::ContextualOnceCallback<void(uint8_t /* inst_id */, uint8_t /* status */)> callback);



  void SetParameters(AdvertiserId advertiser_id, AdvertisingConfig config);
@@ -163,13 +164,6 @@ class LeAdvertisingManager : public bluetooth::Module { 
  std::string ToString() const override;



 private:

  // Return -1 if the advertiser was not created, otherwise the advertiser ID.

  AdvertiserId create_advertiser(

      int reg_id,

      const AdvertisingConfig config,

      const common::Callback<void(Address, AddressType)>& scan_callback,

      const common::Callback<void(ErrorCode, uint8_t, uint8_t)>& set_terminated_callback,

      os::Handler* handler);

  struct impl;

  std::unique_ptr<impl> pimpl_;

};