Mqtt5ClientCore.h

Go to the documentation of this file.

 
#pragma once
#include <aws/crt/http/HttpConnection.h>
#include <aws/crt/mqtt/Mqtt5Client.h>
#include <aws/crt/mqtt/Mqtt5Types.h>
 
#include <mutex>
 
namespace Aws
{
    namespace Crt
    {
        namespace Mqtt5
        {
            class AWS_CRT_CPP_API Mqtt5ClientCore final : public std::enable_shared_from_this<Mqtt5ClientCore>
            {
                friend class Mqtt5Client;
                friend class Mqtt::MqttConnection;
 
              public:
                static std::shared_ptr<Mqtt5ClientCore> NewMqtt5ClientCore(
                    const Mqtt5ClientOptions &options,
                    Allocator *allocator = ApiAllocator()) noexcept;
 
                std::shared_ptr<Mqtt5ClientCore> getptr() { return shared_from_this(); }
 
                operator bool() const noexcept;
 
                int LastError() const noexcept;
 
                bool Publish(
                    std::shared_ptr<PublishPacket> publishOptions,
                    OnPublishCompletionHandler onPublishCompletionCallback = NULL) noexcept;
 
                bool Subscribe(
                    std::shared_ptr<SubscribePacket> subscribeOptions,
                    OnSubscribeCompletionHandler onSubscribeCompletionCallback = NULL) noexcept;
 
                bool Unsubscribe(
                    std::shared_ptr<UnsubscribePacket> unsubscribeOptions,
                    OnUnsubscribeCompletionHandler onUnsubscribeCompletionCallback = NULL) noexcept;
 
                void Close() noexcept;
 
                virtual ~Mqtt5ClientCore();
 
                struct aws_mqtt5_client *GetUnderlyingHandle() const noexcept { return m_client; }
 
              private:
                Mqtt5ClientCore(const Mqtt5ClientOptions &options, Allocator *allocator = ApiAllocator()) noexcept;
 
                std::shared_ptr<Crt::Mqtt::MqttConnection> NewConnection(
                    const Mqtt5::Mqtt5to3AdapterOptions *options) noexcept;
 
                /* Static Callbacks */
                static void s_publishCompletionCallback(
                    enum aws_mqtt5_packet_type packet_type,
                    const void *packet,
                    int error_code,
                    void *complete_ctx);
 
                static void s_subscribeCompletionCallback(
                    const struct aws_mqtt5_packet_suback_view *puback,
                    int error_code,
                    void *complete_ctx);
 
                static void s_unsubscribeCompletionCallback(
                    const struct aws_mqtt5_packet_unsuback_view *puback,
                    int error_code,
                    void *complete_ctx);
 
                static void s_lifeCycleEventCallback(const aws_mqtt5_client_lifecycle_event *event);
 
                static void s_publishReceivedCallback(const aws_mqtt5_packet_publish_view *publish, void *user_data);
 
                static void s_onWebsocketHandshake(
                    aws_http_message *rawRequest,
                    void *user_data,
                    aws_mqtt5_transform_websocket_handshake_complete_fn *complete_fn,
                    void *complete_ctx);
 
                static void s_clientTerminationCompletion(void *complete_ctx);
 
                /* The handler is set by clientoptions */
                OnWebSocketHandshakeIntercept websocketInterceptor;
                OnConnectionSuccessHandler onConnectionSuccess;
 
                OnConnectionFailureHandler onConnectionFailure;
 
                OnDisconnectionHandler onDisconnection;
 
                OnStoppedHandler onStopped;
 
                OnAttemptingConnectHandler onAttemptingConnect;
 
                OnPublishReceivedHandler onPublishReceived;
 
                std::shared_ptr<Mqtt5ClientCore> m_selfReference;
 
                /*
                 * The Mqtt5to3 Adapter Options. Used to create a mqtt311 connection from mqtt5 client
                 */
                ScopedResource<Mqtt5to3AdapterOptions> m_mqtt5to3AdapterOptions;
 
                /*
                 * The callback flag used to indicate if it is safe to invoke the callbacks
                 */
                enum CallbackFlag
                {
                    INVOKE,
                    IGNORE
                } m_callbackFlag;
 
                /*
                 * Lock for the callbacks. This is used to protect the callback flag and callbacks.
                 */
                std::recursive_mutex m_callback_lock;
 
                aws_mqtt5_client *m_client;
                Allocator *m_allocator;
            };
 
            class Mqtt5to3AdapterOptions
            {
                friend class Mqtt5ClientOptions;
                friend class Mqtt5ClientCore;
                friend class Mqtt::MqttConnection;
 
              public:
                /* Default constructor */
                Mqtt5to3AdapterOptions();
                /*
                 * Allocate and create a new Mqtt5to3AdapterOptions. This function is internally used by Mqtt5Client to
                 * support the Mqtt5to3Adapter.
                 *
                 * @return Mqtt5to3AdapterOptions
                 */
                static ScopedResource<Mqtt5to3AdapterOptions> NewMqtt5to3AdapterOptions(
                    const Mqtt5ClientOptions &options) noexcept;
 
              private:
                Mqtt::MqttConnectionOptions m_mqtt3Options;
 
                /* Reserve to store memory for m_mqtt3options.hostname */
                String m_hostname;
 
                /*
                 * The transform function invoked during websocket handshake.
                 */
                Crt::Mqtt::OnWebSocketHandshakeIntercept m_webSocketInterceptor;
 
                /* Store the user intercept handshake function */
                OnWebSocketHandshakeIntercept m_websocketHandshakeTransform;
 
                Crt::Optional<Crt::Http::HttpClientConnectionProxyOptions> m_proxyOptions;
            };
 
        } // namespace Mqtt5
    } // namespace Crt
} // namespace Aws