attribute_server.hpp

Go to the documentation of this file.

#ifndef ELEC_C7222_BLE_GATT_ATTRIBUTE_SERVER_HPP_
#define ELEC_C7222_BLE_GATT_ATTRIBUTE_SERVER_HPP_
 
#include <cstdint>
#include <list>
 
#include "ble_error.hpp"
#include "non_copyable.hpp"
#include "service.hpp"
#include "uuid.hpp"
 
namespace c7222 {
 
class AttributeServer : public NonCopyableNonMovable {
   public:
    struct ReadResult {
        uint16_t bytes = 0;
        BleError error = BleError::kSuccess;
        bool ok = true;
    };
 
 
    static AttributeServer* GetInstance() {
        if(instance_ == nullptr) {
            instance_ = new AttributeServer();
            assert(instance_ != nullptr &&
                   "Failed to allocate AttributeServer singleton instance");
        }
        return instance_;
    }
 
 
    BleError Init(const void* context);
 
    [[nodiscard]] bool IsInitialized() const {
        return initialized_;
    }
 
    [[nodiscard]] const void* GetContext() const {
        return context_;
    }
 
    [[nodiscard]] bool HasContext() const {
        return context_ != nullptr;
    }
 
 
    [[nodiscard]] size_t GetServiceCount() const {
        return services_.size();
    }
 
 
    Service& GetService(size_t index);
 
    [[nodiscard]] const std::list<Service>& GetServices() const {
        return services_;
    }
 
    std::list<Service>& GetServices() {
        return services_;
    }
    
    [[nodiscard]] const Service& GetService(size_t index) const;
 
    Service* FindServiceByUuid(const Uuid& uuid);
 
    [[nodiscard]] const Service* FindServiceByUuid(const Uuid& uuid) const;
 
    [[nodiscard]] bool HasServicesRequiringAuthentication() const;
 
    [[nodiscard]] bool HasServicesRequiringEncryption() const;
 
    [[nodiscard]] bool HasServicesRequiringAuthorization() const;
 
    std::list<Characteristic*> FindCharacteristicByUuid(const Uuid& uuid);
 
    [[nodiscard]] std::list<const Characteristic*> FindCharacteristicByUuid(const Uuid& uuid) const;
 
    Characteristic* FindCharacteristicByHandle(uint16_t handle);
 
    [[nodiscard]] const Characteristic* FindCharacteristicByHandle(uint16_t handle) const;
 
 
    auto begin() {
        return services_.begin();
    }
 
    auto end() {
        return services_.end();
    }
 
    [[nodiscard]] auto begin() const {
        return services_.begin();
    }
 
    [[nodiscard]] auto end() const {
        return services_.end();
    }
 
    [[nodiscard]] auto cbegin() const {
        return services_.cbegin();
    }
 
    [[nodiscard]] auto cend() const {
        return services_.cend();
    }
 
 
    void SetConnectionHandle(uint16_t connection_handle);
 
    void SetSecurityLevel(uint16_t connection_handle, uint8_t security_level);
 
    [[nodiscard]] uint8_t GetSecurityLevel(uint16_t connection_handle) const;
 
    void SetAuthorizationGranted(uint16_t connection_handle, bool granted);
 
    [[nodiscard]] bool IsAuthorizationGranted(uint16_t connection_handle) const;
 
    [[nodiscard]] uint16_t GetConnectionHandle() const {
        return connection_handle_;
    }
 
    void SetDisconnected();
    [[nodiscard]] bool HasConnectionHandle() const {
        return connection_handle_ != 0;
    }
 
    [[nodiscard]] bool IsConnected() const {
        return connection_handle_ != 0;
    }
 
    BleError DispatchBleHciPacket(uint8_t packet_type,
                                  const uint8_t* packet_data,
                                  uint16_t packet_data_size);
 
 
    ReadResult ReadAttribute(uint16_t attribute_handle,
                             uint16_t offset,
                             uint8_t* buffer,
                             uint16_t buffer_size);
 
    BleError
    WriteAttribute(uint16_t attribute_handle, uint16_t offset, const uint8_t* data, uint16_t size);
 
 
    friend std::ostream& operator<<(std::ostream& os, const AttributeServer& server);
 
 
    void InitServices(std::list<Attribute>& attributes);
 
   private:
    AttributeServer() = default;
    ~AttributeServer() = default;
 
 
    Attribute* FindServiceAttributeByHandle(uint16_t handle);
    [[nodiscard]] const Attribute* FindServiceAttributeByHandle(uint16_t handle) const;
    Attribute* FindAttributeByHandle(uint16_t handle);
    [[nodiscard]] const Attribute* FindAttributeByHandle(uint16_t handle) const;
 
    static bool IsAttErrorCode(uint16_t value, BleError& out_error);
 
    std::list<Service> services_;
    const void* context_ = nullptr;
    uint16_t connection_handle_ = 0;
    uint8_t security_level_ = 0;
    bool authorization_granted_ = false;
    bool initialized_ = false;
 
    static AttributeServer* instance_;
};
 
}  // namespace c7222
 
#endif  // ELEC_C7222_BLE_GATT_ATTRIBUTE_SERVER_HPP_