Rework the example to use the new AWS Client

The previous version (v4) of aws-iot-device-sdk-embedded-C is now
deprecated in favour of coreMQTT from Amazon FreeRTOS.

An new AWS client based on coreMQTT and written for Mbed OS has been
contributed by Nantis GmbH, and this commit reworks the example to
support the new AWS client.

Two demos are provided. The demo is selected based on the config
in mbed_app.json:
* MQTT (default): if aws-client.shadow is unset or false
* Device Shadow service: if aws-client.shadow is true

Author: LDong-Arm

CMakeLists.txt

@@ -30,6 +30,8 @@ target_include_directories(${APP_TARGET}
 target_sources(${APP_TARGET}
     PRIVATE
         main.cpp
+        demo_mqtt.cpp
+        demo_shadow.cpp
 )
 
 if("-DMBED_CONF_ISM43362_PROVIDE_DEFAULT=1" IN_LIST MBED_CONFIG_DEFINITIONS)

demo_mqtt.cpp

@@ -0,0 +1,104 @@
+/*
+ * Copyright (c) 2020-2021 Arm Limited
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#if !MBED_CONF_AWS_CLIENT_SHADOW
+
+#include "mbed.h"
+#include "mbed-trace/mbed_trace.h"
+#include "rtos/ThisThread.h"
+#include "AWSClient/AWSClient.h"
+
+extern "C" {
+#include "core_json.h"
+}
+
+#define TRACE_GROUP "Main"
+
+static bool reply_received = false;
+
+// Callback when a MQTT message has been added to the topic
+void on_message_callback(
+    const char *topic,
+    uint16_t topic_length,
+    const void *payload,
+    size_t payload_length)
+{
+    char *json_value;
+    size_t value_length;
+    auto ret = JSON_Search((char *)payload, payload_length, "sender", strlen("sender"), &json_value, &value_length);
+    if (ret == JSONSuccess && (strncmp(json_value, "device", strlen("device")) == 0)) {
+        tr_info("Message sent successfully");
+    } else {
+        ret = JSON_Search((char *)payload, payload_length, "message", strlen("message"), &json_value, &value_length);
+        if (ret == JSONSuccess) {
+            reply_received = true;
+            tr_info("Message received from the cloud: \"%.*s\"", value_length, json_value);
+        } else {
+            tr_error("Failed to extract message from the payload: \"%.*s\"", payload_length, (const char *) payload);
+        }
+    }
+}
+
+void demo()
+{
+    AWSClient &client = AWSClient::getInstance();
+
+    // Subscribe to the topic
+    const char topic[] = MBED_CONF_APP_AWS_MQTT_TOPIC;
+    int ret = client.subscribe(topic, strlen(topic));
+    if (ret != MBED_SUCCESS) {
+        tr_error("AWSClient::subscribe() failed");
+        return;
+    }
+
+    // Send ten message to the cloud (one per second)
+    // Stop when we receive a cloud-to-device message
+    char payload[128];
+    for (int i = 0; i < 10; i++) {
+        if (reply_received) {
+            // If we have received a message from the cloud, don't send more messeges
+            break;
+        }
+
+        // The MQTT protocol does not distinguish between senders,
+        // so we add a "sender" attribute to the payload
+        const char base_message[] = "messages left to send, or until we receive a reply";
+        sprintf(payload, "{\n"
+                "    \"sender\": \"device\",\n"
+                "    \"message\": \"%d %s\"\n"
+                "}",
+                10 - i, base_message);
+        tr_info("Publishing \"%d %s\" to topic \"%s\"", 10 - i, base_message, topic);
+        ret = client.publish(
+                  topic,
+                  strlen(topic),
+                  payload,
+                  strlen(payload)
+              );
+        if (ret != MBED_SUCCESS) {
+            tr_error("AWSClient::publish() failed");
+            goto unsubscribe;
+        }
+
+        rtos::ThisThread::sleep_for(1s);
+    }
+
+    // If the user didn't manage to send a cloud-to-device message earlier,
+    // let's wait until we receive one
+    while (!reply_received) {
+        // Continue to receive messages in the communication thread
+        // which is internally created and maintained by the Azure SDK.
+        sleep();
+    }
+
+unsubscribe:
+    // Unsubscribe from the topic
+    ret = client.unsubscribe(topic, strlen(topic));
+    if (ret != MBED_SUCCESS) {
+        tr_error("AWSClient::unsubscribe() failed");
+    }
+}
+
+#endif // !MBED_CONF_AWS_CLIENT_SHADOW

demo_shadow.cpp

@@ -0,0 +1,98 @@
+/*
+ * Copyright (c) 2020-2021 Arm Limited
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#if MBED_CONF_AWS_CLIENT_SHADOW
+
+#include "mbed.h"
+#include "mbed-trace/mbed_trace.h"
+#include "AWSClient/AWSClient.h"
+
+extern "C" {
+#include "core_json.h"
+}
+
+#define TRACE_GROUP "Main"
+
+// This should not be called for the Device Shadow demo -
+// Device Shadow messages are internally consumed by the client
+void on_message_callback(
+    const char *topic,
+    uint16_t topic_length,
+    const void *payload,
+    size_t payload_length)
+{
+    tr_warning(
+        "Message received on non-shadow topic: %.*s payload: %.*s",
+        topic_length,
+        topic,
+        (const char *) payload_length,
+        payload
+    );
+}
+
+void demo()
+{
+    AWSClient &client = AWSClient::getInstance();
+
+    // Download shadow document
+    auto ret = client.downloadShadowDocument();
+    if (ret == MBED_SUCCESS) {
+        tr_info("Device Shadow document downloaded");
+    } else {
+        tr_error("AWSClient::downloadShadowDocument() failed: %d", ret);
+        return; // cannot continue without downloadShadowDocument()
+    }
+
+    // Get a desired shadow value
+    const char shadow_demo_int_key[] = "DemoNumber";
+    const int shadow_demo_int_value = 100;
+    char *shadow_value;
+    size_t shadow_value_length;
+    ret = client.getShadowDesiredValue(
+        shadow_demo_int_key,
+        strlen(shadow_demo_int_key),
+        &shadow_value,
+        &shadow_value_length
+    );
+    if (ret == MBED_SUCCESS) {
+        tr_info("Desired value of %s: %.*s", shadow_demo_int_key, shadow_value_length, shadow_value);
+    } else {
+        tr_error(
+            "AWSClient::getShadowDesiredValue() failed: %d, "
+            "please ensure you have set a desired value for %s (e.g. using the AWS Console)",
+            ret,
+            shadow_demo_int_key
+        );
+    }
+
+    // Report a string shadow value
+    const char shadow_demo_string_key[] = "DemoName";
+    const char shadow_demo_string_value[] = "mbed-os-example-for-aws";
+    ret = client.publishShadowReportedValue(
+        shadow_demo_string_key,
+        strlen(shadow_demo_string_key),
+        shadow_demo_string_value,
+        strlen(shadow_demo_string_value)
+    );
+    if (ret == MBED_SUCCESS) {
+        tr_info("Device Shadow reported string value published");
+    } else {
+        tr_error("AWSClient::publishShadowReportedValue() failed: %d", ret);
+    }
+
+    // Report an integer shadow value
+    ret = client.publishShadowReportedValue(
+        shadow_demo_int_key,
+        strlen(shadow_demo_int_key),
+        shadow_demo_int_value
+    );
+    if (ret == MBED_SUCCESS) {
+        tr_info("Device Shadow reported integer value published");
+    } else {
+        tr_error("AWSClient::publishShadowReportedValue() failed: %d", ret);
+    }
+}
+
+#endif // MBED_CONF_AWS_CLIENT_SHADOW