Api.h

Go to the documentation of this file.

#pragma once
#include <aws/crt/Types.h>
#include <aws/crt/crypto/HMAC.h>
#include <aws/crt/crypto/Hash.h>
#include <aws/crt/mqtt/Mqtt5Client.h>
#include <aws/crt/mqtt/MqttClient.h>
 
#include <aws/common/logging.h>
 
namespace Aws
{
    namespace Crt
    {
        enum class LogLevel
        {
            None = AWS_LL_NONE,
            Fatal = AWS_LL_FATAL,
            Error = AWS_LL_ERROR,
            Warn = AWS_LL_WARN,
            Info = AWS_LL_INFO,
            Debug = AWS_LL_DEBUG,
            Trace = AWS_LL_TRACE,
 
            Count
        };

        enum class ApiHandleShutdownBehavior
        {
            Blocking,
            NonBlocking
        };

        class AWS_CRT_CPP_API ApiHandle
        {
          public:
            ApiHandle(Allocator *allocator) noexcept;
            ApiHandle() noexcept;
            ~ApiHandle();
            ApiHandle(const ApiHandle &) = delete;
            ApiHandle(ApiHandle &&) = delete;
            ApiHandle &operator=(const ApiHandle &) = delete;
            ApiHandle &operator=(ApiHandle &&) = delete;

            void InitializeLogging(LogLevel level, const char *filename);

            void InitializeLogging(LogLevel level, FILE *fp);

            void SetShutdownBehavior(ApiHandleShutdownBehavior behavior);

            void SetBYOCryptoNewMD5Callback(Crypto::CreateHashCallback &&callback);

            void SetBYOCryptoNewSHA256Callback(Crypto::CreateHashCallback &&callback);

            void SetBYOCryptoNewSHA512Callback(Crypto::CreateHashCallback &&callback);

            void SetBYOCryptoNewSHA1Callback(Crypto::CreateHashCallback &&callback);

            void SetBYOCryptoNewSHA256HMACCallback(Crypto::CreateHMACCallback &&callback);

            void SetBYOCryptoNewSHA512HMACCallback(Crypto::CreateHMACCallback &&callback);

            void SetBYOCryptoClientTlsCallback(Io::NewClientTlsHandlerCallback &&callback);

            void SetBYOCryptoTlsContextCallbacks(
                Io::NewTlsContextImplCallback &&newCallback,
                Io::DeleteTlsContextImplCallback &&deleteCallback,
                Io::IsTlsAlpnSupportedCallback &&alpnCallback);

            static const Io::NewTlsContextImplCallback &GetBYOCryptoNewTlsContextImplCallback();
            static const Io::DeleteTlsContextImplCallback &GetBYOCryptoDeleteTlsContextImplCallback();
            static const Io::IsTlsAlpnSupportedCallback &GetBYOCryptoIsTlsAlpnSupportedCallback();

            static Io::ClientBootstrap *GetOrCreateStaticDefaultClientBootstrap();

            static Io::EventLoopGroup *GetOrCreateStaticDefaultEventLoopGroup();

            static Io::HostResolver *GetOrCreateStaticDefaultHostResolver();
 
#pragma pack(push, 1)
            struct Version
            {
                uint16_t major;
                uint16_t minor;
                uint16_t patch;
            };
#pragma pack(pop)
            Version GetCrtVersion() const;
 
          private:
            void InitializeLoggingCommon(struct aws_logger_standard_options &options);
 
            aws_logger m_logger;
 
            ApiHandleShutdownBehavior m_shutdownBehavior;
 
            static Io::ClientBootstrap *s_static_bootstrap;
            static std::mutex s_lock_client_bootstrap;
            static void ReleaseStaticDefaultClientBootstrap();
 
            static Io::EventLoopGroup *s_static_event_loop_group;
            static std::mutex s_lock_event_loop_group;
            static void ReleaseStaticDefaultEventLoopGroup();
 
            static int s_host_resolver_default_max_hosts;
            static Io::HostResolver *s_static_default_host_resolver;
            static std::mutex s_lock_default_host_resolver;
            static void ReleaseStaticDefaultHostResolver();
 
            Version m_version = {0, 0, 0};
        };

        AWS_CRT_CPP_API const char *ErrorDebugString(int error) noexcept;

        AWS_CRT_CPP_API int LastError() noexcept;

        AWS_CRT_CPP_API int LastErrorOrUnknown() noexcept;
    } // namespace Crt
} // namespace Aws