BLEGattClient.hxx

Go to the documentation of this file.

 
#ifndef _OPENLCB_BLEGATTCLIENT_HXX_
#define _OPENLCB_BLEGATTCLIENT_HXX_
 
#include <memory>
 
#include "ble/Connection.hxx"
#include "utils/Singleton.hxx"
#include "openlcb/BLEDefs.hxx"
 
namespace openlcb
{
 
class BLEGattClient
{
public:
    ~BLEGattClient()
    {
    }
 
    ble::Defs::AttHandle get_out_bound()
    {
        return outBound_;
    }
 
    ble::Defs::AttHandle get_in_bound()
    {
        return inBound_;
    }
 
    ble::Connection *connection()
    {
        return conn_;
    }
 
    void set_protocol_engine(BLEProtocolEnginePtr protocol)
    {
        protocol_ = std::move(protocol);
    }
 
    BLEProtocolEngine* protocol_engine() {
        return protocol_.get();
    }
    
private:
    BLEGattClient(ble::Connection *conn, ble::Defs::AttHandle out_bound,
        ble::Defs::AttHandle in_bound)
        : conn_(conn)
        , outBound_(out_bound)
        , inBound_(in_bound)
    { }
 
    ble::Connection *conn_;         
    ble::Defs::AttHandle outBound_; 
    ble::Defs::AttHandle inBound_;  
    BLEProtocolEnginePtr protocol_;
 
    friend class BLEGattClients;
};
 
class BLEGattClients : public Singleton<BLEGattClients>
{
public:
    BLEGattClients()
    {
        ble::Connections::instance()->register_disconnect_callback(std::bind(
            &BLEGattClients::disconnect_callback, this, std::placeholders::_1));
    }
 
    BLEGattClient *register_client(ble::Connection *conn,
        ble::Defs::AttHandle out_bound, ble::Defs::AttHandle in_bound)
    {
        auto *c =
            new BLEGattClient(conn, out_bound, in_bound);
        clients_.emplace_back(c);
        return c;
    }
 
    BLEGattClient *find_client_by_out(
        ble::Connection *conn, ble::Defs::AttHandle out_handle)
    {
        for (auto it = clients_.begin(); it != clients_.end(); ++it)
        {
            if (it->get()->connection() == conn &&
                it->get()->get_out_bound() == out_handle)
            {
                return it->get();
            }
        }
        return nullptr;
    }
 
    BLEGattClient *find_client_by_in(
        ble::Connection *conn, ble::Defs::AttHandle in_handle)
    {
        for (auto it = clients_.begin(); it != clients_.end(); ++it)
        {
            if (it->get()->connection() == conn &&
                it->get()->get_in_bound() == in_handle)
            {
                return it->get();
            }
        }
        return nullptr;
    }
    
    void for_each_call(std::function<void(BLEGattClient *)> callback)
    {
        for (auto it = clients_.begin(); it != clients_.end(); ++it)
        {
            callback(it->get());
        }
    }
 
private:
    void disconnect_callback(ble::Connection *conn)
    {
        for (int i = 0; i < (int)clients_.size(); ++i)
        {
            if (clients_[i]->conn_ == conn)
            {
                clients_.erase(clients_.begin() + i);
                --i;
                continue;
            }
        }
    }
 
    std::vector<std::unique_ptr<BLEGattClient>> clients_;
};
 
} // namespace openlcb
 
#endif // _OPENLCB_BLEGATTCLIENT_HXX_