IotMqtt_SerializeSubscribe

Generate a SUBSCRIBE packet from the given parameters.

IotMqttError_t IotMqtt_SerializeSubscribe( const IotMqttSubscription_t * pSubscriptionList,
                                           size_t subscriptionCount,
                                           size_t remainingLength,
                                           uint16_t * pPacketIdentifier,
                                           uint8_t * pBuffer,
                                           size_t bufferSize );

Parameters

[in]	pSubscriptionList	User-provided array of subscriptions.
[in]	subscriptionCount	Size of pSubscriptionList.
[in]	remainingLength	remaining length of the packet to be serialized.
[out]	pPacketIdentifier	The packet identifier generated for this SUBSCRIBE.
[in,out]	pBuffer	User provide buffer where the SUBSCRIBE packet is written.
[in]	bufferSize	Size of the buffer pointed to by pBuffer.

Returns

IOT_MQTT_SUCCESS or IOT_MQTT_NO_MEMORY.

Note

pBuffer must be allocated by caller.

This call is part of serializer API used for implementing light-weight MQTT client. Example

// Example code below shows how IotMqtt_SerializeSubscribe() should be used to serialize
// MQTT Subscribe packet and send it to MQTT broker.
// Example uses static memory, but dynamically allocated memory can be used as well.
// Get size requirement for the MQTT subscribe packet.

#define mqttexampleSHARED_BUFFER_SIZE 100
static ucSharedBuffer[mqttexampleSHARED_BUFFER_SIZE];
void sendSubscribePacket( int xMQTTSocket )
{
   IotMqttSubscription_t xMQTTSubscription[ 1 ];
   size_t xRemainingLength = 0;
   size_t xPacketSize = 0;
   IotMqttError_t xResult;
   size_t xSentBytes = 0;

   // Initialize Subscribe parameters. Details are out of scope for this example.
   // It will involve setting QOS, topic filter  and topic filter length.
   _initializeSubscribe( xMQTTSubscription );
   // Get size requirement for MQTT Subscribe packet.
   xResult = IotMqtt_GetSubscriptionPacketSize( IOT_MQTT_SUBSCRIBE,
                                             xMQTTSubscription,
                                             sizeof( xMQTTSubscription ) / sizeof( IotMqttSubscription_t ),
                                             &xRemainingLength, &xPacketSize );
   IotMqtt_Assert( xResult == IOT_MQTT_SUCCESS );
   // Make sure the packet size is less than static buffer size.
   IotMqtt_Assert( xPacketSize < mqttexampleSHARED_BUFFER_SIZE );

   // Serialize subscribe into statically allocated ucSharedBuffer.
    xResult = IotMqtt_SerializeSubscribe( xMQTTSubscription,
                                      sizeof( xMQTTSubscription ) / sizeof( IotMqttSubscription_t ),
                                      xRemainingLength,
                                      &usPacketIdentifier,
                                      ucSharedBuffer,
                                      xPacketSize );
   IotMqtt_Assert( xResult == IOT_MQTT_SUCCESS );
   // xMQTTSocket here is posix socket created and connected to MQTT broker outside of this function.
   xSentBytes = send( xMQTTSocket, ( void * ) ucSharedBuffer, xPacketSize, 0 );
   IotMqtt_Assert( xSentBytes == xPacketSize );
}