ARMmbed
/
mbed-os
mirror of https://github.com/ARMmbed/mbed-os.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
mbed-os/connectivity/FEATURE_BLE/source/generic/GapImpl.h

998 lines
30 KiB
C++
Raw Blame History

/* mbed Microcontroller Library
* Copyright (c) 2006-2020 ARM Limited
*
* SPDX-License-Identifier: Apache-2.0
*
* 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.
*/
#ifndef IMPL_GAP_GAP_H
#define IMPL_GAP_GAP_H
#include "ble/common/CallChainOfFunctionPointersWithContext.h"
#include <algorithm>
#include "drivers/LowPowerTimeout.h"
#include "drivers/LowPowerTicker.h"
#include "platform/mbed_error.h"
#include "ble/common/BLERoles.h"
#include "ble/common/BLETypes.h"
#include "ble/gap/AdvertisingDataBuilder.h"
#include "ble/gap/AdvertisingDataSimpleBuilder.h"
#include "ble/gap/ConnectionParameters.h"
#include "ble/gap/ScanParameters.h"
#include "ble/gap/AdvertisingParameters.h"
#include "ble/gap/Events.h"
#include "source/pal/PalGap.h"
#include "source/pal/PalConnectionMonitor.h"
#include "source/pal/PalEventQueue.h"
#include "source/generic/PrivateAddressController.h"
#include "ble/Gap.h"
namespace ble {
class PalGenericAccessService;
class PalSecurityManager;
class PalGap;
class PalEventQueue;
namespace impl {
class BLEInstanceBase;
class Gap :
public ble::PalConnectionMonitor,
public PalGapEventHandler
#if BLE_FEATURE_PRIVACY
, public PrivateAddressController::EventHandler
#endif //BLE_FEATURE_PRIVACY
{
friend PalConnectionMonitor;
friend PalGapEventHandler;
friend PalGap;
friend impl::BLEInstanceBase;
using EventHandler = ::ble::Gap::EventHandler;
using GapShutdownCallback_t = ::ble::Gap::GapShutdownCallback_t;
using GapShutdownCallbackChain_t = ::ble::Gap::GapShutdownCallbackChain_t ;
public:
using PreferredConnectionParams_t = ::ble::Gap::PreferredConnectionParams_t ;
#if BLE_FEATURE_PRIVACY
#if BLE_ROLE_BROADCASTER
/**
* Default peripheral privacy configuration.
*/
static const peripheral_privacy_configuration_t
default_peripheral_privacy_configuration;
#endif // BLE_ROLE_BROADCASTER
#if BLE_ROLE_OBSERVER
/**
* Default peripheral privacy configuration.
*/
static const central_privacy_configuration_t
default_central_privacy_configuration;
#endif // BLE_ROLE_OBSERVER
#endif // BLE_FEATURE_PRIVACY
public:
void setEventHandler(EventHandler *handler);
bool isFeatureSupported(controller_supported_features_t feature);
/* advertising */
#if BLE_ROLE_BROADCASTER
uint8_t getMaxAdvertisingSetNumber();
uint16_t getMaxAdvertisingDataLength();
uint16_t getMaxConnectableAdvertisingDataLength();
uint16_t getMaxActiveSetAdvertisingDataLength();
#if BLE_FEATURE_EXTENDED_ADVERTISING
ble_error_t createAdvertisingSet(
advertising_handle_t *handle,
const AdvertisingParameters &parameters
);
ble_error_t destroyAdvertisingSet(advertising_handle_t handle);
#endif // BLE_FEATURE_EXTENDED_ADVERTISING
ble_error_t setAdvertisingParameters(
advertising_handle_t handle,
const AdvertisingParameters &params
);
ble_error_t setAdvertisingPayload(
advertising_handle_t handle,
mbed::Span<const uint8_t> payload
);
ble_error_t setAdvertisingScanResponse(
advertising_handle_t handle,
mbed::Span<const uint8_t> response
);
ble_error_t startAdvertising(
advertising_handle_t handle,
adv_duration_t maxDuration = adv_duration_t::forever(),
uint8_t maxEvents = 0
);
ble_error_t stopAdvertising(advertising_handle_t handle);
bool isAdvertisingActive(advertising_handle_t handle);
#endif // BLE_ROLE_BROADCASTER
#if BLE_ROLE_BROADCASTER
#if BLE_FEATURE_PERIODIC_ADVERTISING
ble_error_t setPeriodicAdvertisingParameters(
advertising_handle_t handle,
periodic_interval_t periodicAdvertisingIntervalMin,
periodic_interval_t periodicAdvertisingIntervalMax,
bool advertiseTxPower = true
);
ble_error_t setPeriodicAdvertisingPayload(
advertising_handle_t handle,
mbed::Span<const uint8_t> payload
);
ble_error_t startPeriodicAdvertising(advertising_handle_t handle);
ble_error_t stopPeriodicAdvertising(advertising_handle_t handle);
bool isPeriodicAdvertisingActive(advertising_handle_t handle);
#endif // BLE_ROLE_BROADCASTER
#endif // BLE_FEATURE_PERIODIC_ADVERTISING
/* scanning */
#if BLE_ROLE_OBSERVER
ble_error_t setScanParameters(const ScanParameters &params);
ble_error_t startScan(
scan_duration_t duration = scan_duration_t::forever(),
duplicates_filter_t filtering = duplicates_filter_t::DISABLE,
scan_period_t period = scan_period_t(0)
);
ble_error_t initiate_scan();
ble_error_t stopScan();
#endif // BLE_ROLE_OBSERVER
#if BLE_ROLE_OBSERVER
#if BLE_FEATURE_PERIODIC_ADVERTISING
ble_error_t createSync(
peer_address_type_t peerAddressType,
const address_t &peerAddress,
uint8_t sid,
slave_latency_t maxPacketSkip,
sync_timeout_t timeout
);
ble_error_t createSync(
slave_latency_t maxPacketSkip,
sync_timeout_t timeout
);
ble_error_t cancelCreateSync();
ble_error_t terminateSync(periodic_sync_handle_t handle);
ble_error_t addDeviceToPeriodicAdvertiserList(
peer_address_type_t peerAddressType,
const address_t &peerAddress,
advertising_sid_t sid
);
ble_error_t removeDeviceFromPeriodicAdvertiserList(
peer_address_type_t peerAddressType,
const address_t &peerAddress,
advertising_sid_t sid
);
ble_error_t clearPeriodicAdvertiserList();
uint8_t getMaxPeriodicAdvertiserListSize();
#endif // BLE_ROLE_OBSERVER
#endif // BLE_FEATURE_PERIODIC_ADVERTISING
#if BLE_ROLE_CENTRAL
ble_error_t connect(
peer_address_type_t peerAddressType,
const address_t &peerAddress,
const ConnectionParameters &connectionParams
);
ble_error_t cancelConnect();
#endif // BLE_ROLE_CENTRAL
#if BLE_FEATURE_CONNECTABLE
ble_error_t updateConnectionParameters(
connection_handle_t connectionHandle,
conn_interval_t minConnectionInterval,
conn_interval_t maxConnectionInterval,
slave_latency_t slaveLatency,
supervision_timeout_t supervision_timeout,
conn_event_length_t minConnectionEventLength = conn_event_length_t(0),
conn_event_length_t maxConnectionEventLength = conn_event_length_t(0)
);
ble_error_t manageConnectionParametersUpdateRequest(
bool userManageConnectionUpdateRequest
);
ble_error_t acceptConnectionParametersUpdate(
connection_handle_t connectionHandle,
conn_interval_t minConnectionInterval,
conn_interval_t maxConnectionInterval,
slave_latency_t slaveLatency,
supervision_timeout_t supervision_timeout,
conn_event_length_t minConnectionEventLength = conn_event_length_t(0),
conn_event_length_t maxConnectionEventLength = conn_event_length_t(0)
);
ble_error_t rejectConnectionParametersUpdate(
connection_handle_t connectionHandle
);
ble_error_t disconnect(
connection_handle_t connectionHandle,
local_disconnection_reason_t reason
);
#endif // BLE_FEATURE_CONNECTABLE
#if BLE_FEATURE_PHY_MANAGEMENT
ble_error_t readPhy(connection_handle_t connection);
ble_error_t setPreferredPhys(
const phy_set_t *txPhys,
const phy_set_t *rxPhys
);
ble_error_t setPhy(
connection_handle_t connection,
const phy_set_t *txPhys,
const phy_set_t *rxPhys,
coded_symbol_per_bit_t codedSymbol
);
#endif // BLE_FEATURE_PHY_MANAGEMENT
#if BLE_FEATURE_PRIVACY
ble_error_t enablePrivacy(bool enable);
#if BLE_ROLE_BROADCASTER
ble_error_t setPeripheralPrivacyConfiguration(
const peripheral_privacy_configuration_t *configuration
);
ble_error_t getPeripheralPrivacyConfiguration(
peripheral_privacy_configuration_t *configuration
);
#endif // BLE_ROLE_BROADCASTER
#if BLE_ROLE_OBSERVER
ble_error_t setCentralPrivacyConfiguration(
const central_privacy_configuration_t *configuration
);
ble_error_t getCentralPrivacyConfiguration(
central_privacy_configuration_t *configuration
);
#endif // BLE_ROLE_OBSERVER
#endif // BLE_FEATURE_PRIVACY
#if BLE_FEATURE_WHITELIST
uint8_t getMaxWhitelistSize() const;
ble_error_t getWhitelist(whitelist_t &whitelist) const;
ble_error_t setWhitelist(const whitelist_t &whitelist);
#endif // BLE_FEATURE_WHITELIST
ble_error_t getAddress(
own_address_type_t &typeP,
address_t &address
);
static ble_error_t getRandomAddressType(
ble::address_t address,
ble::random_address_type_t *addressType
);
ble_error_t reset();
void onShutdown(const GapShutdownCallback_t &callback);
GapShutdownCallbackChain_t &onShutdown();
#if !defined(DOXYGEN_ONLY)
/*
* API reserved for the controller driver to set the random static address.
* Setting a new random static address while the controller is operating is
* forbidden by the Bluetooth specification.
*/
ble_error_t setRandomStaticAddress(const ble::address_t &address);
ble::address_t getRandomStaticAddress();
#endif // !defined(DOXYGEN_ONLY)
/* ===================================================================== */
/* private implementation follows */
private:
/** List in random order */
template<typename EventType, typename IndexType, IndexType MAX_EVENTS>
class EventList {
public:
EventList()
{
};
~EventList()
{
for (IndexType i = 0; i < _current_size; ++i) {
delete _pointers[i];
}
};
/** Add event to the list. List takes ownership of memory.
*
* @param event List will point to this event.
* @return False if list full.
*/
bool push(EventType *event)
{
if (_current_size < MAX_EVENTS) {
_pointers[_current_size] = event;
_current_size++;
return true;
}
return false;
};
/** Take one entry of the list. Transfers ownership to caller.
*
* @return The event return. Memory belongs to caller.
*/
EventType* pop()
{
MBED_ASSERT(_current_size);
if (!_current_size) {
return nullptr;
}
EventType* event_returned = _pointers[_current_index];
_current_size--;
if (_current_size != _current_index) {
_pointers[_current_index] = _pointers[_current_size];
} else {
_current_index = 0;
}
return event_returned;
};
/** Return pointer to the first element that fulfills the passed in condition and remove the entry
* that was pointing to the item. Transfers ownership to caller.
*
* @param compare_func The condition that is checked for all the items.
* @return First element that fulfills the passed in condition or nullptr if no such item found.
*/
EventType* pop(mbed::Callback<bool(EventType&)> compare_func)
{
for (IndexType i = 0; i < _current_size ; ++i) {
if (compare_func(*_pointers[_current_index])) {
return pop();
}
increment_current_index();
}
return nullptr;
}
/** Return pointer to the first element that fulfills the passed in condition and remove the entry
* that was pointing to the item. Takes and returns number of failed matches allowing to speed up search.
* Transfers ownership to caller.
*
* @note Calls must be consecutive - any call to pop or find will invalidate the search.
*
* @param compare_func The condition that is checked for all the items.
* @param events_not_matching Pointer to the number of items already searched but not matching.
* This is updated in the method.
* @return First element that fulfills the passed in condition or nullptr if no such item found.
*/
EventType* continue_pop(mbed::Callback<bool(EventType&)> compare_func, IndexType *events_not_matching)
{
_current_index = *events_not_matching;
for (IndexType i = *events_not_matching; i < _current_size ; ++i) {
if (compare_func(*_pointers[_current_index])) {
return pop();
}
(*events_not_matching)++;
increment_current_index();
}
return nullptr;
}
/** Return pointer to the first element that fulfills the passed in condition. Does not remove item from list.
*
* @param compare_func The condition that is checked for all the items.
* @return First element that fulfills the passed in condition or nullptr if no such item found.
*/
EventType* find(mbed::Callback<bool(EventType&)> compare_func)
{
for (IndexType i = 0; i < _current_size ; ++i) {
if (compare_func(*_pointers[_current_index])) {
return _pointers[_current_index];
}
increment_current_index();
}
return nullptr;
}
/** Return number of events stored.
*
* @return Number of events stored.
*/
IndexType get_size()
{
return _current_size;
}
private:
void increment_current_index()
{
_current_index++;
if (_current_index == _current_size) {
_current_index = 0;
}
}
private:
EventType* _pointers[MAX_EVENTS];
IndexType _current_size = 0;
/* this helps us find the event faster */
IndexType _current_index = 0;
};
#if BLE_FEATURE_PRIVACY && BLE_GAP_HOST_BASED_PRIVATE_ADDRESS_RESOLUTION
class PendingAdvertisingReportEvent {
public:
PendingAdvertisingReportEvent(
const AdvertisingReportEvent& event_to_copy
) : event(event_to_copy)
{
/* copy the data to the buffer */
const mbed::Span<const uint8_t> payload = event_to_copy.getPayload();
if (payload.size()) {
advertising_data_buffer = new(std::nothrow) uint8_t[payload.size()];
if (advertising_data_buffer) {
memcpy(advertising_data_buffer, payload.data(), payload.size());
/* set the payload to our local copy of the data */
event.setAdvertisingData(mbed::make_Span(advertising_data_buffer, payload.size()));
}
}
};
~PendingAdvertisingReportEvent()
{
delete[] advertising_data_buffer;
}
bool is_valid()
{
return advertising_data_buffer || (event.getPayload().size() == 0);
}
AdvertisingReportEvent& get_pending_event()
{
return event;
}
private:
AdvertisingReportEvent event;
uint8_t *advertising_data_buffer = nullptr;
};
#endif // BLE_FEATURE_PRIVACY && BLE_GAP_HOST_BASED_PRIVATE_ADDRESS_RESOLUTION
private:
/* Disallow copy and assignment. */
Gap(const Gap &);
Gap &operator=(const Gap &);
Gap(
ble::PalEventQueue &event_queue,
ble::PalGap &pal_gap,
ble::PalGenericAccessService &generic_access_service
#if BLE_FEATURE_PRIVACY
, ble::PrivateAddressController &private_address_controller
#endif // BLE_FEATURE_PRIVACY
);
~Gap();
#if BLE_ROLE_BROADCASTER
ble_error_t setAdvertisingData(
advertising_handle_t handle,
Span<const uint8_t> payload,
bool minimiseFragmentation,
bool scan_response
);
void on_advertising_timeout();
void process_advertising_timeout();
#endif // BLE_ROLE_BROADCASTER
void on_gap_event_received(const GapEvent &e);
#if BLE_ROLE_OBSERVER
void on_advertising_report(const GapAdvertisingReportEvent &e);
#endif // BLE_ROLE_OBSERVER
#if BLE_FEATURE_CONNECTABLE
void on_connection_complete(const GapConnectionCompleteEvent &e);
void on_disconnection_complete(const GapDisconnectionCompleteEvent &e);
void on_connection_parameter_request(
const GapRemoteConnectionParameterRequestEvent &e
);
void on_connection_update(const GapConnectionUpdateEvent &e);
#endif // BLE_FEATURE_CONNECTABLE
void on_unexpected_error(const GapUnexpectedErrorEvent &e);
enum AddressUseType_t {
CENTRAL_CONNECTION,
CENTRAL_SCAN,
PERIPHERAL_CONNECTABLE,
PERIPHERAL_NON_CONNECTABLE
};
own_address_type_t get_own_address_type(AddressUseType_t address_use_type);
#if BLE_FEATURE_WHITELIST
bool initialize_whitelist() const;
#endif // BLE_FEATURE_WHITELIST
#if BLE_FEATURE_PRIVACY && !BLE_GAP_HOST_BASED_PRIVATE_ADDRESS_RESOLUTION
ble_error_t update_ll_address_resolution_setting();
#endif // BLE_FEATURE_PRIVACY && !BLE_GAP_HOST_BASED_PRIVATE_ADDRESS_RESOLUTION
#if BLE_ROLE_BROADCASTER
#if BLE_FEATURE_EXTENDED_ADVERTISING
ble_error_t setExtendedAdvertisingParameters(
advertising_handle_t handle,
const AdvertisingParameters &parameters
);
#endif // BLE_FEATURE_EXTENDED_ADVERTISING
#endif // BLE_ROLE_BROADCASTER
bool is_extended_advertising_available();
#if BLE_ROLE_BROADCASTER
#if BLE_FEATURE_EXTENDED_ADVERTISING
ble_error_t prepare_legacy_advertising_set(const AdvertisingParameters& parameters);
#endif // BLE_FEATURE_EXTENDED_ADVERTISING
#endif // BLE_ROLE_BROADCASTER
#if BLE_FEATURE_CONNECTABLE
/** Call the internal handlers that report to the security manager and GATT
* that a connection has been established.
*
* @param report Connection event
*/
void report_internal_connection_complete(const ConnectionCompleteEvent& report);
/** Pass the connection complete event to the application. This may involve privacy resolution.
*
* @param report Event to be passed to the user application.
*/
void signal_connection_complete(ConnectionCompleteEvent& report);
#if BLE_FEATURE_PRIVACY
/**
* Apply the privacy policies when the local peripheral is connected.
* @param event The connection event
* @return true if the policy process has been successful and false if the
* it fails meaning the process connection shouldn't continue.
*/
bool apply_peripheral_privacy_connection_policy(
const ConnectionCompleteEvent &event
);
#endif // BLE_FEATURE_PRIVACY
#if BLE_FEATURE_PRIVACY && BLE_GAP_HOST_BASED_PRIVATE_ADDRESS_RESOLUTION
/** Pass the connection complete event to the application after privacy resolution completed.
*
* @param event Event to be passed to the user application.
* @param identity_address_type Address type of the identity address.
* @param identity_address Address resolved by private address resolution, nullptr if no identity found.
*/
void conclude_signal_connection_complete_after_address_resolution(
ConnectionCompleteEvent &event,
target_peer_address_type_t identity_address_type,
const address_t *identity_address
);
#endif // BLE_FEATURE_PRIVACY && BLE_GAP_HOST_BASED_PRIVATE_ADDRESS_RESOLUTION
#endif // BLE_FEATURE_CONNECTABLE
#if BLE_ROLE_OBSERVER
/** Pass the advertising report to the application. This may involve privacy resolution.
*
* @param report Report to be passed to the user application.
*/
void signal_advertising_report(AdvertisingReportEvent& report);
#if BLE_FEATURE_PRIVACY && BLE_GAP_HOST_BASED_PRIVATE_ADDRESS_RESOLUTION
/** Pass the advertising report to the application after privacy resolution completed.
*
* @param event Event to be passed to the user application.
* @param identity_address_type Address type of the identity address.
* @param identity_address Address resolved by private address resolution, nullptr if no identity found.
*/
void conclude_signal_advertising_report_after_address_resolution(
AdvertisingReportEvent &event,
target_peer_address_type_t identity_address_type,
const address_t *identity_address
);
#endif // BLE_FEATURE_PRIVACY && BLE_GAP_HOST_BASED_PRIVATE_ADDRESS_RESOLUTION
#endif // BLE_ROLE_OBSERVER
/* implements PalGap::EventHandler */
private:
#if BLE_FEATURE_PHY_MANAGEMENT
void on_read_phy(
hci_error_code_t hci_status,
connection_handle_t connection_handle,
phy_t tx_phy,
phy_t rx_phy
) override;
#endif // BLE_FEATURE_PHY_MANAGEMENT
#if BLE_FEATURE_CONNECTABLE
void on_data_length_change(
connection_handle_t connection_handle,
uint16_t tx_size,
uint16_t rx_size
) override;
#endif
#if BLE_FEATURE_PHY_MANAGEMENT
void on_phy_update_complete(
hci_error_code_t hci_status,
connection_handle_t connection_handle,
phy_t tx_phy,
phy_t rx_phy
) override;
#endif // BLE_FEATURE_PHY_MANAGEMENT
#if BLE_ROLE_OBSERVER
#if BLE_FEATURE_EXTENDED_ADVERTISING
void on_extended_advertising_report(
advertising_event_t event_type,
const connection_peer_address_type_t *address_type,
const ble::address_t &address,
phy_t primary_phy,
const phy_t *secondary_phy,
advertising_sid_t advertising_sid,
advertising_power_t tx_power,
rssi_t rssi,
uint16_t periodic_advertising_interval,
direct_address_type_t direct_address_type,
const ble::address_t &direct_address,
uint8_t data_length,
const uint8_t *data
) override;
#endif // BLE_FEATURE_EXTENDED_ADVERTISING
#if BLE_FEATURE_PERIODIC_ADVERTISING
void on_periodic_advertising_sync_established(
hci_error_code_t error,
sync_handle_t sync_handle,
advertising_sid_t advertising_sid,
connection_peer_address_type_t advertiser_address_type,
const ble::address_t &advertiser_address,
phy_t advertiser_phy,
uint16_t periodic_advertising_interval,
clock_accuracy_t clock_accuracy
) override;
void on_periodic_advertising_report(
sync_handle_t sync_handle,
advertising_power_t tx_power,
rssi_t rssi,
advertising_data_status_t data_status,
uint8_t data_length,
const uint8_t *data
) override;
void on_periodic_advertising_sync_loss(sync_handle_t sync_handle) override;
#endif // BLE_FEATURE_PERIODIC_ADVERTISING
#endif // BLE_ROLE_OBSERVER
#if BLE_ROLE_BROADCASTER
void on_legacy_advertising_started() override;
void on_legacy_advertising_stopped() override;
#if BLE_FEATURE_EXTENDED_ADVERTISING
void on_advertising_set_started(const mbed::Span<const uint8_t>& handles) override;
void on_advertising_set_terminated(
hci_error_code_t status,
advertising_handle_t advertising_handle,
connection_handle_t connection_handle,
uint8_t number_of_completed_extended_advertising_events
) override;
void on_scan_request_received(
advertising_handle_t advertising_handle,
connection_peer_address_type_t scanner_address_type,
const ble::address_t &address
) override;
#endif // BLE_FEATURE_EXTENDED_ADVERTISING
#endif // BLE_ROLE_BROADCASTER
#if BLE_FEATURE_CONNECTABLE
void on_connection_update_complete(
hci_error_code_t status,
connection_handle_t connection_handle,
uint16_t connection_interval,
uint16_t connection_latency,
uint16_t supervision_timeout
) override;
void on_remote_connection_parameter(
connection_handle_t connection_handle,
uint16_t connection_interval_min,
uint16_t connection_interval_max,
uint16_t connection_latency,
uint16_t supervision_timeout
) override;
#endif // BLE_FEATURE_CONNECTABLE
#if BLE_ROLE_OBSERVER
void on_scan_started(bool success) override;
void on_scan_stopped(bool success) override;
void on_scan_timeout() override;
void process_legacy_scan_timeout();
#endif // BLE_ROLE_OBSERVER
#if BLE_FEATURE_PRIVACY
/* Implement PrivateAddressController::EventHandler */
private:
void on_resolvable_private_addresses_generated(const address_t &address) final;
void on_non_resolvable_private_addresses_generated(const address_t &address) final;
void on_private_address_generated(bool connectable);
#if BLE_GAP_HOST_BASED_PRIVATE_ADDRESS_RESOLUTION
void on_address_resolution_completed(
const address_t &peer_resolvable_address,
bool resolved,
target_peer_address_type_t identity_address_type,
const address_t &identity_address
) final;
#endif // BLE_GAP_HOST_BASED_PRIVATE_ADDRESS_RESOLUTION
#endif // BLE_FEATURE_PRIVACY
private:
bool is_advertising() const;
bool is_radio_active() const;
void update_advertising_set_connectable_attribute(
advertising_handle_t handle,
const AdvertisingParameters& parameters
);
enum class controller_operation_t {
scanning, advertising, initiating
};
const address_t *get_random_address(controller_operation_t operation, size_t advertising_set = 0);
#if BLE_GAP_HOST_BASED_PRIVATE_ADDRESS_RESOLUTION
void connecting_to_host_resolved_address_failed(bool inform_user = true);
#endif // BLE_GAP_HOST_BASED_PRIVATE_ADDRESS_RESOLUTION
private:
/**
* Callchain containing all registered callback handlers for shutdown
* events.
*/
GapShutdownCallbackChain_t shutdownCallChain;
/**
* Event handler provided by the application.
*/
ble::Gap::EventHandler *_event_handler;
#if BLE_FEATURE_PRIVACY && BLE_GAP_HOST_BASED_PRIVATE_ADDRESS_RESOLUTION
#if BLE_ROLE_OBSERVER
EventList<PendingAdvertisingReportEvent, uint8_t, BLE_GAP_MAX_ADVERTISING_REPORTS_PENDING_ADDRESS_RESOLUTION> _reports_pending_address_resolution;
#endif // BLE_ROLE_OBSERVER
#if BLE_FEATURE_CONNECTABLE
EventList<ConnectionCompleteEvent, uint8_t, DM_CONN_MAX> _connections_pending_address_resolution;
#endif // BLE_FEATURE_CONNECTABLE
#endif // BLE_FEATURE_PRIVACY && BLE_GAP_HOST_BASED_PRIVATE_ADDRESS_RESOLUTION
PalEventQueue &_event_queue;
PalGap &_pal_gap;
PalGenericAccessService &_gap_service;
#if BLE_FEATURE_PRIVACY
PrivateAddressController &_private_address_controller;
#endif // BLE_FEATURE_PRIVACY
ble::own_address_type_t _address_type;
initiator_policy_t _initiator_policy_mode;
scanning_filter_policy_t _scanning_filter_policy;
advertising_filter_policy_t _advertising_filter_policy;
mutable whitelist_t _whitelist;
bool _privacy_enabled;
#if BLE_FEATURE_PRIVACY
bool _privacy_initialization_pending = false;
#if BLE_ROLE_PERIPHERAL
peripheral_privacy_configuration_t _peripheral_privacy_configuration;
#endif // BLE_ROLE_PERIPHERAL
#if BLE_ROLE_OBSERVER
central_privacy_configuration_t _central_privacy_configuration;
#endif //BLE_ROLE_OBSERVER
#endif // BLE_FEATURE_PRIVACY
ble::address_t _random_static_identity_address;
enum class ScanState : uint8_t {
idle,
scan,
pending_scan,
pending_stop_scan
};
ScanState _scan_state = ScanState::idle;
scan_duration_t _scan_requested_duration = scan_duration_t::forever();
duplicates_filter_t _scan_requested_filtering = duplicates_filter_t::DISABLE;
scan_period_t _scan_requested_period = scan_period_t(0);
bool _scan_requested = false;
#if BLE_GAP_HOST_BASED_PRIVATE_ADDRESS_RESOLUTION
enum class ConnectionToHostResolvedAddressState : uint8_t {
idle,
scan,
connect
};
ble::address_t _connect_to_host_resolved_address;
peer_address_type_t _connect_to_host_resolved_address_type = peer_address_type_t::ANONYMOUS;
ConnectionToHostResolvedAddressState _connect_to_host_resolved_address_state = ConnectionToHostResolvedAddressState::idle;
ConnectionParameters *_connect_to_host_resolved_address_parameters = nullptr;
#endif // BLE_GAP_HOST_BASED_PRIVATE_ADDRESS_RESOLUTION
mbed::LowPowerTimeout _advertising_timeout;
mbed::LowPowerTimeout _scan_timeout;
mbed::LowPowerTicker _address_rotation_ticker;
bool _initiating = false;
template<size_t bit_size>
struct BitArray {
BitArray() : data()
{
}
bool get(size_t index) const
{
position p(index);
return (data[p.byte_index] >> p.bit_index) & 0x01;
}
void set(size_t index)
{
position p(index);
data[p.byte_index] |= (0x01 << p.bit_index);
}
void clear(size_t index)
{
position p(index);
data[p.byte_index] &= ~(0x01 << p.bit_index);
}
void clear()
{
for (size_t i = 0; i < (bit_size / 8 + 1); ++i) {
data[i] = 0;
}
}
private:
struct position {
position(size_t bit_number) :
byte_index(bit_number / 8),
bit_index(bit_number % 8)
{
}
size_t byte_index;
uint8_t bit_index;
};
uint8_t data[bit_size / 8 + 1];
};
BitArray<BLE_GAP_MAX_ADVERTISING_SETS> _existing_sets;
BitArray<BLE_GAP_MAX_ADVERTISING_SETS> _active_sets;
BitArray<BLE_GAP_MAX_ADVERTISING_SETS> _active_periodic_sets;
BitArray<BLE_GAP_MAX_ADVERTISING_SETS> _connectable_payload_size_exceeded;
BitArray<BLE_GAP_MAX_ADVERTISING_SETS> _set_is_connectable;
BitArray<BLE_GAP_MAX_ADVERTISING_SETS> _pending_sets;
BitArray<BLE_GAP_MAX_ADVERTISING_SETS> _address_refresh_sets;
BitArray<BLE_GAP_MAX_ADVERTISING_SETS> _interruptible_sets;
BitArray<BLE_GAP_MAX_ADVERTISING_SETS> _adv_started_from_refresh;
bool _user_manage_connection_parameter_requests : 1;
};
} // namespace impl
} // namespace ble
#endif //IMPL_GAP_GAP_H
Reference in New Issue View Git Blame Copy Permalink