Initial commit.

src/NimBLEServer.h

@@ -0,0 +1,154 @@
+/*
+ * 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 "sdkconfig.h"
+#if defined(CONFIG_BT_ENABLED)
+
+#include "NimBLEAddress.h"
+#include "NimBLEUUID.h"
+#include "NimBLEAdvertising.h"
+#include "NimBLEService.h"
+#include "NimBLESecurity.h"
+#include "FreeRTOS.h"
+
+
+#include <map>
+
+class NimBLEService;
+class NimBLECharacteristic;
+class NimBLEServerCallbacks;
+
+/* TODO possibly refactor this struct */ 
+typedef struct {
+    void *peer_device;      // peer device BLEClient or BLEServer - maybe its better to have 2 structures or union here
+    bool connected;         // do we need it?
+    uint16_t mtu;           // every peer device negotiate own mtu
+} conn_status_t;
+
+
+/**
+ * @brief A data structure that manages the %BLE servers owned by a BLE server.
+ */
+class NimBLEServiceMap {
+public:
+//    NimBLEService* getByHandle(uint16_t handle);
+    NimBLEService* getByUUID(const char* uuid);    
+    NimBLEService* getByUUID(NimBLEUUID uuid, uint8_t inst_id = 0);
+//    void           setByHandle(uint16_t handle, NimBLEService* service);
+    void           setByUUID(const char* uuid, NimBLEService* service);
+    void           setByUUID(NimBLEUUID uuid, NimBLEService* service);
+    std::string    toString();
+    NimBLEService* getFirst();
+    NimBLEService* getNext();
+    void           removeService(NimBLEService *service);
+    int            getRegisteredServiceCount();
+
+private:
+//    std::map<uint16_t, NimBLEService*>    m_handleMap;
+    std::map<NimBLEService*, std::string> m_uuidMap;
+    std::map<NimBLEService*, std::string>::iterator m_iterator;
+};
+
+
+/**
+ * @brief The model of a %BLE server.
+ */
+class NimBLEServer {
+public:
+    uint32_t              getConnectedCount();
+    NimBLEService*        createService(const char* uuid);    
+    NimBLEService*        createService(NimBLEUUID uuid, uint32_t numHandles=15, uint8_t inst_id=0);
+    NimBLEAdvertising*    getAdvertising();
+    void                  setCallbacks(NimBLEServerCallbacks* pCallbacks);
+    void                  startAdvertising();
+    void                  stopAdvertising();
+    void                  start();
+//    void                  removeService(BLEService* service);
+    NimBLEService*        getServiceByUUID(const char* uuid);
+    NimBLEService*        getServiceByUUID(NimBLEUUID uuid);
+    int                   disconnect(uint16_t connID, uint8_t reason = BLE_ERR_REM_USER_CONN_TERM);
+//    bool                connect(BLEAddress address);
+    void                  updateConnParams(uint16_t conn_handle, 
+                                    uint16_t minInterval, uint16_t maxInterval, 
+                                    uint16_t latency, uint16_t timeout,
+                                    uint16_t minConnTime=0, uint16_t maxConnTime=0);
+
+    /* multi connection support */
+    std::map<uint16_t, conn_status_t> getPeerDevices();
+    void          addPeerDevice(void* peer, bool is_client, uint16_t conn_id);
+    void          removePeerDevice(uint16_t conn_id, bool client);
+    NimBLEServer* getServerByConnId(uint16_t conn_id);
+    void          updatePeerMTU(uint16_t connId, uint16_t mtu);
+    uint16_t      getPeerMTU(uint16_t conn_id);
+    uint16_t      getConnId();
+
+
+private:
+    NimBLEServer();
+    //friend class BLEService;
+    friend class NimBLECharacteristic;
+    friend class NimBLEDevice;
+    friend class NimBLEAdvertising;
+ //   void         onHostReset();
+    // BLEAdvertising      m_bleAdvertising;
+    uint16_t               m_connId;
+    uint16_t               m_svcChgChrHdl;
+	bool				   m_gattsStarted;
+    
+    std::map<uint16_t, conn_status_t> m_connectedServersMap;
+    std::map<uint16_t, NimBLECharacteristic*> m_notifyChrMap;
+
+    NimBLEServiceMap       m_serviceMap;
+    NimBLEServerCallbacks* m_pServerCallbacks;
+
+	static int 		handleGapEvent(struct ble_gap_event *event, void *arg);
+}; // NimBLEServer
+
+
+/**
+ * @brief Callbacks associated with the operation of a %BLE server.
+ */
+class NimBLEServerCallbacks {
+public:
+    virtual ~NimBLEServerCallbacks() {};
+    /**
+     * @brief Handle a new client connection.
+     *
+     * When a new client connects, we are invoked.
+     *
+     * @param [in] pServer A reference to the %BLE server that received the client connection.
+     */
+    virtual void onConnect(NimBLEServer* pServer);
+    virtual void onConnect(NimBLEServer* pServer, ble_gap_conn_desc* desc);
+    /**
+     * @brief Handle an existing client disconnection.
+     *
+     * When an existing client disconnects, we are invoked.
+     *
+     * @param [in] pServer A reference to the %BLE server that received the existing client disconnection.
+     */
+    virtual void onDisconnect(NimBLEServer* pServer);
+    
+    virtual uint32_t onPassKeyRequest(); //{return 0;}
+    virtual void onPassKeyNotify(uint32_t pass_key); //{}
+    virtual bool onSecurityRequest(); //{return true;}
+    virtual void onAuthenticationComplete(ble_gap_conn_desc* desc);//{};
+    virtual bool onConfirmPIN(uint32_t pin);//{return true;}
+}; // BLEServerCallbacks
+
+
+#endif /* CONFIG_BT_ENABLED */
+#endif /* MAIN_NIMBLESERVER_H_ */