IoT Platform:Ejemplo de uso

Contexto

• Para obtener más información sobre la compresión de datos, consulte Overview.

• La compresión de datos utiliza conexiones MQTT. Para más detalles sobre el código relacionado con MQTT, consulte Usage example.

Paso 1: Inicialización

1. Agregue el archivo de encabezado.

   ……
   ……
   #include "aiot_compress_api.h"
   ……

2. Configure la dependencia subyacente y la salida de registros.

   aiot_sysdep_set_portfile(&g_aiot_sysdep_portfile);
   aiot_state_set_logcb(demo_state_logcb);

3. Invoque aiot_compress_init para crear una instancia de compresión de datos e inicializar los parámetros predeterminados.

    /* Create a compress client instance and initialize the default parameters. */
       compress_handle = aiot_compress_init();
       if (compress_handle == NULL) {
           demo_mqtt_stop(&mqtt_handle);
           printf("aiot_compress_init failed\n");
           return -1;
       }

Paso 2: Configurar funciones

Invoque aiot_compress_setopt para establecer la siguiente configuración.

1. Asocie el identificador de conexión MQTT.

   /* Associate the MQTT handle. */
   aiot_compress_setopt(compress_handle, AIOT_COMPRESSOPT_MQTT_HANDLE, mqtt_handle);

2. Establezca el nivel de compresión.

    /* Set the compression level. The level ranges from 1 to 9. A higher level provides better compression but consumes more memory and time. */
    uint8_t compress_level = 1;
    aiot_compress_setopt(compress_handle, AIOT_COMPRESSOPT_LEVEL, &compress_level);

3. Agregue los topics para mensajes originados en el dispositivo (MO) que requieren compresión.

   Especifique la ruta completa del topic. No se admiten caracteres comodín.

   • Defina la lista.

     /* TODO: Replace this with the list of topics for mobile originated messages that you want to compress. */
     char *compr_list[] = {
         "/${YourProductKey}/${YourDeviceName}/user/update",
         "/sys/${YourProductKey}/${YourDeviceName}/thing/event/property/post",
     };

   • Configure la lista de topics.

     /* Add the topics for mobile originated messages that require compression. */
     for(int i = 0; i < sizeof(compr_list) / sizeof(char *); i++) {
         aiot_compress_setopt(compress_handle, AIOT_COMPRESSOPT_APPEND_COMPR_TOPIC, compr_list[i]);
     }

4. Agregue los topics para mensajes terminados en el dispositivo (MT) que requieren descompresión.

   • Defina la lista.

     /* TODO: Replace this with the list of topics for mobile terminated messages that you want to compress. */
     char *decompr_list[] = {
         "/${YourProductKey}/${YourDeviceName}/user/update_reply",
         "/sys/${YourProductKey}/${YourDeviceName}/thing/event/property/post_reply",
     };

   • Configure la lista de topics.

      /* Add the topics for mobile terminated messages that require decompression. */
      for(int i = 0; i < sizeof(decompr_list) / sizeof(char *); i++) {
          aiot_compress_setopt(compress_handle, AIOT_COMPRESSOPT_APPEND_DECOMPR_TOPIC, decompr_list[i]);
      }

5. Establezca la función de callback para el reporte de la lista de topics.

    /* Report the list of topics for compression or decompression to IoT Platform. You only need to report the list once. The configuration remains valid after a restart. */
       uint32_t code = 0;
       aiot_compress_setopt(compress_handle, AIOT_COMPRESSOPT_RECV_HANDLER, demo_update_reply);
       aiot_compress_setopt(compress_handle, AIOT_COMPRESSOPT_USERDATA, &code);

   Implemente la función de callback para obtener el resultado.

   static void demo_update_reply(void *handle, const aiot_compress_recv_t *packet, void *userdata)
   {
       uint32_t *code = (uint32_t *)userdata;
       *code = packet->data.update_reply.code;
       printf("compress update reply code %d, message %.*s\r\n", packet->data.update_reply.code, packet->data.update_reply.message_len, packet->data.update_reply.message);
   }

(Opcional) Paso 3: Reportar la lista de topics de compresión

Reporte la lista de topics para compresión o descompresión desde el dispositivo y espere el resultado.

• Reporte la lista de topics de compresión.

  aiot_compress_topiclist_update(compress_handle);

• Un código de retorno 200 indica que la operación fue exitosa.

   if(code != 200) {
          demo_mqtt_stop(&mqtt_handle);
          aiot_compress_deinit(&compress_handle);
          printf("aiot_compress_topiclist_update failed\n");
          return -1;
      }

Paso 4: Publicar mensajes en la lista de compresión

Cuando publica un mensaje en un topic incluido en la lista de compresión, el Link SDK comprime el mensaje automáticamente.

Invoque aiot_mqtt_pub para publicar el mensaje de la misma forma que un mensaje normal.

 char *pub_topic = "/sys/${YourProductKey}/${YourDeviceName}/thing/event/property/post";
 char *pub_payload = "{\"id\":\"1\",\"version\":\"1.0\",\"params\":{\"LightSwitch\":0, \"message\":\"this is a test message, this is a test message, this is a test message\"}}";
 aiot_mqtt_pub(mqtt_handle, pub_topic, (uint8_t *)pub_payload, (uint32_t)strlen(pub_payload), 0);

Paso 5: Recibir mensajes de la lista de compresión

Para los mensajes terminados en el dispositivo (MT) que requieren compresión, IoT Platform los comprime antes de entregarlos. El Link SDK descomprime estos mensajes automáticamente y la función de callback recibe los datos descomprimidos.

Invoque aiot_mqtt_recv para procesar los mensajes recibidos. Cuando llega un mensaje comprimido, el Link SDK lo descomprime y ejecuta el callback de mensaje correspondiente.

/* The default MQTT message processing callback. This is called when the SDK receives an MQTT message from the server and no corresponding user callback is available to process it. */
void demo_mqtt_default_recv_handler(void *handle, const aiot_mqtt_recv_t *packet, void *userdata)
{
    switch (packet->type) {

	....
    case AIOT_MQTTRECV_PUB: {
        printf("pub, qos: %d, topic: %.*s\n", packet->data.pub.qos, packet->data.pub.topic_len, packet->data.pub.topic);
        printf("pub, payload: %.*s\n", packet->data.pub.payload_len, packet->data.pub.payload);
    }
    break;

	....
    }
}

Paso 6: Salir del programa

Invoque aiot_compress_deinit para destruir la instancia de compresión y liberar los recursos.

  /* Destroy the COMPRESS instance. This part of the code is not typically run. */
    res = aiot_compress_deinit(&compress_handle);
    if (res < STATE_SUCCESS) {
        demo_mqtt_stop(&mqtt_handle);
        printf("aiot_compress_deinit failed: -0x%04X\n", -res);
        return -1;
    }

Siguientes pasos

• Después de configurar el archivo de ejemplo, compílelo para generar el archivo ejecutable ./output/compress-basic-demo. Para más información, consulte Compile and run.

• Para obtener más información sobre los resultados de la operación, consulte Operational logs.