| /****************************************************************************** |
| * |
| * Copyright 2017 The Android Open Source Project |
| * Copyright 2014 Broadcom Corporation |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at: |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| * |
| ******************************************************************************/ |
| |
| #include <base/bind.h> |
| #include <base/location.h> |
| #include <base/logging.h> |
| #include <base/memory/weak_ptr.h> |
| #include <base/strings/string_number_conversions.h> |
| #include <base/time/time.h> |
| #include <string.h> |
| #include <queue> |
| #include <vector> |
| |
| #include "bt_target.h" |
| #include "device/include/controller.h" |
| #include "osi/include/alarm.h" |
| |
| #include "ble_advertiser.h" |
| #include "ble_advertiser_hci_interface.h" |
| #include "btm_int_types.h" |
| |
| using base::Bind; |
| using base::TimeDelta; |
| using base::TimeTicks; |
| using RegisterCb = |
| base::Callback<void(uint8_t /* inst_id */, uint8_t /* status */)>; |
| using IdTxPowerStatusCb = base::Callback<void( |
| uint8_t /* inst_id */, int8_t /* tx_power */, uint8_t /* status */)>; |
| using SetEnableData = BleAdvertiserHciInterface::SetEnableData; |
| extern void btm_gen_resolvable_private_addr( |
| base::Callback<void(uint8_t[8])> cb); |
| |
| constexpr int ADV_DATA_LEN_MAX = 251; |
| |
| namespace { |
| |
| bool is_connectable(uint16_t advertising_event_properties) { |
| return advertising_event_properties & 0x01; |
| } |
| |
| struct AdvertisingInstance { |
| uint8_t inst_id; |
| bool in_use; |
| uint8_t advertising_event_properties; |
| alarm_t* adv_raddr_timer; |
| int8_t tx_power; |
| uint16_t duration; // 1 unit is 10ms |
| uint8_t maxExtAdvEvents; |
| alarm_t* timeout_timer; |
| uint8_t own_address_type; |
| RawAddress own_address; |
| MultiAdvCb timeout_cb; |
| bool address_update_required; |
| bool periodic_enabled; |
| uint32_t advertising_interval; // 1 unit is 0.625 ms |
| |
| /* When true, advertising set is enabled, or last scheduled call to "LE Set |
| * Extended Advertising Set Enable" is to enable this advertising set. Any |
| * command scheduled when in this state will execute when the set is enabled, |
| * unless enabling fails. |
| * |
| * When false, advertising set is disabled, or last scheduled call to "LE Set |
| * Extended Advertising Set Enable" is to disable this advertising set. Any |
| * command scheduled when in this state will execute when the set is disabled. |
| */ |
| bool enable_status; |
| TimeTicks enable_time; |
| |
| bool IsEnabled() { return enable_status; } |
| |
| bool IsConnectable() { return is_connectable(advertising_event_properties); } |
| |
| AdvertisingInstance(int inst_id) |
| : inst_id(inst_id), |
| in_use(false), |
| advertising_event_properties(0), |
| tx_power(0), |
| duration(0), |
| timeout_timer(nullptr), |
| own_address_type(0), |
| own_address(RawAddress::kEmpty), |
| address_update_required(false), |
| periodic_enabled(false), |
| enable_status(false) { |
| adv_raddr_timer = alarm_new_periodic("btm_ble.adv_raddr_timer"); |
| } |
| |
| ~AdvertisingInstance() { |
| alarm_free(adv_raddr_timer); |
| adv_raddr_timer = nullptr; |
| if (timeout_timer) { |
| alarm_free(timeout_timer); |
| timeout_timer = nullptr; |
| } |
| } |
| }; |
| |
| void btm_ble_adv_raddr_timer_timeout(void* data); |
| |
| void DoNothing(uint8_t) {} |
| void DoNothing2(uint8_t, uint8_t) {} |
| |
| struct closure_data { |
| base::Closure user_task; |
| tracked_objects::Location posted_from; |
| }; |
| |
| static void alarm_closure_cb(void* p) { |
| closure_data* data = (closure_data*)p; |
| VLOG(1) << "executing timer scheduled at %s" << data->posted_from.ToString(); |
| data->user_task.Run(); |
| delete data; |
| } |
| |
| // Periodic alarms are not supported, because we clean up data in callback |
| void alarm_set_closure(const tracked_objects::Location& posted_from, |
| alarm_t* alarm, period_ms_t interval_ms, |
| base::Closure user_task) { |
| closure_data* data = new closure_data; |
| data->posted_from = posted_from; |
| data->user_task = std::move(user_task); |
| VLOG(1) << "scheduling timer %s" << data->posted_from.ToString(); |
| alarm_set_on_mloop(alarm, interval_ms, alarm_closure_cb, data); |
| } |
| |
| class BleAdvertisingManagerImpl; |
| |
| /* a temporary type for holding all the data needed in callbacks below*/ |
| struct CreatorParams { |
| uint8_t inst_id; |
| base::WeakPtr<BleAdvertisingManagerImpl> self; |
| IdTxPowerStatusCb cb; |
| tBTM_BLE_ADV_PARAMS params; |
| std::vector<uint8_t> advertise_data; |
| std::vector<uint8_t> scan_response_data; |
| tBLE_PERIODIC_ADV_PARAMS periodic_params; |
| std::vector<uint8_t> periodic_data; |
| uint16_t duration; |
| uint8_t maxExtAdvEvents; |
| RegisterCb timeout_cb; |
| }; |
| |
| using c_type = std::unique_ptr<CreatorParams>; |
| |
| BleAdvertisingManager* instance; |
| base::WeakPtr<BleAdvertisingManagerImpl> instance_weakptr; |
| |
| class BleAdvertisingManagerImpl |
| : public BleAdvertisingManager, |
| public BleAdvertiserHciInterface::AdvertisingEventObserver { |
| public: |
| BleAdvertisingManagerImpl(BleAdvertiserHciInterface* interface) |
| : hci_interface(interface), weak_factory_(this) { |
| hci_interface->ReadInstanceCount( |
| base::Bind(&BleAdvertisingManagerImpl::ReadInstanceCountCb, |
| weak_factory_.GetWeakPtr())); |
| } |
| |
| ~BleAdvertisingManagerImpl() { adv_inst.clear(); } |
| |
| void GetOwnAddress(uint8_t inst_id, GetAddressCallback cb) override { |
| cb.Run(adv_inst[inst_id].own_address_type, adv_inst[inst_id].own_address); |
| } |
| |
| void ReadInstanceCountCb(uint8_t instance_count) { |
| this->inst_count = instance_count; |
| adv_inst.reserve(inst_count); |
| /* Initialize adv instance indices and IDs. */ |
| for (uint8_t i = 0; i < inst_count; i++) { |
| adv_inst.emplace_back(i); |
| } |
| } |
| |
| void OnRpaGenerationComplete(base::Callback<void(RawAddress)> cb, |
| uint8_t rand[8]) { |
| VLOG(1) << __func__; |
| |
| RawAddress bda; |
| |
| rand[2] &= (~BLE_RESOLVE_ADDR_MASK); |
| rand[2] |= BLE_RESOLVE_ADDR_MSB; |
| |
| bda.address[2] = rand[0]; |
| bda.address[1] = rand[1]; |
| bda.address[0] = rand[2]; |
| |
| BT_OCTET16 irk; |
| BTM_GetDeviceIDRoot(irk); |
| tSMP_ENC output; |
| |
| if (!SMP_Encrypt(irk, BT_OCTET16_LEN, rand, 3, &output)) |
| LOG_ASSERT(false) << "SMP_Encrypt failed"; |
| |
| /* set hash to be LSB of rpAddress */ |
| bda.address[5] = output.param_buf[0]; |
| bda.address[4] = output.param_buf[1]; |
| bda.address[3] = output.param_buf[2]; |
| |
| cb.Run(bda); |
| } |
| |
| void GenerateRpa(base::Callback<void(RawAddress)> cb) { |
| btm_gen_resolvable_private_addr( |
| Bind(&BleAdvertisingManagerImpl::OnRpaGenerationComplete, |
| weak_factory_.GetWeakPtr(), std::move(cb))); |
| } |
| |
| void ConfigureRpa(AdvertisingInstance* p_inst, MultiAdvCb configuredCb) { |
| /* Connectable advertising set must be disabled when updating RPA */ |
| bool restart = p_inst->IsEnabled() && p_inst->IsConnectable(); |
| |
| // If there is any form of timeout on the set, schedule address update when |
| // the set stops, because there is no good way to compute new timeout value. |
| // Maximum duration value is around 10 minutes, so this is safe. |
| if (restart && (p_inst->duration || p_inst->maxExtAdvEvents)) { |
| p_inst->address_update_required = true; |
| configuredCb.Run(0x01); |
| return; |
| } |
| |
| GenerateRpa(Bind( |
| [](AdvertisingInstance* p_inst, MultiAdvCb configuredCb, |
| RawAddress bda) { |
| /* Connectable advertising set must be disabled when updating RPA */ |
| bool restart = p_inst->IsEnabled() && p_inst->IsConnectable(); |
| |
| if (!instance_weakptr.get()) return; |
| auto hci_interface = instance_weakptr.get()->GetHciInterface(); |
| |
| if (restart) { |
| p_inst->enable_status = false; |
| hci_interface->Enable(false, p_inst->inst_id, 0x00, 0x00, |
| Bind(DoNothing)); |
| } |
| |
| /* set it to controller */ |
| hci_interface->SetRandomAddress( |
| p_inst->inst_id, bda, |
| Bind( |
| [](AdvertisingInstance* p_inst, RawAddress bda, |
| MultiAdvCb configuredCb, uint8_t status) { |
| p_inst->own_address = bda; |
| configuredCb.Run(0x00); |
| }, |
| p_inst, bda, configuredCb)); |
| |
| if (restart) { |
| p_inst->enable_status = true; |
| hci_interface->Enable(true, p_inst->inst_id, 0x00, 0x00, |
| Bind(DoNothing)); |
| } |
| }, |
| p_inst, std::move(configuredCb))); |
| } |
| |
| void RegisterAdvertiser( |
| base::Callback<void(uint8_t /* inst_id */, uint8_t /* status */)> cb) |
| override { |
| AdvertisingInstance* p_inst = &adv_inst[0]; |
| for (uint8_t i = 0; i < inst_count; i++, p_inst++) { |
| if (p_inst->in_use) continue; |
| |
| p_inst->in_use = true; |
| |
| // set up periodic timer to update address. |
| if (BTM_BleLocalPrivacyEnabled()) { |
| p_inst->own_address_type = BLE_ADDR_RANDOM; |
| GenerateRpa(Bind( |
| [](AdvertisingInstance* p_inst, |
| base::Callback<void(uint8_t /* inst_id */, uint8_t /* status */)> |
| cb, |
| RawAddress bda) { |
| p_inst->own_address = bda; |
| |
| alarm_set_on_mloop(p_inst->adv_raddr_timer, |
| BTM_BLE_PRIVATE_ADDR_INT_MS, |
| btm_ble_adv_raddr_timer_timeout, p_inst); |
| cb.Run(p_inst->inst_id, BTM_BLE_MULTI_ADV_SUCCESS); |
| }, |
| p_inst, cb)); |
| } else { |
| p_inst->own_address_type = BLE_ADDR_PUBLIC; |
| p_inst->own_address = *controller_get_interface()->get_address(); |
| |
| cb.Run(p_inst->inst_id, BTM_BLE_MULTI_ADV_SUCCESS); |
| } |
| return; |
| } |
| |
| LOG(INFO) << "no free advertiser instance"; |
| cb.Run(0xFF, ADVERTISE_FAILED_TOO_MANY_ADVERTISERS); |
| } |
| |
| void StartAdvertising(uint8_t advertiser_id, MultiAdvCb cb, |
| tBTM_BLE_ADV_PARAMS* params, |
| std::vector<uint8_t> advertise_data, |
| std::vector<uint8_t> scan_response_data, int duration, |
| MultiAdvCb timeout_cb) override { |
| /* a temporary type for holding all the data needed in callbacks below*/ |
| struct CreatorParams { |
| uint8_t inst_id; |
| base::WeakPtr<BleAdvertisingManagerImpl> self; |
| MultiAdvCb cb; |
| tBTM_BLE_ADV_PARAMS params; |
| std::vector<uint8_t> advertise_data; |
| std::vector<uint8_t> scan_response_data; |
| int duration; |
| MultiAdvCb timeout_cb; |
| }; |
| |
| std::unique_ptr<CreatorParams> c; |
| c.reset(new CreatorParams()); |
| |
| c->self = weak_factory_.GetWeakPtr(); |
| c->cb = std::move(cb); |
| c->params = *params; |
| c->advertise_data = std::move(advertise_data); |
| c->scan_response_data = std::move(scan_response_data); |
| c->duration = duration; |
| c->timeout_cb = std::move(timeout_cb); |
| c->inst_id = advertiser_id; |
| |
| using c_type = std::unique_ptr<CreatorParams>; |
| |
| // this code is intentionally left formatted this way to highlight the |
| // asynchronous flow |
| // clang-format off |
| c->self->SetParameters(c->inst_id, &c->params, Bind( |
| [](c_type c, uint8_t status, int8_t tx_power) { |
| if (!c->self) { |
| LOG(INFO) << "Stack was shut down"; |
| return; |
| } |
| |
| if (status) { |
| LOG(ERROR) << "setting parameters failed, status: " << +status; |
| c->cb.Run(status); |
| return; |
| } |
| |
| c->self->adv_inst[c->inst_id].tx_power = tx_power; |
| |
| const RawAddress& rpa = c->self->adv_inst[c->inst_id].own_address; |
| c->self->GetHciInterface()->SetRandomAddress(c->inst_id, rpa, Bind( |
| [](c_type c, uint8_t status) { |
| if (!c->self) { |
| LOG(INFO) << "Stack was shut down"; |
| return; |
| } |
| |
| if (status != 0) { |
| LOG(ERROR) << "setting random address failed, status: " << +status; |
| c->cb.Run(status); |
| return; |
| } |
| |
| c->self->SetData(c->inst_id, false, std::move(c->advertise_data), Bind( |
| [](c_type c, uint8_t status) { |
| if (!c->self) { |
| LOG(INFO) << "Stack was shut down"; |
| return; |
| } |
| |
| if (status != 0) { |
| LOG(ERROR) << "setting advertise data failed, status: " << +status; |
| c->cb.Run(status); |
| return; |
| } |
| |
| c->self->SetData(c->inst_id, true, std::move(c->scan_response_data), Bind( |
| [](c_type c, uint8_t status) { |
| if (!c->self) { |
| LOG(INFO) << "Stack was shut down"; |
| return; |
| } |
| |
| if (status != 0) { |
| LOG(ERROR) << "setting scan response data failed, status: " << +status; |
| c->cb.Run(status); |
| return; |
| } |
| |
| c->self->Enable(c->inst_id, true, c->cb, c->duration, 0, std::move(c->timeout_cb)); |
| |
| }, base::Passed(&c))); |
| }, base::Passed(&c))); |
| }, base::Passed(&c))); |
| }, base::Passed(&c))); |
| // clang-format on |
| } |
| |
| void StartAdvertisingSet(IdTxPowerStatusCb cb, tBTM_BLE_ADV_PARAMS* params, |
| std::vector<uint8_t> advertise_data, |
| std::vector<uint8_t> scan_response_data, |
| tBLE_PERIODIC_ADV_PARAMS* periodic_params, |
| std::vector<uint8_t> periodic_data, |
| uint16_t duration, uint8_t maxExtAdvEvents, |
| RegisterCb timeout_cb) override { |
| std::unique_ptr<CreatorParams> c; |
| c.reset(new CreatorParams()); |
| |
| c->self = weak_factory_.GetWeakPtr(); |
| c->cb = std::move(cb); |
| c->params = *params; |
| c->advertise_data = std::move(advertise_data); |
| c->scan_response_data = std::move(scan_response_data); |
| c->periodic_params = *periodic_params; |
| c->periodic_data = std::move(periodic_data); |
| c->duration = duration; |
| c->maxExtAdvEvents = maxExtAdvEvents; |
| c->timeout_cb = std::move(timeout_cb); |
| |
| // this code is intentionally left formatted this way to highlight the |
| // asynchronous flow |
| // clang-format off |
| c->self->RegisterAdvertiser(Bind( |
| [](c_type c, uint8_t advertiser_id, uint8_t status) { |
| if (!c->self) { |
| LOG(INFO) << "Stack was shut down"; |
| return; |
| } |
| |
| if (status != 0) { |
| LOG(ERROR) << " failed, status: " << +status; |
| c->cb.Run(0, 0, status); |
| return; |
| } |
| |
| c->inst_id = advertiser_id; |
| |
| c->self->SetParameters(c->inst_id, &c->params, Bind( |
| [](c_type c, uint8_t status, int8_t tx_power) { |
| if (!c->self) { |
| LOG(INFO) << "Stack was shut down"; |
| return; |
| } |
| |
| if (status != 0) { |
| c->self->Unregister(c->inst_id); |
| LOG(ERROR) << "setting parameters failed, status: " << +status; |
| c->cb.Run(0, 0, status); |
| return; |
| } |
| |
| c->self->adv_inst[c->inst_id].tx_power = tx_power; |
| |
| if (c->self->adv_inst[c->inst_id].own_address_type == BLE_ADDR_PUBLIC) { |
| c->self->StartAdvertisingSetAfterAddressPart(std::move(c)); |
| return; |
| } |
| |
| //own_address_type == BLE_ADDR_RANDOM |
| const RawAddress& rpa = c->self->adv_inst[c->inst_id].own_address; |
| c->self->GetHciInterface()->SetRandomAddress(c->inst_id, rpa, Bind( |
| [](c_type c, uint8_t status) { |
| if (!c->self) { |
| LOG(INFO) << "Stack was shut down"; |
| return; |
| } |
| |
| if (status != 0) { |
| c->self->Unregister(c->inst_id); |
| LOG(ERROR) << "setting random address failed, status: " << +status; |
| c->cb.Run(0, 0, status); |
| return; |
| } |
| |
| c->self->StartAdvertisingSetAfterAddressPart(std::move(c)); |
| }, base::Passed(&c))); |
| }, base::Passed(&c))); |
| }, base::Passed(&c))); |
| // clang-format on |
| } |
| |
| void StartAdvertisingSetAfterAddressPart(c_type c) { |
| c->self->SetData( |
| c->inst_id, false, std::move(c->advertise_data), |
| Bind( |
| [](c_type c, uint8_t status) { |
| if (!c->self) { |
| LOG(INFO) << "Stack was shut down"; |
| return; |
| } |
| |
| if (status != 0) { |
| c->self->Unregister(c->inst_id); |
| LOG(ERROR) << "setting advertise data failed, status: " |
| << +status; |
| c->cb.Run(0, 0, status); |
| return; |
| } |
| |
| c->self->SetData( |
| c->inst_id, true, std::move(c->scan_response_data), |
| Bind( |
| [](c_type c, uint8_t status) { |
| if (!c->self) { |
| LOG(INFO) << "Stack was shut down"; |
| return; |
| } |
| |
| if (status != 0) { |
| c->self->Unregister(c->inst_id); |
| LOG(ERROR) |
| << "setting scan response data failed, status: " |
| << +status; |
| c->cb.Run(0, 0, status); |
| return; |
| } |
| |
| if (c->periodic_params.enable) { |
| c->self->StartAdvertisingSetPeriodicPart( |
| std::move(c)); |
| } else { |
| c->self->StartAdvertisingSetFinish(std::move(c)); |
| } |
| }, |
| base::Passed(&c))); |
| }, |
| base::Passed(&c))); |
| } |
| |
| void StartAdvertisingSetPeriodicPart(c_type c) { |
| // this code is intentionally left formatted this way to highlight the |
| // asynchronous flow |
| // clang-format off |
| c->self->SetPeriodicAdvertisingParameters(c->inst_id, &c->periodic_params, Bind( |
| [](c_type c, uint8_t status) { |
| if (!c->self) { |
| LOG(INFO) << "Stack was shut down"; |
| return; |
| } |
| |
| if (status != 0) { |
| c->self->Unregister(c->inst_id); |
| LOG(ERROR) << "setting periodic parameters failed, status: " << +status; |
| c->cb.Run(0, 0, status); |
| return; |
| } |
| |
| c->self->SetPeriodicAdvertisingData(c->inst_id, std::move(c->periodic_data), Bind( |
| [](c_type c, uint8_t status) { |
| if (!c->self) { |
| LOG(INFO) << "Stack was shut down"; |
| return; |
| } |
| |
| if (status != 0) { |
| c->self->Unregister(c->inst_id); |
| LOG(ERROR) << "setting periodic parameters failed, status: " << +status; |
| c->cb.Run(0, 0, status); |
| return; |
| } |
| |
| c->self->SetPeriodicAdvertisingEnable(c->inst_id, true, Bind( |
| [](c_type c, uint8_t status) { |
| if (!c->self) { |
| LOG(INFO) << "Stack was shut down"; |
| return; |
| } |
| |
| if (status != 0) { |
| c->self->Unregister(c->inst_id); |
| LOG(ERROR) << "enabling periodic advertising failed, status: " << +status; |
| c->cb.Run(0, 0, status); |
| return; |
| } |
| |
| c->self->StartAdvertisingSetFinish(std::move(c)); |
| |
| }, base::Passed(&c))); |
| }, base::Passed(&c))); |
| }, base::Passed(&c))); |
| // clang-format on |
| } |
| |
| void StartAdvertisingSetFinish(c_type c) { |
| uint8_t inst_id = c->inst_id; |
| uint16_t duration = c->duration; |
| uint8_t maxExtAdvEvents = c->maxExtAdvEvents; |
| RegisterCb timeout_cb = std::move(c->timeout_cb); |
| base::WeakPtr<BleAdvertisingManagerImpl> self = c->self; |
| MultiAdvCb enable_cb = Bind( |
| [](c_type c, uint8_t status) { |
| if (!c->self) { |
| LOG(INFO) << "Stack was shut down"; |
| return; |
| } |
| |
| if (status != 0) { |
| c->self->Unregister(c->inst_id); |
| LOG(ERROR) << "enabling advertiser failed, status: " << +status; |
| c->cb.Run(0, 0, status); |
| return; |
| } |
| int8_t tx_power = c->self->adv_inst[c->inst_id].tx_power; |
| c->cb.Run(c->inst_id, tx_power, status); |
| }, |
| base::Passed(&c)); |
| |
| self->Enable(inst_id, true, std::move(enable_cb), duration, maxExtAdvEvents, |
| Bind(std::move(timeout_cb), inst_id)); |
| } |
| |
| void EnableWithTimerCb(uint8_t inst_id, MultiAdvCb enable_cb, int duration, |
| MultiAdvCb timeout_cb, uint8_t status) { |
| VLOG(1) << __func__ << " inst_id: " << +inst_id; |
| AdvertisingInstance* p_inst = &adv_inst[inst_id]; |
| |
| // Run the regular enable callback |
| enable_cb.Run(status); |
| |
| p_inst->timeout_timer = alarm_new("btm_ble.adv_timeout"); |
| |
| base::Closure cb = Bind( |
| &BleAdvertisingManagerImpl::Enable, weak_factory_.GetWeakPtr(), inst_id, |
| 0 /* disable */, std::move(timeout_cb), 0, 0, base::Bind(DoNothing)); |
| |
| // schedule disable when the timeout passes |
| alarm_set_closure(FROM_HERE, p_inst->timeout_timer, duration * 10, |
| std::move(cb)); |
| } |
| |
| void Enable(uint8_t inst_id, bool enable, MultiAdvCb cb, uint16_t duration, |
| uint8_t maxExtAdvEvents, MultiAdvCb timeout_cb) override { |
| VLOG(1) << __func__ << " inst_id: " << +inst_id; |
| if (inst_id >= inst_count) { |
| LOG(ERROR) << "bad instance id " << +inst_id; |
| return; |
| } |
| |
| AdvertisingInstance* p_inst = &adv_inst[inst_id]; |
| VLOG(1) << __func__ << " enable: " << enable << ", duration: " << +duration; |
| if (!p_inst->in_use) { |
| LOG(ERROR) << "Invalid or no active instance"; |
| cb.Run(BTM_BLE_MULTI_ADV_FAILURE); |
| return; |
| } |
| |
| if (enable && (duration || maxExtAdvEvents)) { |
| p_inst->timeout_cb = std::move(timeout_cb); |
| } |
| |
| p_inst->duration = duration; |
| p_inst->maxExtAdvEvents = maxExtAdvEvents; |
| |
| if (enable && p_inst->address_update_required) { |
| p_inst->address_update_required = false; |
| ConfigureRpa(p_inst, base::Bind(&BleAdvertisingManagerImpl::EnableFinish, |
| weak_factory_.GetWeakPtr(), p_inst, |
| enable, std::move(cb))); |
| return; |
| } |
| |
| EnableFinish(p_inst, enable, std::move(cb), 0); |
| } |
| |
| void EnableFinish(AdvertisingInstance* p_inst, bool enable, MultiAdvCb cb, |
| uint8_t status) { |
| MultiAdvCb myCb; |
| if (enable && p_inst->duration) { |
| // TODO(jpawlowski): HCI implementation that can't do duration should |
| // emulate it, not EnableWithTimerCb. |
| myCb = Bind(&BleAdvertisingManagerImpl::EnableWithTimerCb, |
| weak_factory_.GetWeakPtr(), p_inst->inst_id, std::move(cb), |
| p_inst->duration, p_inst->timeout_cb); |
| } else { |
| myCb = std::move(cb); |
| |
| if (p_inst->timeout_timer) { |
| alarm_cancel(p_inst->timeout_timer); |
| alarm_free(p_inst->timeout_timer); |
| p_inst->timeout_timer = nullptr; |
| } |
| } |
| |
| if (enable) p_inst->enable_time = TimeTicks::Now(); |
| p_inst->enable_status = enable; |
| GetHciInterface()->Enable(enable, p_inst->inst_id, p_inst->duration, |
| p_inst->maxExtAdvEvents, std::move(myCb)); |
| } |
| |
| void SetParameters(uint8_t inst_id, tBTM_BLE_ADV_PARAMS* p_params, |
| ParametersCb cb) override { |
| VLOG(1) << __func__ << " inst_id: " << +inst_id; |
| if (inst_id >= inst_count) { |
| LOG(ERROR) << "bad instance id " << +inst_id; |
| return; |
| } |
| |
| AdvertisingInstance* p_inst = &adv_inst[inst_id]; |
| if (!p_inst->in_use) { |
| LOG(ERROR) << "adv instance not in use" << +inst_id; |
| cb.Run(BTM_BLE_MULTI_ADV_FAILURE, 0); |
| return; |
| } |
| |
| // TODO: disable only if was enabled, currently no use scenario needs |
| // that, |
| // we always set parameters before enabling |
| // GetHciInterface()->Enable(false, inst_id, Bind(DoNothing)); |
| p_inst->advertising_event_properties = |
| p_params->advertising_event_properties; |
| p_inst->tx_power = p_params->tx_power; |
| p_inst->advertising_interval = p_params->adv_int_min; |
| const RawAddress& peer_address = RawAddress::kEmpty; |
| |
| GetHciInterface()->SetParameters( |
| p_inst->inst_id, p_params->advertising_event_properties, |
| p_params->adv_int_min, p_params->adv_int_max, p_params->channel_map, |
| p_inst->own_address_type, p_inst->own_address, 0x00, peer_address, |
| p_params->adv_filter_policy, p_inst->tx_power, |
| p_params->primary_advertising_phy, 0x00, |
| p_params->secondary_advertising_phy, 0x01 /* TODO: proper SID */, |
| p_params->scan_request_notification_enable, cb); |
| |
| // TODO: re-enable only if it was enabled, properly call |
| // SetParamsCallback |
| // currently no use scenario needs that |
| // GetHciInterface()->Enable(true, inst_id, BTM_BleUpdateAdvInstParamCb); |
| } |
| |
| void SetData(uint8_t inst_id, bool is_scan_rsp, std::vector<uint8_t> data, |
| MultiAdvCb cb) override { |
| VLOG(1) << __func__ << " inst_id: " << +inst_id; |
| if (inst_id >= inst_count) { |
| LOG(ERROR) << "bad instance id " << +inst_id; |
| return; |
| } |
| |
| AdvertisingInstance* p_inst = &adv_inst[inst_id]; |
| VLOG(1) << "is_scan_rsp = " << is_scan_rsp; |
| |
| if (!is_scan_rsp && is_connectable(p_inst->advertising_event_properties)) { |
| uint8_t flags_val = BTM_GENERAL_DISCOVERABLE; |
| |
| if (p_inst->duration) flags_val = BTM_LIMITED_DISCOVERABLE; |
| |
| std::vector<uint8_t> flags; |
| flags.push_back(2); // length |
| flags.push_back(HCI_EIR_FLAGS_TYPE); |
| flags.push_back(flags_val); |
| |
| data.insert(data.begin(), flags.begin(), flags.end()); |
| } |
| |
| // Find and fill TX Power with the correct value |
| if (data.size()) { |
| size_t i = 0; |
| while (i < data.size()) { |
| uint8_t type = data[i + 1]; |
| if (type == HCI_EIR_TX_POWER_LEVEL_TYPE) { |
| data[i + 2] = adv_inst[inst_id].tx_power; |
| } |
| i += data[i] + 1; |
| } |
| } |
| |
| VLOG(1) << "data is: " << base::HexEncode(data.data(), data.size()); |
| DivideAndSendData( |
| inst_id, data, cb, |
| base::Bind(&BleAdvertisingManagerImpl::SetDataAdvDataSender, |
| weak_factory_.GetWeakPtr(), is_scan_rsp)); |
| } |
| |
| void SetDataAdvDataSender(uint8_t is_scan_rsp, uint8_t inst_id, |
| uint8_t operation, uint8_t length, uint8_t* data, |
| MultiAdvCb cb) { |
| if (is_scan_rsp) |
| GetHciInterface()->SetScanResponseData(inst_id, operation, 0x01, length, |
| data, cb); |
| else |
| GetHciInterface()->SetAdvertisingData(inst_id, operation, 0x01, length, |
| data, cb); |
| } |
| |
| using DataSender = base::Callback<void( |
| uint8_t /*inst_id*/, uint8_t /* operation */, uint8_t /* length */, |
| uint8_t* /* data */, MultiAdvCb /* done */)>; |
| |
| void DivideAndSendData(int inst_id, std::vector<uint8_t> data, |
| MultiAdvCb done_cb, DataSender sender) { |
| DivideAndSendDataRecursively(true, inst_id, std::move(data), 0, |
| std::move(done_cb), std::move(sender), 0); |
| } |
| |
| static void DivideAndSendDataRecursively(bool isFirst, int inst_id, |
| std::vector<uint8_t> data, |
| int offset, MultiAdvCb done_cb, |
| DataSender sender, uint8_t status) { |
| constexpr uint8_t INTERMEDIATE = |
| 0x00; // Intermediate fragment of fragmented data |
| constexpr uint8_t FIRST = 0x01; // First fragment of fragmented data |
| constexpr uint8_t LAST = 0x02; // Last fragment of fragmented data |
| constexpr uint8_t COMPLETE = 0x03; // Complete extended advertising data |
| |
| int dataSize = (int)data.size(); |
| if (status != 0 || (!isFirst && offset == dataSize)) { |
| /* if we got error writing data, or reached the end of data */ |
| done_cb.Run(status); |
| return; |
| } |
| |
| bool moreThanOnePacket = dataSize - offset > ADV_DATA_LEN_MAX; |
| uint8_t operation = isFirst ? moreThanOnePacket ? FIRST : COMPLETE |
| : moreThanOnePacket ? INTERMEDIATE : LAST; |
| int length = moreThanOnePacket ? ADV_DATA_LEN_MAX : dataSize - offset; |
| int newOffset = offset + length; |
| |
| sender.Run( |
| inst_id, operation, length, data.data() + offset, |
| Bind(&BleAdvertisingManagerImpl::DivideAndSendDataRecursively, false, |
| inst_id, std::move(data), newOffset, std::move(done_cb), sender)); |
| } |
| |
| void SetPeriodicAdvertisingParameters(uint8_t inst_id, |
| tBLE_PERIODIC_ADV_PARAMS* params, |
| MultiAdvCb cb) override { |
| VLOG(1) << __func__ << " inst_id: " << +inst_id; |
| |
| GetHciInterface()->SetPeriodicAdvertisingParameters( |
| inst_id, params->min_interval, params->max_interval, |
| params->periodic_advertising_properties, cb); |
| } |
| |
| void SetPeriodicAdvertisingData(uint8_t inst_id, std::vector<uint8_t> data, |
| MultiAdvCb cb) override { |
| VLOG(1) << __func__ << " inst_id: " << +inst_id; |
| |
| VLOG(1) << "data is: " << base::HexEncode(data.data(), data.size()); |
| |
| DivideAndSendData( |
| inst_id, data, cb, |
| base::Bind(&BleAdvertiserHciInterface::SetPeriodicAdvertisingData, |
| base::Unretained(GetHciInterface()))); |
| } |
| |
| void SetPeriodicAdvertisingEnable(uint8_t inst_id, uint8_t enable, |
| MultiAdvCb cb) override { |
| VLOG(1) << __func__ << " inst_id: " << +inst_id << ", enable: " << +enable; |
| |
| AdvertisingInstance* p_inst = &adv_inst[inst_id]; |
| if (!p_inst->in_use) { |
| LOG(ERROR) << "Invalid or not active instance"; |
| cb.Run(BTM_BLE_MULTI_ADV_FAILURE); |
| return; |
| } |
| |
| MultiAdvCb enable_cb = Bind( |
| [](AdvertisingInstance* p_inst, uint8_t enable, MultiAdvCb cb, |
| uint8_t status) { |
| VLOG(1) << "periodc adv enable cb: inst_id: " << +p_inst->inst_id |
| << ", enable: " << +enable << ", status: " << std::hex |
| << +status; |
| if (!status) p_inst->periodic_enabled = enable; |
| |
| cb.Run(status); |
| }, |
| p_inst, enable, std::move(cb)); |
| |
| GetHciInterface()->SetPeriodicAdvertisingEnable(enable, inst_id, |
| std::move(enable_cb)); |
| } |
| |
| void Unregister(uint8_t inst_id) override { |
| AdvertisingInstance* p_inst = &adv_inst[inst_id]; |
| |
| VLOG(1) << __func__ << " inst_id: " << +inst_id; |
| if (inst_id >= inst_count) { |
| LOG(ERROR) << "bad instance id " << +inst_id; |
| return; |
| } |
| |
| if (adv_inst[inst_id].IsEnabled()) { |
| p_inst->enable_status = false; |
| GetHciInterface()->Enable(false, inst_id, 0x00, 0x00, Bind(DoNothing)); |
| } |
| |
| if (p_inst->periodic_enabled) { |
| p_inst->periodic_enabled = false; |
| GetHciInterface()->SetPeriodicAdvertisingEnable(false, inst_id, |
| Bind(DoNothing)); |
| } |
| |
| alarm_cancel(p_inst->adv_raddr_timer); |
| p_inst->in_use = false; |
| GetHciInterface()->RemoveAdvertisingSet(inst_id, Bind(DoNothing)); |
| p_inst->address_update_required = false; |
| } |
| |
| void RecomputeTimeout(AdvertisingInstance* inst, TimeTicks now) { |
| TimeDelta duration = now - inst->enable_time; |
| bool cb_fired = false; |
| if (inst->duration) { |
| int durationDone = (duration.InMilliseconds() / 10); |
| if (durationDone + 1 >= inst->duration) { |
| inst->enable_status = false; |
| inst->timeout_cb.Run(0 /* TODO: STATUS HERE?*/); |
| cb_fired = true; |
| } else { |
| inst->duration = inst->duration - durationDone; |
| } |
| } |
| |
| if (inst->maxExtAdvEvents && !cb_fired) { |
| int eventsDone = |
| (duration.InMilliseconds() / (inst->advertising_interval * 5 / 8)); |
| |
| if (eventsDone + 1 >= inst->maxExtAdvEvents) { |
| inst->enable_status = false; |
| inst->timeout_cb.Run(0 /* TODO: STATUS HERE?*/); |
| } else { |
| inst->maxExtAdvEvents = inst->maxExtAdvEvents - eventsDone; |
| } |
| } |
| } |
| |
| void Suspend() override { |
| std::vector<SetEnableData> sets; |
| |
| for (AdvertisingInstance& inst : adv_inst) { |
| if (!inst.in_use || !inst.enable_status) continue; |
| |
| if (inst.duration || inst.maxExtAdvEvents) |
| RecomputeTimeout(&inst, TimeTicks::Now()); |
| |
| sets.emplace_back(SetEnableData{.handle = inst.inst_id}); |
| } |
| |
| if (!sets.empty()) GetHciInterface()->Enable(false, sets, Bind(DoNothing)); |
| } |
| |
| void Resume() override { |
| std::vector<SetEnableData> sets; |
| |
| for (const AdvertisingInstance& inst : adv_inst) { |
| if (inst.in_use && inst.enable_status) { |
| sets.emplace_back(SetEnableData{ |
| .handle = inst.inst_id, |
| .duration = inst.duration, |
| .max_extended_advertising_events = inst.maxExtAdvEvents}); |
| } |
| } |
| |
| if (!sets.empty()) GetHciInterface()->Enable(true, sets, Bind(DoNothing)); |
| } |
| |
| void OnAdvertisingSetTerminated( |
| uint8_t status, uint8_t advertising_handle, uint16_t connection_handle, |
| uint8_t num_completed_extended_adv_events) override { |
| AdvertisingInstance* p_inst = &adv_inst[advertising_handle]; |
| VLOG(1) << __func__ << "status: " << loghex(status) |
| << ", advertising_handle: " << loghex(advertising_handle) |
| << ", connection_handle: " << loghex(connection_handle); |
| |
| if (status == HCI_ERR_LIMIT_REACHED || |
| status == HCI_ERR_ADVERTISING_TIMEOUT) { |
| // either duration elapsed, or maxExtAdvEvents reached |
| p_inst->enable_status = false; |
| |
| if (p_inst->timeout_cb.is_null()) { |
| LOG(INFO) << __func__ << "No timeout callback"; |
| return; |
| } |
| |
| p_inst->timeout_cb.Run(status); |
| return; |
| } |
| |
| if (BTM_BleLocalPrivacyEnabled() && |
| advertising_handle <= BTM_BLE_MULTI_ADV_MAX) { |
| btm_acl_update_conn_addr(connection_handle, p_inst->own_address); |
| } |
| |
| VLOG(1) << "reneabling advertising"; |
| |
| if (p_inst->in_use) { |
| // TODO(jpawlowski): we don't really allow to do directed advertising |
| // right now. This should probably be removed, check with Andre. |
| if ((p_inst->advertising_event_properties & 0x0C) == 0) { |
| /* directed advertising bits not set */ |
| |
| RecomputeTimeout(p_inst, TimeTicks::Now()); |
| if (p_inst->enable_status) { |
| GetHciInterface()->Enable(true, advertising_handle, p_inst->duration, |
| p_inst->maxExtAdvEvents, Bind(DoNothing)); |
| } |
| |
| } else { |
| /* mark directed adv as disabled if adv has been stopped */ |
| p_inst->in_use = false; |
| } |
| } |
| } |
| |
| base::WeakPtr<BleAdvertisingManagerImpl> GetWeakPtr() { |
| return weak_factory_.GetWeakPtr(); |
| } |
| |
| void CancelAdvAlarms() { |
| AdvertisingInstance* p_inst = &adv_inst[0]; |
| for (uint8_t i = 0; i < inst_count; i++, p_inst++) { |
| if (p_inst->timeout_timer) { |
| alarm_cancel(p_inst->timeout_timer); |
| } |
| if (p_inst->adv_raddr_timer) { |
| alarm_cancel(p_inst->adv_raddr_timer); |
| } |
| } |
| } |
| |
| private: |
| BleAdvertiserHciInterface* GetHciInterface() { return hci_interface; } |
| |
| BleAdvertiserHciInterface* hci_interface = nullptr; |
| std::vector<AdvertisingInstance> adv_inst; |
| uint8_t inst_count; |
| |
| // Member variables should appear before the WeakPtrFactory, to ensure |
| // that any WeakPtrs are invalidated before its members |
| // variable's destructors are executed, rendering them invalid. |
| base::WeakPtrFactory<BleAdvertisingManagerImpl> weak_factory_; |
| }; |
| |
| void btm_ble_adv_raddr_timer_timeout(void* data) { |
| BleAdvertisingManagerImpl* ptr = instance_weakptr.get(); |
| if (ptr) ptr->ConfigureRpa((AdvertisingInstance*)data, base::Bind(DoNothing)); |
| } |
| } // namespace |
| |
| void BleAdvertisingManager::Initialize(BleAdvertiserHciInterface* interface) { |
| instance = new BleAdvertisingManagerImpl(interface); |
| instance_weakptr = ((BleAdvertisingManagerImpl*)instance)->GetWeakPtr(); |
| } |
| |
| bool BleAdvertisingManager::IsInitialized() { return instance; } |
| |
| base::WeakPtr<BleAdvertisingManager> BleAdvertisingManager::Get() { |
| return instance_weakptr; |
| }; |
| |
| void BleAdvertisingManager::CleanUp() { |
| if (instance_weakptr.get()) instance_weakptr.get()->CancelAdvAlarms(); |
| |
| delete instance; |
| instance = nullptr; |
| }; |
| |
| /** |
| * This function initialize the advertising manager. |
| **/ |
| void btm_ble_adv_init() { |
| BleAdvertiserHciInterface::Initialize(); |
| BleAdvertisingManager::Initialize(BleAdvertiserHciInterface::Get()); |
| BleAdvertiserHciInterface::Get()->SetAdvertisingEventObserver( |
| (BleAdvertisingManagerImpl*)BleAdvertisingManager::Get().get()); |
| |
| if (BleAdvertiserHciInterface::Get()->QuirkAdvertiserZeroHandle()) { |
| // If handle 0 can't be used, register advertiser for it, but never use it. |
| BleAdvertisingManager::Get().get()->RegisterAdvertiser(Bind(DoNothing2)); |
| } |
| } |
| |
| /******************************************************************************* |
| * |
| * Function btm_ble_multi_adv_cleanup |
| * |
| * Description This function cleans up multi adv control block. |
| * |
| * Parameters |
| * Returns void |
| * |
| ******************************************************************************/ |
| void btm_ble_multi_adv_cleanup(void) { |
| BleAdvertisingManager::CleanUp(); |
| BleAdvertiserHciInterface::CleanUp(); |
| } |
| |
| // TODO(jpawlowski): Find a nicer way to test RecomputeTimeout without exposing |
| // AdvertisingInstance |
| bool timeout_triggered = false; |
| void test_timeout_cb(uint8_t status) { timeout_triggered = true; } |
| |
| // verify that if duration passed, or is about to pass, recomputation will shut |
| // down the advertiser completly |
| void testRecomputeTimeout1() { |
| auto manager = (BleAdvertisingManagerImpl*)BleAdvertisingManager::Get().get(); |
| |
| TimeTicks start = TimeTicks::Now(); |
| TimeTicks end = start + TimeDelta::FromMilliseconds(111); |
| AdvertisingInstance test1(0); |
| test1.enable_status = true; |
| test1.enable_time = start; |
| test1.duration = 12 /*120ms*/; |
| test1.timeout_cb = Bind(&test_timeout_cb); |
| |
| manager->RecomputeTimeout(&test1, end); |
| |
| CHECK(timeout_triggered); |
| timeout_triggered = false; |
| CHECK(!test1.enable_status); |
| } |
| |
| // verify that duration and maxExtAdvEvents are properly adjusted when |
| // recomputing. |
| void testRecomputeTimeout2() { |
| auto manager = (BleAdvertisingManagerImpl*)BleAdvertisingManager::Get().get(); |
| |
| TimeTicks start = TimeTicks::Now(); |
| TimeTicks end = start + TimeDelta::FromMilliseconds(250); |
| AdvertisingInstance test1(0); |
| test1.enable_status = true; |
| test1.enable_time = start; |
| test1.duration = 50 /*500ms*/; |
| test1.maxExtAdvEvents = 50; |
| test1.advertising_interval = 16 /* 10 ms */; |
| test1.timeout_cb = Bind(&test_timeout_cb); |
| |
| manager->RecomputeTimeout(&test1, end); |
| |
| CHECK(!timeout_triggered); |
| CHECK(test1.enable_status); |
| CHECK(test1.duration == 25); |
| CHECK(test1.maxExtAdvEvents == 25); |
| } |
| |
| // verify that if maxExtAdvEvents were sent, or are close to end, recomputation |
| // wil shut down the advertiser completly |
| void testRecomputeTimeout3() { |
| auto manager = (BleAdvertisingManagerImpl*)BleAdvertisingManager::Get().get(); |
| |
| TimeTicks start = TimeTicks::Now(); |
| TimeTicks end = start + TimeDelta::FromMilliseconds(495); |
| AdvertisingInstance test1(0); |
| test1.enable_status = true; |
| test1.enable_time = start; |
| test1.maxExtAdvEvents = 50; |
| test1.advertising_interval = 16 /* 10 ms */; |
| test1.timeout_cb = Bind(&test_timeout_cb); |
| |
| manager->RecomputeTimeout(&test1, end); |
| |
| CHECK(timeout_triggered); |
| timeout_triggered = false; |
| CHECK(!test1.enable_status); |
| } |