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

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

Merge "[GD] Implement Advertising APIs for OOB" am: 20d9d331 

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

Change-Id: Ib562f5736383021b8f0e41305c740bd3e9c6dea5
parents 00fb621c 20d9d331

system/gd/hci/le_advertising_manager.cc

+80 −5
Original line number Diff line number Diff line
@@ -33,6 +33,7 @@ namespace bluetooth { 
namespace hci {



const ModuleFactory LeAdvertisingManager::Factory = ModuleFactory([]() { return new LeAdvertisingManager(); });

constexpr int kIdLocal = 0xff;  // Id for advertiser not register from Java layer



enum class AdvertisingApiType {

  LEGACY = 1,
@@ -51,6 +52,8 @@ enum class AdvertisingFlag : uint8_t { 
struct Advertiser {

  os::Handler* handler;

  AddressWithType current_address;

  base::Callback<void(uint8_t /* status */)> status_callback;

  base::Callback<void(uint8_t /* status */)> timeout_callback;

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

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

  int8_t tx_power;
@@ -186,7 +189,14 @@ struct LeAdvertisingManager::impl : public bluetooth::hci::LeAddressManagerCallb 
    auto status = event_view.GetStatus();

    acl_manager_->OnAdvertisingSetTerminated(status, event_view.GetConnectionHandle(), advertiser_address);

    if (status == ErrorCode::LIMIT_REACHED || status == ErrorCode::ADVERTISING_TIMEOUT) {

      if (id_map_[advertiser_id] == kIdLocal) {

        if (!advertising_sets_[advertiser_id].timeout_callback.is_null()) {

          advertising_sets_[advertiser_id].timeout_callback.Run((uint8_t)status);

          advertising_sets_[advertiser_id].timeout_callback.Reset();

        }

      } else {

        advertising_callbacks_->OnAdvertisingEnabled(advertiser_id, false, (uint8_t)status);

      }

      return;

    }
@@ -304,6 +314,21 @@ struct LeAdvertisingManager::impl : public bluetooth::hci::LeAddressManagerCallb 
    }

  }



  void start_advertising(

      AdvertiserId id,

      const ExtendedAdvertisingConfig config,

      uint16_t duration,

      const base::Callback<void(uint8_t /* status */)>& status_callback,

      const base::Callback<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,

      os::Handler* handler) {

    advertising_sets_[id].status_callback = status_callback;

    advertising_sets_[id].timeout_callback = timeout_callback;



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

  }



  void create_extended_advertiser(

      int reg_id,

      AdvertiserId id,
@@ -975,6 +1000,7 @@ struct LeAdvertisingManager::impl : public bluetooth::hci::LeAddressManagerCallb 
  std::mutex id_mutex_;

  size_t num_instances_;

  std::vector<hci::EnabledSet> enabled_sets_;

  // map to mapping the id from java layer and advertier id

  std::map<uint8_t, int> id_map_;



  AdvertisingApiType advertising_api_type_{0};
@@ -1016,6 +1042,14 @@ struct LeAdvertisingManager::impl : public bluetooth::hci::LeAddressManagerCallb 
        continue;

      }



      if (id_map_[id] == kIdLocal) {

        if (!advertising_sets_[enabled_set.advertising_handle_].status_callback.is_null()) {

          advertising_sets_[enabled_set.advertising_handle_].status_callback.Run(advertising_status);

          advertising_sets_[enabled_set.advertising_handle_].status_callback.Reset();

        }

        continue;

      }



      if (started) {

        advertising_callbacks_->OnAdvertisingEnabled(id, enable, advertising_status);

      } else {
@@ -1050,6 +1084,14 @@ struct LeAdvertisingManager::impl : public bluetooth::hci::LeAddressManagerCallb 
        continue;

      }



      if (id_map_[id] == kIdLocal) {

        if (!advertising_sets_[enabled_set.advertising_handle_].status_callback.is_null()) {

          advertising_sets_[enabled_set.advertising_handle_].status_callback.Run(advertising_status);

          advertising_sets_[enabled_set.advertising_handle_].status_callback.Reset();

        }

        continue;

      }



      if (started) {

        advertising_callbacks_->OnAdvertisingEnabled(id, enable, advertising_status);

      } else {
@@ -1072,7 +1114,7 @@ struct LeAdvertisingManager::impl : public bluetooth::hci::LeAddressManagerCallb 
    }

    advertising_sets_[id].tx_power = complete_view.GetSelectedTxPower();



    if (advertising_sets_[id].started) {

    if (advertising_sets_[id].started && id_map_[id] != kIdLocal) {

      advertising_callbacks_->OnAdvertisingParametersUpdated(id, advertising_sets_[id].tx_power, advertising_status);

    }

  }
@@ -1088,7 +1130,7 @@ struct LeAdvertisingManager::impl : public bluetooth::hci::LeAddressManagerCallb 
      advertising_status = AdvertisingCallback::AdvertisingStatus::INTERNAL_ERROR;

    }



    if (advertising_callbacks_ == nullptr || !advertising_sets_[id].started) {

    if (advertising_callbacks_ == nullptr || !advertising_sets_[id].started || id_map_[id] == kIdLocal) {

      return;

    }
@@ -1129,8 +1171,9 @@ struct LeAdvertisingManager::impl : public bluetooth::hci::LeAddressManagerCallb 
      advertising_status = AdvertisingCallback::AdvertisingStatus::INTERNAL_ERROR;

    }



    // Do not trigger callback if the advertiser not stated yet

    if (advertising_callbacks_ == nullptr || !advertising_sets_[id].started) {

    // Do not trigger callback if the advertiser not stated yet, or the advertiser is not register

    // from Java layer

    if (advertising_callbacks_ == nullptr || !advertising_sets_[id].started || id_map_[id] == kIdLocal) {

      return;

    }
@@ -1300,6 +1343,38 @@ AdvertiserId LeAdvertisingManager::ExtendedCreateAdvertiser( 
  return id;

}



void LeAdvertisingManager::StartAdvertising(

    AdvertiserId advertiser_id,

    const ExtendedAdvertisingConfig config,

    uint16_t duration,

    const base::Callback<void(uint8_t /* status */)>& status_callback,

    const base::Callback<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,

    os::Handler* handler) {

  CallOn(

      pimpl_.get(),

      &impl::start_advertising,

      advertiser_id,

      config,

      duration,

      status_callback,

      timeout_callback,

      scan_callback,

      set_terminated_callback,

      handler);

}



void LeAdvertisingManager::RegisterAdvertiser(

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

  AdvertiserId id = pimpl_->allocate_advertiser();

  if (id == kInvalidId) {

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

  } else {

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

  }

}



void LeAdvertisingManager::GetOwnAddress(uint8_t advertiser_id) {

  CallOn(pimpl_.get(), &impl::get_own_address, advertiser_id);

}

system/gd/hci/le_advertising_manager.h

+12 −0
Original line number Diff line number Diff line
@@ -116,8 +116,20 @@ class LeAdvertisingManager : public bluetooth::Module { 
      uint8_t max_extended_advertising_events,

      os::Handler* handler);



  void StartAdvertising(

      AdvertiserId advertiser_id,

      const ExtendedAdvertisingConfig config,

      uint16_t duration,

      const base::Callback<void(uint8_t /* status */)>& status_callback,

      const base::Callback<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,

      os::Handler* handler);



  void GetOwnAddress(uint8_t advertiser_id);



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



  void SetParameters(AdvertiserId advertiser_id, ExtendedAdvertisingConfig config);



  void SetData(AdvertiserId advertiser_id, bool set_scan_rsp, std::vector<GapData> data);

system/main/shim/le_advertising_manager.cc

+43 −1
Original line number Diff line number Diff line
@@ -59,9 +59,9 @@ class BleAdvertiserInterfaceImpl : public BleAdvertiserInterface, 
    bluetooth::shim::GetAdvertising()->RegisterAdvertisingCallback(this);

  }



  // nobody use this function

  void RegisterAdvertiser(IdStatusCallback cb) override {

    LOG(INFO) << __func__ << " in shim layer";

    bluetooth::shim::GetAdvertising()->RegisterAdvertiser(cb);

  }



  void Unregister(uint8_t advertiser_id) override {
@@ -73,6 +73,7 @@ class BleAdvertiserInterfaceImpl : public BleAdvertiserInterface, 


  void GetOwnAddress(uint8_t advertiser_id, GetAddressCallback cb) override {

    LOG(INFO) << __func__ << " in shim layer";

    address_callbacks_[advertiser_id] = cb;

    bluetooth::shim::GetAdvertising()->GetOwnAddress(advertiser_id);

  }
@@ -123,6 +124,41 @@ class BleAdvertiserInterfaceImpl : public BleAdvertiserInterface, 
                        std::vector<uint8_t> scan_response_data, int timeout_s,

                        MultiAdvCb timeout_cb) override {

    LOG(INFO) << __func__ << " in shim layer";



    bluetooth::hci::ExtendedAdvertisingConfig config{};

    parse_parameter(config, params);



    size_t offset = 0;

    while (offset < advertise_data.size()) {

      GapData gap_data;

      uint8_t len = advertise_data[offset];

      auto begin = advertise_data.begin() + offset;

      auto end = begin + len + 1;  // 1 byte for len

      auto data_copy = std::make_shared<std::vector<uint8_t>>(begin, end);

      bluetooth::packet::PacketView<bluetooth::packet::kLittleEndian> packet(

          data_copy);

      GapData::Parse(&gap_data, packet.begin());

      config.advertisement.push_back(gap_data);

      offset += len + 1;  // 1 byte for len

    }



    offset = 0;

    while (offset < scan_response_data.size()) {

      GapData gap_data;

      uint8_t len = scan_response_data[offset];

      auto begin = scan_response_data.begin() + offset;

      auto end = begin + len + 1;  // 1 byte for len

      auto data_copy = std::make_shared<std::vector<uint8_t>>(begin, end);

      bluetooth::packet::PacketView<bluetooth::packet::kLittleEndian> packet(

          data_copy);

      GapData::Parse(&gap_data, packet.begin());

      config.scan_response.push_back(gap_data);

      offset += len + 1;  // 1 byte for len

    }



    bluetooth::shim::GetAdvertising()->StartAdvertising(

        advertiser_id, config, timeout_s * 100, cb, timeout_cb, scan_callback,

        set_terminated_callback, bluetooth::shim::GetGdShimHandler());

  }



  void StartAdvertisingSet(int reg_id, IdTxPowerStatusCallback register_cb,
@@ -331,6 +367,11 @@ class BleAdvertiserInterfaceImpl : public BleAdvertiserInterface, 
  void OnOwnAddressRead(uint8_t advertiser_id, uint8_t address_type,

                        bluetooth::hci::Address address) {

    RawAddress raw_address = bluetooth::ToRawAddress(address);

    if (address_callbacks_.find(advertiser_id) != address_callbacks_.end()) {

      address_callbacks_[advertiser_id].Run(address_type, raw_address);

      address_callbacks_.erase(advertiser_id);

      return;

    }

    do_in_jni_thread(FROM_HERE,

                     base::Bind(&AdvertisingCallbacks::OnOwnAddressRead,

                                base::Unretained(advertising_callbacks_),
@@ -362,6 +403,7 @@ class BleAdvertiserInterfaceImpl : public BleAdvertiserInterface, 
    // TODO set own_address_type based on address policy

    config.own_address_type = OwnAddressType::RANDOM_DEVICE_ADDRESS;

  }

  std::map<uint8_t, GetAddressCallback> address_callbacks_;

};



BleAdvertiserInterfaceImpl* bt_le_advertiser_instance = nullptr;