Mqtt5Client.h

Go to the documentation of this file.

#pragma once
 
#include <aws/crt/http/HttpConnection.h>
#include <aws/crt/mqtt/Mqtt5Types.h>
#include <aws/crt/mqtt/MqttClient.h>
 
namespace Aws
{
    namespace Crt
    {
        namespace Mqtt5
        {
            class ConnectPacket;
            class ConnAckPacket;
            class DisconnectPacket;
            class Mqtt5Client;
            class Mqtt5ClientOptions;
            class NegotiatedSettings;
            class PublishResult;
            class PublishPacket;
            class PubAckPacket;
            class SubscribePacket;
            class SubAckPacket;
            class UnsubscribePacket;
            class UnSubAckPacket;
            class Mqtt5ClientCore;
 
            class Mqtt5to3AdapterOptions;
 
            enum class OutboundTopicAliasBehaviorType
            {
 
                Default = AWS_MQTT5_COTABT_DEFAULT,
 
                Manual = AWS_MQTT5_COTABT_MANUAL,
 
                LRU = AWS_MQTT5_COTABT_LRU,
 
                Disabled = AWS_MQTT5_COTABT_DISABLED,
            };
 
            enum class InboundTopicAliasBehaviorType
            {
 
                Default = AWS_MQTT5_CITABT_DEFAULT,
 
                Enabled = AWS_MQTT5_CITABT_ENABLED,
 
                Disabled = AWS_MQTT5_CITABT_DISABLED,
            };
 
            struct AWS_CRT_CPP_API TopicAliasingOptions
            {
 
                Crt::Optional<OutboundTopicAliasBehaviorType> m_outboundBehavior;
 
                Crt::Optional<uint16_t> m_outboundCacheMaxSize;
 
                Crt::Optional<InboundTopicAliasBehaviorType> m_inboundBehavior;
 
                Crt::Optional<uint16_t> m_inboundCacheMaxSize;
            };
 
            struct AWS_CRT_CPP_API ReconnectOptions
            {
                ExponentialBackoffJitterMode m_reconnectMode;
 
                uint64_t m_minReconnectDelayMs;
 
                uint64_t m_maxReconnectDelayMs;
 
                uint64_t m_minConnectedTimeToResetReconnectDelayMs;
            };
 
            struct AWS_CRT_CPP_API Mqtt5ClientOperationStatistics
            {
                uint64_t incompleteOperationCount;
 
                uint64_t incompleteOperationSize;
 
                uint64_t unackedOperationCount;
 
                uint64_t unackedOperationSize;
            };
 
            struct AWS_CRT_CPP_API OnAttemptingConnectEventData
            {
                OnAttemptingConnectEventData() {}
            };
 
            struct AWS_CRT_CPP_API OnConnectionFailureEventData
            {
                OnConnectionFailureEventData() : errorCode(AWS_ERROR_SUCCESS), connAckPacket(nullptr) {}
 
                int errorCode;
                std::shared_ptr<ConnAckPacket> connAckPacket;
            };
 
            struct AWS_CRT_CPP_API OnConnectionSuccessEventData
            {
                OnConnectionSuccessEventData() : connAckPacket(nullptr), negotiatedSettings(nullptr) {}
 
                std::shared_ptr<ConnAckPacket> connAckPacket;
                std::shared_ptr<NegotiatedSettings> negotiatedSettings;
            };
 
            struct AWS_CRT_CPP_API OnDisconnectionEventData
            {
                OnDisconnectionEventData() : errorCode(AWS_ERROR_SUCCESS), disconnectPacket(nullptr) {}
 
                int errorCode;
                std::shared_ptr<DisconnectPacket> disconnectPacket;
            };
 
            struct AWS_CRT_CPP_API OnStoppedEventData
            {
                OnStoppedEventData() {}
            };
 
            struct AWS_CRT_CPP_API PublishReceivedEventData
            {
                PublishReceivedEventData() : publishPacket(nullptr) {}
                std::shared_ptr<PublishPacket> publishPacket;
            };
 
            using OnConnectionSuccessHandler = std::function<void(const OnConnectionSuccessEventData &)>;
 
            using OnConnectionFailureHandler = std::function<void(const OnConnectionFailureEventData &)>;
 
            using OnDisconnectionHandler = std::function<void(const OnDisconnectionEventData &)>;
 
            using OnAttemptingConnectHandler = std::function<void(const OnAttemptingConnectEventData &)>;
 
            using OnStoppedHandler = std::function<void(const OnStoppedEventData &)>;
 
            using OnPublishCompletionHandler = std::function<void(int, std::shared_ptr<PublishResult>)>;
 
            using OnSubscribeCompletionHandler = std::function<void(int, std::shared_ptr<SubAckPacket>)>;
 
            using OnUnsubscribeCompletionHandler = std::function<void(int, std::shared_ptr<UnSubAckPacket>)>;
 
            using OnPublishReceivedHandler = std::function<void(const PublishReceivedEventData &)>;
 
            using OnWebSocketHandshakeInterceptComplete =
                std::function<void(const std::shared_ptr<Http::HttpRequest> &, int)>;
 
            using OnWebSocketHandshakeIntercept =
                std::function<void(std::shared_ptr<Http::HttpRequest>, const OnWebSocketHandshakeInterceptComplete &)>;
 
            class AWS_CRT_CPP_API Mqtt5Client final : public std::enable_shared_from_this<Mqtt5Client>
            {
                friend class Mqtt::MqttConnection;
 
              public:
                static std::shared_ptr<Mqtt5Client> NewMqtt5Client(
                    const Mqtt5ClientOptions &options,
                    Allocator *allocator = ApiAllocator()) noexcept;
 
                std::shared_ptr<Mqtt5Client> getptr() { return shared_from_this(); }
 
                operator bool() const noexcept;
 
                int LastError() const noexcept;
 
                bool Start() const noexcept;
 
                bool Stop() noexcept;
 
                bool Stop(std::shared_ptr<DisconnectPacket> disconnectPacket) noexcept;
 
                bool Publish(
                    std::shared_ptr<PublishPacket> publishPacket,
                    OnPublishCompletionHandler onPublishCompletionCallback = NULL) noexcept;
 
                bool Subscribe(
                    std::shared_ptr<SubscribePacket> subscribePacket,
                    OnSubscribeCompletionHandler onSubscribeCompletionCallback = NULL) noexcept;
 
                bool Unsubscribe(
                    std::shared_ptr<UnsubscribePacket> unsubscribePacket,
                    OnUnsubscribeCompletionHandler onUnsubscribeCompletionCallback = NULL) noexcept;
 
                const Mqtt5ClientOperationStatistics &GetOperationStatistics() noexcept;
 
                virtual ~Mqtt5Client();
 
              private:
                Mqtt5Client(const Mqtt5ClientOptions &options, Allocator *allocator = ApiAllocator()) noexcept;
 
                /* The client core to handle the user callbacks and c client termination */
                std::shared_ptr<Mqtt5ClientCore> m_client_core;
 
                Mqtt5ClientOperationStatistics m_operationStatistics;
            };
 
            class AWS_CRT_CPP_API Mqtt5ClientOptions final
            {
                friend class Mqtt5ClientCore;
                friend class Mqtt5to3AdapterOptions;
 
              public:
                Mqtt5ClientOptions(Crt::Allocator *allocator = ApiAllocator()) noexcept;
 
                Mqtt5ClientOptions &WithHostName(Crt::String hostname);
 
                Mqtt5ClientOptions &WithPort(uint32_t port) noexcept;
 
                Mqtt5ClientOptions &WithBootstrap(Io::ClientBootstrap *bootStrap) noexcept;
 
                Mqtt5ClientOptions &WithSocketOptions(Io::SocketOptions socketOptions) noexcept;
 
                Mqtt5ClientOptions &WithTlsConnectionOptions(const Io::TlsConnectionOptions &tslOptions) noexcept;
 
                Mqtt5ClientOptions &WithHttpProxyOptions(
                    const Crt::Http::HttpClientConnectionProxyOptions &proxyOptions) noexcept;
 
                Mqtt5ClientOptions &WithConnectOptions(std::shared_ptr<ConnectPacket> connectPacket) noexcept;
 
                Mqtt5ClientOptions &WithSessionBehavior(ClientSessionBehaviorType sessionBehavior) noexcept;
 
                Mqtt5ClientOptions &WithClientExtendedValidationAndFlowControl(
                    ClientExtendedValidationAndFlowControl clientExtendedValidationAndFlowControl) noexcept;
 
                Mqtt5ClientOptions &WithOfflineQueueBehavior(
                    ClientOperationQueueBehaviorType offlineQueueBehavior) noexcept;
 
                Mqtt5ClientOptions &WithReconnectOptions(ReconnectOptions reconnectOptions) noexcept;
 
                Mqtt5ClientOptions &WithTopicAliasingOptions(TopicAliasingOptions topicAliasingOptions) noexcept;
 
                Mqtt5ClientOptions &WithPingTimeoutMs(uint32_t pingTimeoutMs) noexcept;
 
                Mqtt5ClientOptions &WithConnackTimeoutMs(uint32_t connackTimeoutMs) noexcept;
 
                Mqtt5ClientOptions &WithAckTimeoutSeconds(uint32_t ackTimeoutSec) noexcept;
 
                Mqtt5ClientOptions &WithAckTimeoutSec(uint32_t ackTimeoutSec) noexcept;
 
                Mqtt5ClientOptions &WithWebsocketHandshakeTransformCallback(
                    OnWebSocketHandshakeIntercept callback) noexcept;
 
                Mqtt5ClientOptions &WithClientConnectionSuccessCallback(OnConnectionSuccessHandler callback) noexcept;
 
                Mqtt5ClientOptions &WithClientConnectionFailureCallback(OnConnectionFailureHandler callback) noexcept;
 
                Mqtt5ClientOptions &WithClientDisconnectionCallback(OnDisconnectionHandler callback) noexcept;
 
                Mqtt5ClientOptions &WithClientStoppedCallback(OnStoppedHandler callback) noexcept;
 
                Mqtt5ClientOptions &WithClientAttemptingConnectCallback(OnAttemptingConnectHandler callback) noexcept;
 
                Mqtt5ClientOptions &WithPublishReceivedCallback(OnPublishReceivedHandler callback) noexcept;
 
                bool initializeRawOptions(aws_mqtt5_client_options &raw_options) const noexcept;
 
                virtual ~Mqtt5ClientOptions();
                Mqtt5ClientOptions(const Mqtt5ClientOptions &) = delete;
                Mqtt5ClientOptions(Mqtt5ClientOptions &&) = delete;
                Mqtt5ClientOptions &operator=(const Mqtt5ClientOptions &) = delete;
                Mqtt5ClientOptions &operator=(Mqtt5ClientOptions &&) = delete;
 
              private:
                OnWebSocketHandshakeIntercept websocketHandshakeTransform;
 
                OnConnectionSuccessHandler onConnectionSuccess;
 
                OnConnectionFailureHandler onConnectionFailure;
 
                OnDisconnectionHandler onDisconnection;
 
                OnStoppedHandler onStopped;
 
                OnAttemptingConnectHandler onAttemptingConnect;
 
                OnPublishReceivedHandler onPublishReceived;
 
                Crt::String m_hostName;
 
                uint32_t m_port;
 
                Io::ClientBootstrap *m_bootstrap;
 
                Crt::Io::SocketOptions m_socketOptions;
 
                Crt::Optional<Crt::Io::TlsConnectionOptions> m_tlsConnectionOptions;
 
                Crt::Optional<Crt::Http::HttpClientConnectionProxyOptions> m_proxyOptions;
 
                std::shared_ptr<ConnectPacket> m_connectOptions;
 
                ClientSessionBehaviorType m_sessionBehavior;
 
                ClientExtendedValidationAndFlowControl m_extendedValidationAndFlowControlOptions;
 
                ClientOperationQueueBehaviorType m_offlineQueueBehavior;
 
                ReconnectOptions m_reconnectionOptions;
 
                aws_mqtt5_client_topic_alias_options m_topicAliasingOptions;
 
                uint32_t m_pingTimeoutMs;
 
                uint32_t m_connackTimeoutMs;
 
                uint32_t m_ackTimeoutSec;
 
                /* Underlying Parameters */
                Crt::Allocator *m_allocator;
                aws_http_proxy_options m_httpProxyOptionsStorage;
                aws_mqtt5_packet_connect_view m_packetConnectViewStorage;
            };
 
        } // namespace Mqtt5
    }     // namespace Crt
} // namespace Aws