Mqtt5Client.h

Go to the documentation of this file.

#pragma once
#include <aws/crt/http/HttpConnection.h>
#include <aws/crt/mqtt/IoTSDKMetrics.h>
#include <aws/crt/mqtt/Mqtt5Types.h>
#include <aws/crt/mqtt/MqttClient.h>
 
namespace Aws
{
    namespace Crt
    {
        namespace Io
        {
            class L4ProxyConfig;
        } // namespace Io
 
        namespace Mqtt
        {
            class IoTSDKMetricsEncoder;
        } // namespace Mqtt
 
        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;
 
            struct PublishAcknowledgementHandle;

            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;

                std::function<ScopedResource<PublishAcknowledgementHandle>()> acquirePublishAcknowledgement;
            };

            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;

                bool InvokePublishAcknowledgement(
                    const PublishAcknowledgementHandle &publishAcknowledgementHandle) noexcept;
 
                ~Mqtt5Client();
 
                struct aws_mqtt5_client *GetUnderlyingHandle() const noexcept;
 
              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;
                friend class Mqtt::IoTSDKMetricsEncoder;
 
              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 &WithL4ProxyOptions(
                    const std::shared_ptr<Aws::Crt::Io::L4ProxyConfig> &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;

                Mqtt5ClientOptions &WithMetricsCollection(bool enabled) noexcept;

                Mqtt5ClientOptions &WithSdkMetrics(const Mqtt::AWSIoTMetrics &sdkMetrics) noexcept;

                bool initializeRawOptions(aws_mqtt5_client_options &raw_options) const noexcept;
 
                ~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<Crt::Io::L4ProxyConfig> m_l4ProxyOptions;

                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;
 
                bool m_enableMetrics = true;
                Crt::Optional<Crt::Mqtt::AWSIoTMetrics> m_sdkMetrics;
 
                /* Underlying Parameters */
                Crt::Allocator *m_allocator;
                aws_http_proxy_options m_httpProxyOptionsStorage;
                aws_mqtt5_packet_connect_view m_packetConnectViewStorage;

                mutable Mqtt::AWSIoTMetrics m_finalMetrics;
                mutable struct aws_mqtt_iot_metrics m_metricsStorage;
            };
 
        } // namespace Mqtt5
    } // namespace Crt
} // namespace Aws