MqttConnection.h

Go to the documentation of this file.

#pragma once
 
#include <aws/crt/Exports.h>
#include <aws/crt/StlAllocator.h>
#include <aws/crt/Types.h>
#include <aws/crt/http/HttpConnection.h>
#include <aws/crt/io/SocketOptions.h>
#include <aws/crt/io/TlsOptions.h>
#include <aws/crt/mqtt/MqttTypes.h>
 
#include <aws/mqtt/client.h>
#include <aws/mqtt/v5/mqtt5_client.h>
 
#include <functional>
#include <memory>
 
namespace Aws
{
    namespace Crt
    {
        namespace Http
        {
            class HttpRequest;
        }
 
        namespace Io
        {
            class L4ProxyConfig;
        }
 
        namespace Mqtt5
        {
            class Mqtt5Client;
            class Mqtt5ClientCore;
        } // namespace Mqtt5
 
        namespace Mqtt
        {
            class MqttClient;
            class MqttConnectionCore;
            class MqttConnection;

            struct OnConnectionClosedData
            {
            };

            struct OnConnectionSuccessData
            {
                ReturnCode returnCode;

                bool sessionPresent;
            };

            struct OnConnectionFailureData
            {
                int error;
            };

            using OnConnectionInterruptedHandler = std::function<void(MqttConnection &connection, int error)>;

            using OnConnectionResumedHandler =
                std::function<void(MqttConnection &connection, ReturnCode connectCode, bool sessionPresent)>;

            using OnConnectionCompletedHandler = std::function<
                void(MqttConnection &connection, int errorCode, ReturnCode returnCode, bool sessionPresent)>;

            using OnConnectionClosedHandler =
                std::function<void(MqttConnection &connection, OnConnectionClosedData *callbackData)>;

            using OnConnectionSuccessHandler =
                std::function<void(MqttConnection &connection, OnConnectionSuccessData *callbackData)>;

            using OnConnectionFailureHandler =
                std::function<void(MqttConnection &connection, OnConnectionFailureData *callbackData)>;

            using OnDisconnectHandler = std::function<void(MqttConnection &connection)>;

            using OnPublishReceivedHandler =
                std::function<void(MqttConnection &connection, const String &topic, const ByteBuf &payload)>;

            using OnWebSocketHandshakeInterceptComplete =
                std::function<void(const std::shared_ptr<Http::HttpRequest> &, int errorCode)>;

            using OnWebSocketHandshakeIntercept = std::function<
                void(std::shared_ptr<Http::HttpRequest> req, const OnWebSocketHandshakeInterceptComplete &onComplete)>;

            class AWS_CRT_CPP_API MqttConnection final : public std::enable_shared_from_this<MqttConnection>
            {
                friend class MqttClient;
                friend class Mqtt5::Mqtt5ClientCore;
 
              public:
                ~MqttConnection();
                MqttConnection(const MqttConnection &) = delete;
                MqttConnection(MqttConnection &&) = delete;
                MqttConnection &operator=(const MqttConnection &) = delete;
                MqttConnection &operator=(MqttConnection &&) = delete;

                static std::shared_ptr<Crt::Mqtt::MqttConnection> NewConnectionFromMqtt5Client(
                    std::shared_ptr<Mqtt5::Mqtt5Client> mqtt5client) noexcept;

                operator bool() const noexcept;

                int LastError() const noexcept;

                bool SetWill(const char *topic, QOS qos, bool retain, const ByteBuf &payload) noexcept;

                bool SetLogin(const char *username, const char *password) noexcept;

                bool SetWebsocketProxyOptions(const Http::HttpClientConnectionProxyOptions &proxyOptions) noexcept;

                bool SetHttpProxyOptions(const Http::HttpClientConnectionProxyOptions &proxyOptions) noexcept;

                bool SetL4ProxyOptions(const std::shared_ptr<Aws::Crt::Io::L4ProxyConfig> &l4ProxyOptions) noexcept;

                bool SetReconnectTimeout(uint64_t min_seconds, uint64_t max_seconds) noexcept;

                bool Connect(
                    const char *clientId,
                    bool cleanSession,
                    uint16_t keepAliveTimeSecs = 0,
                    uint32_t pingTimeoutMs = 0,
                    uint32_t protocolOperationTimeoutMs = 0) noexcept;

                bool Disconnect() noexcept;

                aws_mqtt_client_connection *GetUnderlyingConnection() const noexcept;

                uint16_t Subscribe(
                    const char *topicFilter,
                    QOS qos,
                    OnMessageReceivedHandler &&onMessage,
                    OnSubAckHandler &&onSubAck) noexcept;

                uint16_t Subscribe(
                    const char *topicFilter,
                    QOS qos,
                    OnPublishReceivedHandler &&onPublish,
                    OnSubAckHandler &&onSubAck) noexcept;

                uint16_t Subscribe(
                    const Vector<std::pair<const char *, OnMessageReceivedHandler>> &topicFilters,
                    QOS qos,
                    OnMultiSubAckHandler &&onOpComplete) noexcept;

                uint16_t Subscribe(
                    const Vector<std::pair<const char *, OnPublishReceivedHandler>> &topicFilters,
                    QOS qos,
                    OnMultiSubAckHandler &&onOpComplete) noexcept;

                bool SetOnMessageHandler(OnMessageReceivedHandler &&onMessage) noexcept;

                bool SetOnMessageHandler(OnPublishReceivedHandler &&onPublish) noexcept;

                uint16_t Unsubscribe(const char *topicFilter, OnOperationCompleteHandler &&onOpComplete) noexcept;

                uint16_t Publish(
                    const char *topic,
                    QOS qos,
                    bool retain,
                    const ByteBuf &payload,
                    OnOperationCompleteHandler &&onOpComplete) noexcept;

                const MqttConnectionOperationStatistics &GetOperationStatistics() noexcept;

                OnConnectionInterruptedHandler OnConnectionInterrupted;

                OnConnectionResumedHandler OnConnectionResumed;

                OnConnectionCompletedHandler OnConnectionCompleted;

                OnDisconnectHandler OnDisconnect;

                OnWebSocketHandshakeIntercept WebsocketInterceptor;

                OnConnectionClosedHandler OnConnectionClosed;

                OnConnectionSuccessHandler OnConnectionSuccess;

                OnConnectionFailureHandler OnConnectionFailure;
 
              private:
                MqttConnection() = default;

                static std::shared_ptr<MqttConnection> s_CreateMqttConnection(
                    aws_mqtt_client *client,
                    MqttConnectionOptions options) noexcept;

                static std::shared_ptr<MqttConnection> s_CreateMqttConnection(
                    aws_mqtt5_client *mqtt5Client,
                    MqttConnectionOptions options) noexcept;
                std::shared_ptr<MqttConnectionCore> m_connectionCore;
            };
        } // namespace Mqtt
    } // namespace Crt
} // namespace Aws