cs_Advertiser.h

Go to the documentation of this file.

/*
 * Author: Crownstone Team
 * Copyright: Crownstone (https://crownstone.rocks)
 * Date: Sep 13, 2019
 * License: LGPLv3+, Apache License 2.0, and/or MIT (triple-licensed)
 */
 
#pragma once
 
#include <ble/cs_Nordic.h>
#include <ble/cs_ServiceData.h>
#include <ble/cs_Stack.h>
#include <ble/cs_iBeacon.h>
#include <cfg/cs_Config.h>
#include <cfg/cs_StaticConfig.h>
#include <events/cs_EventListener.h>
 
#include <cstdint>
 
class Advertiser : EventListener {
private:
    Advertiser();
 
public:
    static Advertiser& getInstance() {
        static Advertiser instance;
        return instance;
    }
    Advertiser(Advertiser const&)     = delete;
    void operator=(Advertiser const&) = delete;
 
    void init();
 
    void setDeviceName(const std::string& deviceName);
 
    void setAdvertisingInterval(uint16_t advertisingInterval);
 
    void setTxPower(int8_t power);
 
    void setLowTxPower();
 
    void setNormalTxPower();
 
    void setConnectable(bool connectable);
 
    void configureAdvertisement(IBeacon& beacon, bool asScanResponse = false);
 
    void configureAdvertisement(ServiceData& serviceData, bool asScanResponse = false);
 
    void startAdvertising();
 
    void stopAdvertising();
 
    void handleEvent(event_t& event);
 
private:
    // Pointer to the BLE stack.
    Stack* _stack                 = nullptr;
 
 
    // Whether the advertiser has been initialized.
    bool _isInitialized           = false;
 
    // Whether currently advertising. This value might be out of sync.
    bool _advertising             = false;
 
    // Whether we should be advertising.
    bool _wantAdvertising         = false;
 
    // Whether to start advertising on next tick.
    bool _startOnNextTick         = false;
 
    // Advertisement handle for softdevice. Set by first call to: sd_ble_gap_adv_set_configure().
    uint8_t _advHandle            = BLE_GAP_ADV_SET_HANDLE_NOT_SET;
 
 
    // Transmit power.
    int8_t _txPower               = 0;
 
    // Advertisement parameter: interval.
    uint16_t _advertisingInterval = g_ADVERTISEMENT_INTERVAL;
 
    // Advertisement parameters for softdevice.
    ble_gap_adv_params_t _advParams;
 
    // Whether advertising parameters have been changed.
    bool _advParamsChanged = false;
 
    // Whether the advertisement is connectable.
    bool _isConnectable    = false;
 
    // Whether we want to advertise being connectable.
    bool _wantConnectable  = true;
 
 
    // iBeacon data field to be encoded into advertisement data.
    ble_advdata_manuf_data_t _ibeaconManufData;
 
    // Service data field to be encoded into advertisement data.
    ble_advdata_service_data_t _crownstoneServiceData;
 
    // Pointer to up to data crownstone service data.
    ServiceData* _serviceData = nullptr;
 
    // Advertised name
    std::string _deviceName   = "none";
 
 
    ble_advdata_t _configAdvertisementData;
 
    ble_advdata_t _configScanResponse;
 
    bool _includeAdvertisementData                                        = false;
 
    bool _includeScanResponseData                                         = false;
 
    // Number of buffers for advertisement / scan response data.
    const static uint8_t _advertisementDataBufferCount                    = 2;
 
    // Size of advertisement / scan response data buffers.
    const static uint8_t _advertisementDataBufferSize                     = BLE_GAP_ADV_SET_DATA_SIZE_MAX;
 
    // Pointers to advertisement data buffers. Half of these are scan response data buffers.
    uint8_t* _advertisementDataBuffers[2 * _advertisementDataBufferCount] = {nullptr};
 
    // Pointers to the currently advertised advertisement and scan response data buffer.
    ble_gap_adv_data_t _advData;
 
    // Keep up which buffers are currently being used in an advertisement.
    bool _advertisementDataBuffersInUse[2 * _advertisementDataBufferCount] = {false};
 
    void configureAdvertisementParameters();
 
    void setAdvertisementData(ServiceData& serviceData, bool asScanResponse);
 
    void setAdvertisementData(IBeacon& beacon, bool asScanResponse);
 
    void updateAdvertisementData();
 
    void updateAdvertisementParams();
 
    void updateTxPower();
 
    void restartAdvertising();
 
    void setConnectableAdvParams();
 
    void setNonConnectableAdvParams();
 
    bool allocateAdvertisementDataBuffers(bool scanResponse);
 
    uint8_t* getAdvertisementBuffer(bool scanResponse);
 
    void markAdvertisementBuffer(const uint8_t* buffer, bool inUse, bool scanResponse);
 
    void onConnect(const ble_connected_t& connectedData);
 
    void onDisconnect();
 
    void onConnectOutgoing();
 
    void onTick();
 
    void printAdvertisement();
};