gap.hpp

Go to the documentation of this file.

 
#ifndef ELEC_C7222_BLE_GAP_H_
#define ELEC_C7222_BLE_GAP_H_
 
#include <cassert>
#include <cstddef>
#include <cstdint>
#include <iosfwd>
#include <list>
#include <map>
#include <vector>
 
#include "advertisement_data.hpp"
#include "ble_address.hpp"
#include "ble_error.hpp"
#include "non_copyable.hpp"
 
namespace c7222 {
 
using ConnectionHandle = uint16_t;
 
class Gap : public NonCopyableNonMovable {
   public:
    enum class EventId : uint8_t {
        kSecurityLevel,
        kDedicatedBondingCompleted,
        kAdvertisingReport,
        kExtendedAdvertisingReport,
        kInquiryResult,
        kInquiryComplete,
        kRssiMeasurement,
        kLocalOobData,
        kPairingStarted,
        kPairingComplete,
        kDisconnectionComplete,
        kCommandComplete,
        kLeScanRequestReceived,
        kLeScanTimeout,
        kLePeriodicAdvertisingSyncEstablished,
        kLePeriodicAdvertisingReport,
        kLePeriodicAdvertisingSyncLost,
        kLeConnectionComplete,
        kLeEnhancedConnectionComplete,
        kLeRemoteConnectionParameterRequest,
        kLeConnectionUpdateComplete,
        kLePhyUpdateComplete,
        kLeDataLengthChange,
        kLeAdvertisingSetTerminated,
        kL2capConnectionParameterUpdateRequest,
        kPrivacyEnabled
    };
    enum class AdvertisingEventType : uint16_t {
        kConnectable = 0x0001,
        kScannable = 0x0002,
        kDirected = 0x0004,
        kHighDutyCycle = 0x0008,
        kLegacy = 0x0010,
        kAnonymous = 0x0020,
        kIncludeTxPower = 0x0040
    };
 
    enum class Phy : uint8_t {
        kNone = 0x00,
        kLe1M = 0x01,
        kLe2M = 0x02,
        kLeCoded = 0x03
    };
 
    enum class AdvertisingType : uint8_t {
        kAdvInd = 0x00,
        kAdvDirectInd = 0x01,
        kAdvScanInd = 0x02,
        kAdvNonConnInd = 0x03
    };
 
    enum class DirectAddressType : uint8_t {
        kPublic = 0x00,
        kRandom = 0x01
    };
 
    enum class AdvertisingChannelMap : uint8_t {
        kChannel37 = 0x01,
        kChannel38 = 0x02,
        kChannel39 = 0x04,
        kAll = 0x07
    };
 
    enum class AdvertisingFilterPolicy : uint8_t {
        kScanAnyConnectAny = 0x00,
        kScanWhitelistConnectAny = 0x01,
        kScanAnyConnectWhitelist = 0x02,
        kScanWhitelistConnectWhitelist = 0x03
    };
 
    struct AdvertisingReport {
        AdvertisingEventType advertising_event_type;
        BleAddress address;
        int8_t rssi;
        const uint8_t* data;
        uint8_t data_length;
        friend std::ostream& operator<<(std::ostream& os, const AdvertisingReport& ar);
    };
 
    struct ExtendedAdvertisingReport {
        AdvertisingEventType advertising_event_type;
        BleAddress address;
        Phy primary_phy;
        Phy secondary_phy;
        uint8_t advertising_sid;
        int8_t tx_power;
        int8_t rssi;
        uint16_t periodic_advertising_interval;
        BleAddress direct_address;
        const uint8_t* data;
        uint8_t data_length;
        friend std::ostream& operator<<(std::ostream& os, const ExtendedAdvertisingReport& ear);
    };
 
    struct InquiryResult {
        BleAddress address;
        uint8_t page_scan_repetition_mode;
        uint32_t class_of_device;
        uint16_t clock_offset;
        bool rssi_available;
        int8_t rssi;
        bool device_id_available;
        uint16_t device_id_vendor_id_source;
        uint16_t device_id_vendor_id;
        uint16_t device_id_product_id;
        uint16_t device_id_version;
        bool name_available;
        const uint8_t* name;
        uint8_t name_len;
 
        friend std::ostream& operator<<(std::ostream& os, const InquiryResult& ir);
    };
 
    struct EventHandler {
        virtual void OnScanRequestReceived(uint8_t advertising_handle,
                                           const BleAddress& scanner_address) const {}
 
        virtual void OnAdvertisingStart(uint8_t status) const {}
 
        virtual void OnAdvertisingEnd(uint8_t status, ConnectionHandle connection_handle) const {}
 
        virtual void OnAdvertisingReport(const AdvertisingReport& report) const {}
 
        virtual void OnExtendedAdvertisingReport(const ExtendedAdvertisingReport& report) const {}
 
        virtual void OnScanTimeout(uint8_t status) const {}
 
        virtual void OnPeriodicAdvertisingSyncEstablished(uint8_t status,
                                                          ConnectionHandle sync_handle) const {}
 
        virtual void OnPeriodicAdvertisingReport(ConnectionHandle sync_handle,
                                                 int8_t tx_power,
                                                 int8_t rssi,
                                                 uint8_t data_status,
                                                 const uint8_t* data,
                                                 uint8_t data_length) const {}
 
        virtual void OnPeriodicAdvertisingSyncLoss(ConnectionHandle sync_handle) const {}
 
        virtual void OnConnectionComplete(uint8_t status,
                                          ConnectionHandle con_handle,
                                          const BleAddress& address,
                                          uint16_t conn_interval,
                                          uint16_t conn_latency,
                                          uint16_t supervision_timeout) const {}
 
        virtual void OnUpdateConnectionParametersRequest(ConnectionHandle con_handle,
                                                         uint16_t min_interval,
                                                         uint16_t max_interval,
                                                         uint16_t latency,
                                                         uint16_t supervision_timeout) const {}
 
        virtual void OnConnectionParametersUpdateComplete(uint8_t status,
                                                          ConnectionHandle con_handle,
                                                          uint16_t conn_interval,
                                                          uint16_t conn_latency,
                                                          uint16_t supervision_timeout) const {}
 
        virtual void OnDisconnectionComplete(uint8_t status,
                                             ConnectionHandle con_handle,
                                             uint8_t reason) const {}
 
        virtual void
        OnReadPhy(uint8_t status, ConnectionHandle con_handle, Phy tx_phy, Phy rx_phy) const {}
 
        virtual void OnPhyUpdateComplete(uint8_t status,
                                         ConnectionHandle con_handle,
                                         Phy tx_phy,
                                         Phy rx_phy) const {}
 
        virtual void OnDataLengthChange(ConnectionHandle con_handle,
                                        uint16_t tx_size,
                                        uint16_t rx_size) const {}
 
        virtual void OnPrivacyEnabled() const {}
 
        virtual void OnSecurityLevel(ConnectionHandle con_handle, uint8_t security_level) const {}
 
        virtual void OnDedicatedBondingCompleted(uint8_t status, const BleAddress& address) const {}
 
        virtual void OnInquiryResult(const InquiryResult& result) const {}
 
        virtual void OnInquiryComplete(uint8_t status) const {}
 
        virtual void OnRssiMeasurement(ConnectionHandle con_handle, int8_t rssi) const {}
 
        virtual void OnLocalOobData(bool oob_data_present,
                                    const uint8_t* c_192,
                                    const uint8_t* r_192,
                                    const uint8_t* c_256,
                                    const uint8_t* r_256) const {}
 
        virtual void OnPairingStarted(ConnectionHandle con_handle,
                                      const BleAddress& address,
                                      bool ssp,
                                      bool initiator) const {}
 
        virtual void OnPairingComplete(ConnectionHandle con_handle,
                                       const BleAddress& address,
                                       uint8_t status) const {}
 
       protected:
        ~EventHandler() = default;
    };
 
    struct AdvertisementParameters {
        AdvertisingType advertising_type;
        DirectAddressType direct_address_type;
        BleAddress direct_address;
        uint16_t min_interval;
        uint16_t max_interval;
        uint8_t channel_map;
        AdvertisingFilterPolicy filter_policy;
 
        AdvertisementParameters()
            : advertising_type(AdvertisingType::kAdvInd),
              direct_address_type(DirectAddressType::kPublic),
              direct_address(),
              min_interval(0x00A0),
              max_interval(0x00F0),
              channel_map(static_cast<uint8_t>(AdvertisingChannelMap::kAll)),
              filter_policy(AdvertisingFilterPolicy::kScanAnyConnectAny) {}
    };
 
    struct PreferredConnectionParameters {
        uint16_t min_interval;
        uint16_t max_interval;
        uint16_t slave_latency;
        uint16_t supervision_timeout;
    };
 
    struct ConnectionParameters {
        uint16_t interval;
        uint16_t latency;
        uint16_t supervision_timeout;
    };
 
    void SetRandomAddress(const BleAddress& address);
 
    void SetAdvertisingParameters(const AdvertisementParameters& params);
 
    void SetAdvertisingData(const uint8_t* data, size_t size);
 
    void SetAdvertisingData(const std::vector<uint8_t>& data) {
        SetAdvertisingData(data.data(), data.size());
    }
 
    void SetAdvertisingData(const AdvertisementDataBuilder& data_builder);
 
    void SetAdvertisingData() {
        bool ok = advertisement_data_builder_.Build();
        assert(ok && "AdvertisementDataBuilder contains invalid data or is empty");
        SetAdvertisingData(advertisement_data_builder_.data());
    }
 
    void SetScanResponseData(uint8_t length, const uint8_t* data);
 
    void EnableAdvertising(bool enabled);
 
    void StartAdvertising();
    void StopAdvertising();
 
    BleError RequestConnectionParameterUpdate(ConnectionHandle con_handle,
                                              const PreferredConnectionParameters& params);
 
    BleError UpdateConnectionParameters(ConnectionHandle con_handle,
                                        const PreferredConnectionParameters& params);
 
    BleError ReadRssi(ConnectionHandle con_handle);
 
    BleError Disconnect(ConnectionHandle con_handle);
 
    void SetLocalAddress(BleAddress& address);
 
    void AddEventHandler(const EventHandler& handler);
    bool RemoveEventHandler(const EventHandler& handler);
 
    void ClearEventHandlers();
 
    std::list<const EventHandler*> GetEventHandlers() const {
        return event_handlers_;
    }
 
    bool GetConnectionParameters(ConnectionHandle con_handle, ConnectionParameters& out) const;
 
    bool IsAdvertisingEnabled() const {
        return advertisement_enabled_;
    }
 
    bool IsAdvertising() const {
        return advertising_;
    }
 
    bool IsAdvertisingParametersSet() const {
        return advertising_params_set_;
    }
 
    bool IsConnected() const {
        return connected_;
    }
 
    bool GetRandomAddress(BleAddress& address) const;
 
    bool IsRandomAddressSet() const {
        return random_address_set_;
    }
 
    bool GetAdvertisingParameters(AdvertisementParameters& params) const;
 
    const std::vector<uint8_t>& GetAdvertisingData() const {
        return advertisement_data_builder_.data();
    }
 
    AdvertisementDataBuilder& GetAdvertisementDataBuilder() {
        return advertisement_data_builder_;
    }
 
    const AdvertisementDataBuilder& GetAdvertisementDataBuilder() const {
        return advertisement_data_builder_;
    }
 
    bool IsAdvertisingDataSet() const {
        return advertising_data_set_;
    }
 
    const std::vector<uint8_t>& scan_response_data() const {
        return scan_response_data_;
    }
 
    bool IsScanResponseDataSet() const {
        return scan_response_data_set_;
    }
 
    const std::map<ConnectionHandle, ConnectionParameters>& GetConnectionParameters() const {
        return connection_parameters_;
    }
 
    static Gap* GetInstance();
 
    virtual BleError DispatchBleHciPacket(uint8_t packet_type,
                                          const uint8_t* packet_data,
                                          uint16_t packet_data_size);
 
   protected:
    virtual BleError DispatchEvent(EventId event_id,
                                   const uint8_t* event_data,
                                   uint16_t event_data_size);
 
   private:
    Gap() = default;
    Gap(const Gap&) = delete;
    Gap& operator=(const Gap&) = delete;
 
    ~Gap() = default;
 
    static Gap* instance_;
 
    bool advertisement_enabled_ = false;
 
    bool advertising_ = false;
    bool advertising_params_set_ = false;
 
    AdvertisementDataBuilder advertisement_data_builder_{};
    bool connected_ = false;
 
    BleAddress random_address_{};
    bool random_address_set_ = false;
 
    AdvertisementParameters advertising_params_{};
    bool advertising_data_set_ = false;
 
    std::vector<uint8_t> scan_response_data_{};
    bool scan_response_data_set_ = false;
 
    std::map<ConnectionHandle, ConnectionParameters> connection_parameters_;
    std::list<const EventHandler*> event_handlers_;
};
 
}  // namespace c7222
 
std::ostream& operator<<(std::ostream& os, c7222::Gap::AdvertisingEventType type);
std::ostream& operator<<(std::ostream& os, c7222::Gap::Phy phy);
std::ostream& operator<<(std::ostream& os, c7222::Gap::AdvertisingType type);
std::ostream& operator<<(std::ostream& os, c7222::Gap::DirectAddressType type);
std::ostream& operator<<(std::ostream& os, c7222::Gap::AdvertisingChannelMap map);
std::ostream& operator<<(std::ostream& os, c7222::Gap::AdvertisingFilterPolicy policy);
 
constexpr uint8_t operator|(c7222::Gap::AdvertisingChannelMap lhs,
                            c7222::Gap::AdvertisingChannelMap rhs) {
    return static_cast<uint8_t>(lhs) | static_cast<uint8_t>(rhs);
}
constexpr uint8_t operator|(uint8_t lhs, c7222::Gap::AdvertisingChannelMap rhs) {
    uint8_t ret = lhs | static_cast<uint8_t>(rhs);
    assert(ret <= static_cast<uint8_t>(c7222::Gap::AdvertisingChannelMap::kAll));
    return ret;
}
constexpr uint8_t operator|=(uint8_t lhs, c7222::Gap::AdvertisingChannelMap rhs) {
    uint8_t ret = lhs | static_cast<uint8_t>(rhs);
    assert(ret <= static_cast<uint8_t>(c7222::Gap::AdvertisingChannelMap::kAll));
    return ret;
}
constexpr uint8_t operator|(c7222::Gap::AdvertisingChannelMap lhs, uint8_t rhs) {
    uint8_t ret = static_cast<uint8_t>(lhs) | rhs;
    assert(ret <= static_cast<uint8_t>(c7222::Gap::AdvertisingChannelMap::kAll));
    return ret;
}
 
constexpr uint8_t operator&(c7222::Gap::AdvertisingChannelMap lhs,
                            c7222::Gap::AdvertisingChannelMap rhs) {
    return static_cast<uint8_t>(lhs) & static_cast<uint8_t>(rhs);
}
 
constexpr uint8_t operator&(uint8_t lhs, c7222::Gap::AdvertisingChannelMap rhs) {
    uint8_t ret = lhs & static_cast<uint8_t>(rhs);
    assert(ret <= static_cast<uint8_t>(c7222::Gap::AdvertisingChannelMap::kAll));
    return ret;
}
 
constexpr uint8_t operator&=(uint8_t lhs, c7222::Gap::AdvertisingChannelMap rhs) {
    uint8_t ret = lhs & static_cast<uint8_t>(rhs);
    assert(ret <= static_cast<uint8_t>(c7222::Gap::AdvertisingChannelMap::kAll));
    return ret;
}
 
constexpr uint8_t operator&(c7222::Gap::AdvertisingChannelMap lhs, uint8_t rhs) {
    uint8_t ret = static_cast<uint8_t>(lhs) & rhs;
    assert(ret <= static_cast<uint8_t>(c7222::Gap::AdvertisingChannelMap::kAll));
    return ret;
}
 
constexpr uint8_t operator^(uint8_t lhs, c7222::Gap::AdvertisingChannelMap rhs) {
    uint8_t ret = lhs ^ static_cast<uint8_t>(rhs);
    assert(ret <= static_cast<uint8_t>(c7222::Gap::AdvertisingChannelMap::kAll));
    return ret;
}
constexpr uint8_t operator^=(uint8_t lhs, c7222::Gap::AdvertisingChannelMap rhs) {
    uint8_t ret = lhs ^ static_cast<uint8_t>(rhs);
    assert(ret <= static_cast<uint8_t>(c7222::Gap::AdvertisingChannelMap::kAll));
    return ret;
}
constexpr uint8_t operator^(c7222::Gap::AdvertisingChannelMap lhs, uint8_t rhs) {
    uint8_t ret = static_cast<uint8_t>(lhs) & rhs;
    assert(ret <= static_cast<uint8_t>(c7222::Gap::AdvertisingChannelMap::kAll));
    return ret;
}
 
#endif  // ELEC_C7222_BLE_GAP_H_