NimBLEAdvertisedDevice.h

/*
 * NimBLEAdvertisedDevice.h
 *
 *  Created: on Jan 24 2020
 *      Author H2zero
 *
 * Originally:
 *
 * BLEAdvertisedDevice.h
 *
 *  Created on: Jul 3, 2017
 *      Author: kolban
 */
 
#ifndef COMPONENTS_NIMBLEADVERTISEDDEVICE_H_
#define COMPONENTS_NIMBLEADVERTISEDDEVICE_H_
#include "nimconfig.h"
#if defined(CONFIG_BT_ENABLED) && defined(CONFIG_BT_NIMBLE_ROLE_OBSERVER)
 
#include "NimBLEAddress.h"
#include "NimBLEScan.h"
#include "NimBLEUUID.h"
 
#if defined(CONFIG_NIMBLE_CPP_IDF)
#include "host/ble_hs_adv.h"
#else
#include "nimble/nimble/host/include/host/ble_hs_adv.h"
#endif
 
#include <map>
#include <vector>
#include <time.h>
 
 
class NimBLEScan;
class NimBLEAdvertisedDevice {
public:
    NimBLEAdvertisedDevice();
 
    NimBLEAddress   getAddress();
    uint8_t         getAdvType();
    uint16_t        getAppearance();
    uint16_t        getAdvInterval();
    uint16_t        getMinInterval();
    uint16_t        getMaxInterval();
    std::string     getManufacturerData();
    std::string     getURI();
 
    template<typename T>
    T       getManufacturerData(bool skipSizeCheck = false) {
        std::string data = getManufacturerData();
        if(!skipSizeCheck && data.size() < sizeof(T)) return T();
        const char *pData = data.data();
        return *((T *)pData);
    }
 
    std::string     getName();
    int             getRSSI();
    NimBLEScan*     getScan();
    uint8_t         getServiceDataCount();
    std::string     getServiceData(uint8_t index = 0);
    std::string     getServiceData(const NimBLEUUID &uuid);
 
    template<typename T>
    T       getServiceData(uint8_t index = 0, bool skipSizeCheck = false) {
        std::string data = getServiceData(index);
        if(!skipSizeCheck && data.size() < sizeof(T)) return T();
        const char *pData = data.data();
        return *((T *)pData);
    }
 
    template<typename T>
    T       getServiceData(const NimBLEUUID &uuid, bool skipSizeCheck = false) {
        std::string data = getServiceData(uuid);
        if(!skipSizeCheck && data.size() < sizeof(T)) return T();
        const char *pData = data.data();
        return *((T *)pData);
    }
 
    NimBLEUUID      getServiceDataUUID(uint8_t index = 0);
    NimBLEUUID      getServiceUUID(uint8_t index = 0);
    uint8_t         getServiceUUIDCount();
    NimBLEAddress   getTargetAddress(uint8_t index = 0);
    uint8_t         getTargetAddressCount();
    int8_t          getTXPower();
    uint8_t*        getPayload();
    uint8_t         getAdvLength();
    size_t          getPayloadLength();
    uint8_t         getAddressType();
    time_t          getTimestamp();
    bool            isAdvertisingService(const NimBLEUUID &uuid);
    bool            haveAppearance();
    bool            haveManufacturerData();
    bool            haveName();
    bool            haveRSSI();
    bool            haveServiceData();
    bool            haveServiceUUID();
    bool            haveTXPower();
    bool            haveConnParams();
    bool            haveAdvInterval();
    bool            haveTargetAddress();
    bool            haveURI();
    std::string     toString();
    bool            isConnectable();
    bool            isLegacyAdvertisement();
#if CONFIG_BT_NIMBLE_EXT_ADV
    uint8_t         getSetId();
    uint8_t         getPrimaryPhy();
    uint8_t         getSecondaryPhy();
    uint16_t        getPeriodicInterval();
#endif
 
private:
    friend class NimBLEScan;
 
    void    setAddress(NimBLEAddress address);
    void    setAdvType(uint8_t advType, bool isLegacyAdv);
    void    setPayload(const uint8_t *payload, uint8_t length, bool append);
    void    setRSSI(int rssi);
#if CONFIG_BT_NIMBLE_EXT_ADV
    void    setSetId(uint8_t sid)              { m_sid = sid; }
    void    setPrimaryPhy(uint8_t phy)         { m_primPhy = phy; }
    void    setSecondaryPhy(uint8_t phy)       { m_secPhy = phy; }
    void    setPeriodicInterval(uint16_t itvl) { m_periodicItvl = itvl; }
#endif
    uint8_t findAdvField(uint8_t type, uint8_t index = 0, size_t * data_loc = nullptr);
    size_t  findServiceData(uint8_t index, uint8_t* bytes);
 
    NimBLEAddress   m_address = NimBLEAddress("");
    uint8_t         m_advType;
    int             m_rssi;
    time_t          m_timestamp;
    bool            m_callbackSent;
    uint8_t         m_advLength;
#if CONFIG_BT_NIMBLE_EXT_ADV
    bool            m_isLegacyAdv;
    uint8_t         m_sid;
    uint8_t         m_primPhy;
    uint8_t         m_secPhy;
    uint16_t        m_periodicItvl;
#endif
 
    std::vector<uint8_t>    m_payload;
};
 
class NimBLEAdvertisedDeviceCallbacks {
public:
    virtual ~NimBLEAdvertisedDeviceCallbacks() {}
    virtual void onResult(NimBLEAdvertisedDevice* advertisedDevice) = 0;
};
 
#endif /* CONFIG_BT_ENABLED && CONFIG_BT_NIMBLE_ROLE_OBSERVER */
#endif /* COMPONENTS_NIMBLEADVERTISEDDEVICE_H_ */