diff options
Diffstat (limited to 'src/mqtt/qmqttconnectionproperties.cpp')
| -rw-r--r-- | src/mqtt/qmqttconnectionproperties.cpp | 317 |
1 files changed, 317 insertions, 0 deletions
diff --git a/src/mqtt/qmqttconnectionproperties.cpp b/src/mqtt/qmqttconnectionproperties.cpp index 68d0374..68647ec 100644 --- a/src/mqtt/qmqttconnectionproperties.cpp +++ b/src/mqtt/qmqttconnectionproperties.cpp @@ -39,10 +39,115 @@ QT_BEGIN_NAMESPACE Q_DECLARE_LOGGING_CATEGORY(lcMqttConnection) +/*! + \class QMqttConnectionProperties + + \inmodule QtMqtt + \since 5.12 + + \brief The QMqttConnectionProperties class represents configuration + options a QMqttClient can pass to the server when invoking + QMqttClient::connectToHost(). + + \note Connection properties are part of the MQTT 5.0 specification and + cannot be used when connecting with a lower protocol level. See + QMqttClient::ProtocolVersion for more information. +*/ + +/*! + \class QMqttServerConnectionProperties + + \inmodule QtMqtt + \since 5.12 + + \brief The QMqttServerConnectionProperties class represents configuration + options of a server a QMqttClient is connected to. + + When a connection has been established the server might send additional + details about the connection properties. Use availableProperties() to + identify properties set by the server. If a property is not set by the + server, default values are assumed and can be obtained by invoking access + functions of this instance. + + \note Connection properties are part of the MQTT 5.0 specification and + cannot be used when connecting with a lower protocol level. See + QMqttClient::ProtocolVersion for more information. +*/ + +/*! + \class QMqttLastWillProperties + + \inmodule QtMqtt + \since 5.12 + + \brief The QMqttLastWillProperties class represents configuration + options a QMqttClient can pass to the server when specifying the last will + during connecting to a server. + + \note Last Will properties are part of the MQTT 5.0 specification and + cannot be used when connecting with a lower protocol level. See + QMqttClient::ProtocolVersion for more information. +*/ + +/*! + \enum QMqttServerConnectionProperties::ServerPropertyDetail + + This enum type specifies the available properties set by the + server or the client after establishing a connection. + + \value None + No property has been specified. + \value SessionExpiryInterval + The number of seconds the server keeps the session after + a disconnect. + \value MaximumReceive + The maximum number of QoS 1 and 2 message the server is + capable of managing concurrently. + \value MaximumQoS + The maximum QoS level the server can understand. + \value RetainAvailable + Specifies whether retained messages are supported. + \value MaximumPacketSize + Specifies the maximum packet size including the message header + and properties. + \value AssignedClientId + Specifies whether the server assigned a client identifier. + \value MaximumTopicAlias + Specifies the maximum amount of topic aliases. + \value ReasonString + Specifies a string providing more details on connection state. + \value UserProperty + Specifies additional user properties. + \value WildCardSupported + Specifies whether the server supports wildcard subscriptions. + \value SubscriptionIdentifierSupport + Specifies whether the server supports subscription identifiers. + \value SharedSubscriptionSupport + Specifies whether the server supports shared subscriptions. + \value ServerKeepAlive + Specifies the number of seconds the server expects a keep alive + packet from the client. + \value ResponseInformation + Specifies the response information. + \value ServerReference + Specifies an alternative server address for the client to + connect to. + \value AuthenticationMethod + Specifies the authentication method. + \value AuthenticationData + Specifies the authentication data. +*/ + +/*! + \internal +*/ QMqttLastWillProperties::QMqttLastWillProperties() : data(new QMqttLastWillPropertiesData) { } +/*! + \internal +*/ QMqttLastWillProperties::QMqttLastWillProperties(const QMqttLastWillProperties &) = default; QMqttLastWillProperties &QMqttLastWillProperties::operator=(const QMqttLastWillProperties &rhs) @@ -54,81 +159,132 @@ QMqttLastWillProperties &QMqttLastWillProperties::operator=(const QMqttLastWillP QMqttLastWillProperties::~QMqttLastWillProperties() = default; +/*! + Returns the delay in seconds a last will message will be sent after + disconnecting from the server. +*/ quint32 QMqttLastWillProperties::willDelayInterval() const { return data->willDelayInterval; } +/*! + Returns the payload format indicator. +*/ QMqtt::PayloadFormatIndicator QMqttLastWillProperties::payloadFormatIndicator() const { return data->formatIndicator; } +/*! + Returns the lifetime of the last will message in seconds, starting from + the will delay interval. +*/ quint32 QMqttLastWillProperties::messageExpiryInterval() const { return data->messageExpiryInterval; } +/*! + Returns the content type of the last will message. +*/ QString QMqttLastWillProperties::contentType() const { return data->contentType; } +/*! + Returns the topic that subscribers to the last will message should respond + to. +*/ QString QMqttLastWillProperties::responseTopic() const { return data->responseTopic; } +/*! + Returns the correlation data to identify the request. +*/ QByteArray QMqttLastWillProperties::correlationData() const { return data->correlationData; } +/*! + Returns the user properties. +*/ QMqttUserProperties QMqttLastWillProperties::userProperties() const { return data->userProperties; } +/*! + Sets the will delay interval to \a delay. +*/ void QMqttLastWillProperties::setWillDelayInterval(quint32 delay) { data->willDelayInterval = delay; } +/*! + Sets the payload format indicator to \a p. +*/ void QMqttLastWillProperties::setPayloadFormatIndicator(QMqtt::PayloadFormatIndicator p) { data->formatIndicator = p; } +/*! + Sets the message expiry interval to \a expiry. +*/ void QMqttLastWillProperties::setMessageExpiryInterval(quint32 expiry) { data->messageExpiryInterval = expiry; } +/*! + Sets the content type to \a content. +*/ void QMqttLastWillProperties::setContentType(const QString &content) { data->contentType = content; } +/*! + Sets the response topic to \a response. +*/ void QMqttLastWillProperties::setResponseTopic(const QString &response) { data->responseTopic = response; } +/*! + Sets the correlation data to \a correlation. +*/ void QMqttLastWillProperties::setCorrelationData(const QByteArray &correlation) { data->correlationData = correlation; } +/*! + Sets the user properties to \a properties. +*/ void QMqttLastWillProperties::setUserProperties(const QMqttUserProperties &properties) { data->userProperties = properties; } +/*! + \internal +*/ QMqttConnectionProperties::QMqttConnectionProperties() : data(new QMqttConnectionPropertiesData) { } +/*! + \internal +*/ QMqttConnectionProperties::QMqttConnectionProperties(const QMqttConnectionProperties &) = default; QMqttConnectionProperties &QMqttConnectionProperties::operator=(const QMqttConnectionProperties &rhs) @@ -140,11 +296,25 @@ QMqttConnectionProperties &QMqttConnectionProperties::operator=(const QMqttConne QMqttConnectionProperties::~QMqttConnectionProperties() = default; +/*! + Sets the session expiry interval to \a expiry. The session expiry interval + specifies the number of seconds a server holds information on the client + state after a connection has been closed. + + The default value is 0, which specifies that the session is closed when + the network connection ends. If the value is specified as maximum of + quint32, then the session does not expire. +*/ void QMqttConnectionProperties::setSessionExpiryInterval(quint32 expiry) { data->sessionExpiryInterval = expiry; } +/*! + Sets the maximum QoS level the client is allowed to receive to \a qos. + + A maximum receive value of 0 is not allowed. +*/ void QMqttConnectionProperties::setMaximumReceive(quint16 qos) { if (qos == 0) { @@ -154,6 +324,14 @@ void QMqttConnectionProperties::setMaximumReceive(quint16 qos) data->maximumReceive = qos; } +/*! + Sets the maximum packet size to \a packetSize. The maximum packet size + specifies the maximum size one packet can contain. This includes the + packet header and its properties. + + If no maximum packet size is specified, no limit is imposed beyond the + limitations of the protocol itself. +*/ void QMqttConnectionProperties::setMaximumPacketSize(quint32 packetSize) { if (packetSize == 0) { @@ -163,81 +341,161 @@ void QMqttConnectionProperties::setMaximumPacketSize(quint32 packetSize) data->maximumPacketSize = packetSize; } +/*! + Sets the maximum topic alias to \a alias. The maximum topic alias specifies + the highest value that the client will accept from the server. The client + uses this value to limit the number of topic aliases it is willing to hold + for the connection. + + The default value is 0. 0 indicates that the client does not accept any + topic aliases on this connection. +*/ void QMqttConnectionProperties::setMaximumTopicAlias(quint16 alias) { data->maximumTopicAlias = alias; } +/*! + Sets the request response information to \a response. A client uses this + to request the server to return response information after the connection + request has been handled. + + The default value is \c false, which indicates that the client must not + return any response information. If the value is \c true, the server + may return response information, but is not enforced to do so. +*/ void QMqttConnectionProperties::setRequestResponseInformation(bool response) { data->requestResponseInformation = response; } +/*! + Sets the request problem information to \a problem. A client uses this + to request the server to return additional information in case of failure. + Types of failure include connection and message management on the server + side. + + The default value is \c false, which indicates that the client must not + receive any problem information for anything but connection management. + The server still may send problem information for connection handling. + If the value is \c true, the server may return problem information. + + Problem information is available in user properties or reason strings + of the property classes. +*/ void QMqttConnectionProperties::setRequestProblemInformation(bool problem) { data->requestProblemInformation = problem; } +/*! + Sets the user properties of the connection to \a properties. + + The default value is to not send any user information. +*/ void QMqttConnectionProperties::setUserProperties(const QMqttUserProperties &properties) { data->userProperties = properties; } +/*! + Sets the authentication method to \a authMethod. + + \sa authenticationData() +*/ void QMqttConnectionProperties::setAuthenticationMethod(const QString &authMethod) { data->authenticationMethod = authMethod; } +/*! + Sets the authentication data to \a authData. + + Authentication data can only be used if an authentication method has + been specified. + + \sa authenticationMethod() +*/ void QMqttConnectionProperties::setAuthenticationData(const QByteArray &authData) { data->authenticationData = authData; } +/*! + Returns the session expiry interval. +*/ quint32 QMqttConnectionProperties::sessionExpiryInterval() const { return data->sessionExpiryInterval; } +/*! + Returns the maximum QoS level the client can receive. +*/ quint16 QMqttConnectionProperties::maximumReceive() const { return data->maximumReceive; } +/*! + Returns the maximum packet size the client can receive. +*/ quint32 QMqttConnectionProperties::maximumPacketSize() const { return data->maximumPacketSize; } +/*! + Returns the maximum topic alias ID the client can use. +*/ quint16 QMqttConnectionProperties::maximumTopicAlias() const { return data->maximumTopicAlias; } +/*! + Returns whether the client should receive response information. +*/ bool QMqttConnectionProperties::requestResponseInformation() const { return data->requestResponseInformation; } +/*! + Returns whether the client should receive problem information. +*/ bool QMqttConnectionProperties::requestProblemInformation() const { return data->requestProblemInformation; } +/*! + Returns the user properties for the connection. +*/ QMqttUserProperties QMqttConnectionProperties::userProperties() const { return data->userProperties; } +/*! + Returns the authentication method. +*/ QString QMqttConnectionProperties::authenticationMethod() const { return data->authenticationMethod; } +/*! + Returns the authentication data. +*/ QByteArray QMqttConnectionProperties::authenticationData() const { return data->authenticationData; } +/*! + \internal +*/ QMqttServerConnectionProperties::QMqttServerConnectionProperties() : QMqttConnectionProperties() , serverData(new QMqttServerConnectionPropertiesData) @@ -245,6 +503,9 @@ QMqttServerConnectionProperties::QMqttServerConnectionProperties() } +/*! + \internal +*/ QMqttServerConnectionProperties::QMqttServerConnectionProperties(const QMqttServerConnectionProperties &rhs) : QMqttConnectionProperties(rhs) , serverData(rhs.serverData) @@ -263,61 +524,117 @@ QMqttServerConnectionProperties &QMqttServerConnectionProperties::operator=(cons QMqttServerConnectionProperties::~QMqttServerConnectionProperties() = default; +/*! + Returns the available properties specified by the server. +*/ QMqttServerConnectionProperties::ServerPropertyDetails QMqttServerConnectionProperties::availableProperties() const { return serverData->details; } +/*! + Returns \c true if the server provided properties as part of the connection + aknowledgment. Returns \c false if no properties have been provided. +*/ bool QMqttServerConnectionProperties::isValid() const { return serverData->valid; } +/*! + Returns the maximum QoS level the server is able to understand. + The default value is 2. +*/ quint8 QMqttServerConnectionProperties::maximumQoS() const { return serverData->maximumQoS; } +/*! + Returns \c true if the server accepts retained messages. + The default value is \c true. +*/ bool QMqttServerConnectionProperties::retainAvailable() const { return serverData->retainAvailable; } +/*! + Returns \c true if the server assigned a new client identifier to + the client. + + \sa QMqttClient::clientId() +*/ bool QMqttServerConnectionProperties::clientIdAssigned() const { return serverData->details & QMqttServerConnectionProperties::AssignedClientId; } +/*! + Returns the reason string associated with this response. +*/ QString QMqttServerConnectionProperties::reason() const { return serverData->reasonString; } +/*! + Returns \c true if the server accepts subscriptions including wildcards. + The default value is \c true. +*/ bool QMqttServerConnectionProperties::wildcardSupported() const { return serverData->wildcardSupported; } +/*! + Returns \c true if the server accepts subscription identifiers. + Subscription identifiers can be passed to the server when creating + a new subscription. + + The default value is \c true. + + \sa QMqttSubscriptionProperties::setSubscriptionIdentifier() +*/ bool QMqttServerConnectionProperties::subscriptionIdentifierSupported() const { return serverData->subscriptionIdentifierSupported; } +/*! + Returns \c true if the server accepts shared subscriptions. + The default value is \c true. +*/ bool QMqttServerConnectionProperties::sharedSubscriptionSupported() const { return serverData->sharedSubscriptionSupported; } + +/*! + Returns the number of seconds the server requested as keep alive. This + overwrites the keep alive being set from the client side. + + \sa QMqttClient::setKeepAlive() +*/ quint16 QMqttServerConnectionProperties::serverKeepAlive() const { return serverData->serverKeepAlive; } +/*! + Returns the response information. +*/ QString QMqttServerConnectionProperties::responseInformation() const { return serverData->responseInformation; } +/*! + Returns a server address which can be used by the client alternatively + to connect to. Typically, this is used together with the reason + code \c 0x9c (Use another server) or \c 0x9c (Server moved). +*/ QString QMqttServerConnectionProperties::serverReference() const { return serverData->serverReference; |