NimBLEServer.h

/*
 * NimBLEServer.h
 *
 *  Created: on March 2, 2020
 *      Author H2zero
 *
 * Originally:
 *
 * BLEServer.h
 *
 *  Created on: Apr 16, 2017
 *      Author: kolban
 */
 
#ifndef MAIN_NIMBLESERVER_H_
#define MAIN_NIMBLESERVER_H_
 
#include "nimconfig.h"
#if defined(CONFIG_BT_ENABLED) && defined(CONFIG_BT_NIMBLE_ROLE_PERIPHERAL)
 
#define NIMBLE_ATT_REMOVE_HIDE 1
#define NIMBLE_ATT_REMOVE_DELETE 2
 
#define onMtuChanged onMTUChange
 
#include "NimBLEUtils.h"
#include "NimBLEAddress.h"
#if CONFIG_BT_NIMBLE_EXT_ADV
#include "NimBLEExtAdvertising.h"
#else
#include "NimBLEAdvertising.h"
#endif
#include "NimBLEService.h"
#include "NimBLESecurity.h"
#include "NimBLEConnInfo.h"
 
 
class NimBLEService;
class NimBLECharacteristic;
class NimBLEServerCallbacks;
 
 
class NimBLEServer {
public:
    size_t                 getConnectedCount();
    NimBLEService*         createService(const char* uuid);
    NimBLEService*         createService(const NimBLEUUID &uuid);
    void                   removeService(NimBLEService* service, bool deleteSvc = false);
    void                   addService(NimBLEService* service);
    void                   setCallbacks(NimBLEServerCallbacks* pCallbacks,
                                        bool deleteCallbacks = true);
#if CONFIG_BT_NIMBLE_EXT_ADV
    NimBLEExtAdvertising*  getAdvertising();
    bool                   startAdvertising(uint8_t inst_id,
                                            int duration = 0,
                                            int max_events = 0);
    bool                   stopAdvertising(uint8_t inst_id);
#endif
#  if !CONFIG_BT_NIMBLE_EXT_ADV || defined(_DOXYGEN_)
    NimBLEAdvertising*     getAdvertising();
    bool                   startAdvertising();
#endif
    bool                   stopAdvertising();
    void                   start();
    NimBLEService*         getServiceByUUID(const char* uuid, uint16_t instanceId = 0);
    NimBLEService*         getServiceByUUID(const NimBLEUUID &uuid, uint16_t instanceId = 0);
    NimBLEService*         getServiceByHandle(uint16_t handle);
    int                    disconnect(uint16_t connID,
                                      uint8_t reason = BLE_ERR_REM_USER_CONN_TERM);
    void                   updateConnParams(uint16_t conn_handle,
                                            uint16_t minInterval, uint16_t maxInterval,
                                            uint16_t latency, uint16_t timeout);
    void                   setDataLen(uint16_t conn_handle, uint16_t tx_octets);
    uint16_t               getPeerMTU(uint16_t conn_id);
    std::vector<uint16_t>  getPeerDevices();
    NimBLEConnInfo         getPeerInfo(size_t index);
    NimBLEConnInfo         getPeerInfo(const NimBLEAddress& address);
    NimBLEConnInfo         getPeerIDInfo(uint16_t id);
#if !CONFIG_BT_NIMBLE_EXT_ADV || defined(_DOXYGEN_)
    void                   advertiseOnDisconnect(bool);
#endif
 
private:
    NimBLEServer();
    ~NimBLEServer();
    friend class           NimBLECharacteristic;
    friend class           NimBLEService;
    friend class           NimBLEDevice;
    friend class           NimBLEAdvertising;
#if CONFIG_BT_NIMBLE_EXT_ADV
    friend class           NimBLEExtAdvertising;
    friend class           NimBLEExtAdvertisementData;
#endif
 
    bool                   m_gattsStarted;
#if !CONFIG_BT_NIMBLE_EXT_ADV
    bool                   m_advertiseOnDisconnect;
#endif
    bool                   m_svcChanged;
    NimBLEServerCallbacks* m_pServerCallbacks;
    bool                   m_deleteCallbacks;
    uint16_t               m_indWait[CONFIG_BT_NIMBLE_MAX_CONNECTIONS];
    std::vector<uint16_t>  m_connectedPeersVec;
 
//    uint16_t               m_svcChgChrHdl; // Future use
 
    std::vector<NimBLEService*> m_svcVec;
    std::vector<NimBLECharacteristic*> m_notifyChrVec;
 
    static int             handleGapEvent(struct ble_gap_event *event, void *arg);
    void                   serviceChanged();
    void                   resetGATT();
    bool                   setIndicateWait(uint16_t conn_handle);
    void                   clearIndicateWait(uint16_t conn_handle);
}; // NimBLEServer
 
 
class NimBLEServerCallbacks {
public:
    virtual ~NimBLEServerCallbacks() {};
 
    virtual void onConnect(NimBLEServer* pServer);
 
    virtual void onConnect(NimBLEServer* pServer, ble_gap_conn_desc* desc);
 
    virtual void onDisconnect(NimBLEServer* pServer);
 
    virtual void onDisconnect(NimBLEServer* pServer, ble_gap_conn_desc* desc);
 
    virtual void onMTUChange(uint16_t MTU, ble_gap_conn_desc* desc);
 
    virtual uint32_t onPassKeyRequest();
 
    //virtual void onPassKeyNotify(uint32_t pass_key);
    //virtual bool onSecurityRequest();
 
    virtual void onAuthenticationComplete(ble_gap_conn_desc* desc);
 
    virtual bool onConfirmPIN(uint32_t pin);
}; // NimBLEServerCallbacks
 
#endif /* CONFIG_BT_ENABLED && CONFIG_BT_NIMBLE_ROLE_PERIPHERAL */
#endif /* MAIN_NIMBLESERVER_H_ */