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