void IoTHubAccount_deinit(IOTHUB_ACCOUNT_INFO_HANDLE acctHandle)
{
if (acctHandle != NULL)
{
IOTHUB_ACCOUNT_INFO* acctInfo = (IOTHUB_ACCOUNT_INFO*)acctHandle;
IOTHUB_REGISTRYMANAGER_RESULT iothub_registrymanager_result;
iothub_registrymanager_result = IoTHubRegistryManager_DeleteDevice(acctInfo->iothub_registrymanager_handle, acctInfo->deviceId);
if (iothub_registrymanager_result != IOTHUB_REGISTRYMANAGER_OK)
{
LogError("IoTHubRegistryManager_DeleteDevice failed\r\n");
}
IoTHubMessaging_LL_Destroy(acctInfo->iothub_messaging_handle);
IoTHubRegistryManager_Destroy(acctInfo->iothub_registrymanager_handle);
IoTHubServiceClientAuth_Destroy(acctInfo->iothub_service_client_auth_handle);
free(acctInfo->hostname);
free(acctInfo->iothubName);
free(acctInfo->iothubSuffix);
free(acctInfo->sharedAccessKey);
free(acctInfo->sharedAccessToken);
free(acctInfo->keyName);
free(acctInfo->eventhubAccessKey);
free(acctInfo->deviceId);
free(acctInfo->deviceKey);
free(acctInfo);
}
}
int main(void)
{
(void)platform_init();
(void)printf("Calling IoTHubServiceClientAuth_CreateFromConnectionString with connectionString\n");
IOTHUB_SERVICE_CLIENT_AUTH_HANDLE iotHubServiceClientHandle = IoTHubServiceClientAuth_CreateFromConnectionString(connectionString);
if (iotHubServiceClientHandle == NULL)
{
(void)printf("IoTHubServiceClientAuth_CreateFromConnectionString failed\n");
}
else
{
IOTHUB_SERVICE_CLIENT_DEVICE_METHOD_HANDLE serviceClientDeviceMethodHandle = IoTHubDeviceMethod_Create(iotHubServiceClientHandle);
if (serviceClientDeviceMethodHandle == NULL)
{
(void)printf("IoTHubDeviceMethod_Create failed\n");
}
else
{
(void)printf("Invoking method %s on device...\n", methodName);
int responseStatus;
unsigned char* responsePayload;
size_t responsePayloadSize;
IOTHUB_DEVICE_METHOD_RESULT invokeResult = IoTHubDeviceMethod_Invoke(serviceClientDeviceMethodHandle, deviceId, methodName, methodPayload, timeout, &responseStatus, &responsePayload, &responsePayloadSize);
if (invokeResult == IOTHUB_DEVICE_METHOD_OK)
{
printf("\r\nDevice Method called\r\n");
printf("Device Method name: %s\r\n", methodName);
printf("Device Method payload: %s\r\n", methodPayload);
printf("\r\nResponse status: %d\r\n", responseStatus);
printf("Response payload: %.*s\r\n", (int)responsePayloadSize, (const char*)responsePayload);
free(responsePayload);
}
else
{
(void)printf("IoTHubDeviceMethod_Invoke failed with result: %d\n", invokeResult);
}
(void)printf("Calling IoTHubDeviceMethod_Destroy...\n");
IoTHubDeviceMethod_Destroy(serviceClientDeviceMethodHandle);
}
(void)printf("Calling IoTHubServiceClientAuth_Destroy...\n");
IoTHubServiceClientAuth_Destroy(iotHubServiceClientHandle);
}
platform_deinit();
}
IOTHUB_ACCOUNT_INFO_HANDLE IoTHubAccount_Init(bool createDevice)
{
IOTHUB_ACCOUNT_INFO* iothub_account_info = malloc(sizeof(IOTHUB_ACCOUNT_INFO));
if (iothub_account_info == NULL)
{
LogError("[IoTHubAccount] Failed allocating IOTHUB_ACCOUNT_INFO.");
}
else
{
memset(iothub_account_info, 0, sizeof(IOTHUB_ACCOUNT_INFO));
#ifdef MBED_BUILD_TIMESTAMP
iothub_account_info->connString = getMbedParameter("IOTHUB_CONNECTION_STRING");
iothub_account_info->eventhubConnString = getMbedParameter("IOTHUB_EVENTHUB_CONNECTION_STRING");
#else
iothub_account_info->connString = getenv("IOTHUB_CONNECTION_STRING");
iothub_account_info->eventhubConnString = getenv("IOTHUB_EVENTHUB_CONNECTION_STRING");
#endif
if (iothub_account_info->connString == NULL || iothub_account_info->eventhubConnString == NULL)
{
LogError("Failure retrieving Connection Strings values.\r\n");
free(iothub_account_info);
iothub_account_info = NULL;
}
else
{
if (retrieveConnStringInfo(iothub_account_info) != 0)
{
LogError("retrieveConnStringInfo failed.\r\n");
free(iothub_account_info);
iothub_account_info = NULL;
}
else if (createDevice)
{
iothub_account_info->iothub_service_client_auth_handle = IoTHubServiceClientAuth_CreateFromConnectionString(iothub_account_info->connString);
if (iothub_account_info->iothub_service_client_auth_handle == NULL)
{
LogError("IoTHubServiceClientAuth_CreateFromConnectionString failed\r\n");
free(iothub_account_info);
iothub_account_info = NULL;
}
else
{
iothub_account_info->iothub_messaging_handle = IoTHubMessaging_LL_Create(iothub_account_info->iothub_service_client_auth_handle);
if (iothub_account_info->iothub_messaging_handle == NULL)
{
LogError("IoTHubMessaging_LL_Create failed\r\n");
IoTHubServiceClientAuth_Destroy(iothub_account_info->iothub_service_client_auth_handle);
free(iothub_account_info);
iothub_account_info = NULL;
}
else
{
iothub_account_info->iothub_registrymanager_handle = IoTHubRegistryManager_Create(iothub_account_info->iothub_service_client_auth_handle);
if (iothub_account_info->iothub_registrymanager_handle == NULL)
{
LogError("IoTHubRegistryManager_Create failed\r\n");
IoTHubMessaging_LL_Destroy(iothub_account_info->iothub_messaging_handle);
IoTHubServiceClientAuth_Destroy(iothub_account_info->iothub_service_client_auth_handle);
free(iothub_account_info);
iothub_account_info = NULL;
}
else
{
if (generateDeviceName(iothub_account_info) != 0)
{
LogError("generateDeviceName failed\r\n");
IoTHubMessaging_LL_Destroy(iothub_account_info->iothub_messaging_handle);
IoTHubRegistryManager_Destroy(iothub_account_info->iothub_registrymanager_handle);
IoTHubServiceClientAuth_Destroy(iothub_account_info->iothub_service_client_auth_handle);
free(iothub_account_info);
iothub_account_info = NULL;
}
IOTHUB_REGISTRYMANAGER_RESULT iothub_registrymanager_result;
IOTHUB_REGISTRY_DEVICE_CREATE deviceCreateInfo;
IOTHUB_DEVICE deviceInfo;
deviceInfo.deviceId = NULL;
deviceInfo.primaryKey = NULL;
deviceInfo.secondaryKey = NULL;
deviceInfo.generationId = NULL;
deviceInfo.eTag = NULL;
deviceInfo.connectionStateUpdatedTime = NULL;
deviceInfo.statusReason = NULL;
deviceInfo.statusUpdatedTime = NULL;
deviceInfo.lastActivityTime = NULL;
deviceInfo.configuration = NULL;
deviceInfo.deviceProperties = NULL;
deviceInfo.serviceProperties = NULL;
deviceCreateInfo.deviceId = iothub_account_info->deviceId;
deviceCreateInfo.primaryKey = "";
deviceCreateInfo.secondaryKey = "";
iothub_registrymanager_result = IoTHubRegistryManager_CreateDevice(iothub_account_info->iothub_registrymanager_handle, &deviceCreateInfo, &deviceInfo);
if (iothub_registrymanager_result != IOTHUB_REGISTRYMANAGER_OK)
{
LogError("IoTHubRegistryManager_CreateDevice failed\r\n");
IoTHubRegistryManager_Destroy(iothub_account_info->iothub_registrymanager_handle);
IoTHubServiceClientAuth_Destroy(iothub_account_info->iothub_service_client_auth_handle);
free(iothub_account_info->deviceId);
free(iothub_account_info);
iothub_account_info = NULL;
}
else
{
if (mallocAndStrcpy_s((char**)&iothub_account_info->deviceKey, (char*)deviceInfo.primaryKey) != 0)
{
LogError("mallocAndStrcpy_s failed for primaryKey\r\n");
}
}
if (deviceInfo.deviceId != NULL)
free((char*)deviceInfo.deviceId);
if (deviceInfo.primaryKey != NULL)
free((char*)deviceInfo.primaryKey);
if(deviceInfo.secondaryKey != NULL)
free((char*)deviceInfo.secondaryKey);
if(deviceInfo.generationId != NULL)
free((char*)deviceInfo.generationId);
if(deviceInfo.eTag != NULL)
free((char*)deviceInfo.eTag);
if(deviceInfo.connectionStateUpdatedTime != NULL)
free((char*)deviceInfo.connectionStateUpdatedTime);
if(deviceInfo.statusReason != NULL)
free((char*)deviceInfo.statusReason);
if(deviceInfo.statusUpdatedTime != NULL)
free((char*)deviceInfo.statusUpdatedTime);
if(deviceInfo.lastActivityTime != NULL)
free((char*)deviceInfo.lastActivityTime);
if(deviceInfo.configuration != NULL)
free((char*)deviceInfo.configuration);
if(deviceInfo.deviceProperties != NULL)
free((char*)deviceInfo.deviceProperties);
if(deviceInfo.serviceProperties != NULL)
free((char*)deviceInfo.serviceProperties);
}
}
}
}
}
}
return (IOTHUB_ACCOUNT_INFO_HANDLE)iothub_account_info;
}
void iothub_messaging_ll_sample_run(void)
{
xlogging_set_log_function(consolelogger_log);
if (platform_init() != 0)
{
(void)printf("Failed to initialize the platform.\r\n");
}
else
{
(void)printf("Calling IoTHubServiceClientAuth_CreateFromConnectionString with connection string\n");
iotHubServiceClientHandle = IoTHubServiceClientAuth_CreateFromConnectionString(connectionString);
if (iotHubServiceClientHandle == NULL)
{
(void)printf("IoTHubServiceClientAuth_CreateFromConnectionString failed\n");
}
else
{
(void)printf("Service Client Authentication handle has been created successfully\n");
(void)printf("Creating Messaging...\n");
iotHubMessagingHandle = IoTHubMessaging_LL_Create(iotHubServiceClientHandle);
if (iotHubMessagingHandle == NULL)
{
(void)printf("IoTHubMessaging_LL_Create failed\n");
}
else
{
(void)printf("Messaging has been created successfully\n");
(void)printf("Opening Messaging...\n");
iotHubMessagingResult = IoTHubMessaging_LL_SetFeedbackMessageCallback(iotHubMessagingHandle, feedbackReceivedCallback, "Context string for feedback");
if (iotHubMessagingResult != IOTHUB_MESSAGING_OK)
{
(void)printf("IoTHubMessaging_LL_SetFeedbackMessageCallback failed\n");
}
else
{
iotHubMessagingResult = IoTHubMessaging_LL_Open(iotHubMessagingHandle, openCompleteCallback, "Context string for open");
if (iotHubMessagingResult != IOTHUB_MESSAGING_OK)
{
(void)printf("IoTHubMessaging_LL_Open failed\n");
}
else
{
for (int i = 0; i < MESSAGE_COUNT; i++)
{
double avgWindSpeed = 10.0;
static char msgText[1024];
sprintf_s(msgText, sizeof(msgText), "{\"deviceId\":%s,\"windSpeed\":%.2f, \"i\":%d}", deviceId, avgWindSpeed + (rand() % 4 + 2), i);
IOTHUB_MESSAGE_HANDLE messageHandle = IoTHubMessage_CreateFromByteArray((const unsigned char*)msgText, strlen(msgText));
if (messageHandle == NULL)
{
(void)printf("IoTHubMessage_CreateFromByteArray failed\n");
break;
}
else
{
iotHubMessagingResult = IoTHubMessaging_LL_Send(iotHubMessagingHandle, deviceId, messageHandle, sendCompleteCallback, NULL);
if (iotHubMessagingResult != IOTHUB_MESSAGING_OK)
{
(void)printf("IoTHubMessaging_LL_Send failed\n");
}
else
{
(void)printf("IoTHubMessaging_LL_Send accepted data for transmission to IoT Hub.\r\n");
}
}
IoTHubMessage_Destroy(messageHandle);
}
feedbackCount = 0;
while (feedbackCount < MESSAGE_COUNT)
{
IoTHubMessaging_LL_DoWork(iotHubMessagingHandle);
ThreadAPI_Sleep(1);
}
/* Wait for user to press a key. */
(void)printf("Press any key to exit the application. \r\n");
(void)getchar();
IoTHubMessaging_LL_Close(iotHubMessagingHandle);
}
}
(void)printf("Calling IoTHubMessaging_LL_Destroy...\n");
IoTHubMessaging_LL_Destroy(iotHubMessagingHandle);
}
(void)printf("Calling IoTHubServiceClientAuth_Destroy...\n");
IoTHubServiceClientAuth_Destroy(iotHubServiceClientHandle);
}
platform_deinit();
}
}
static void RecvMessage(IOTHUB_PROVISIONED_DEVICE* deviceToUse)
{
// arrange
IOTHUB_CLIENT_HANDLE iotHubClientHandle;
IOTHUB_SERVICE_CLIENT_AUTH_HANDLE iotHubServiceClientHandle;
IOTHUB_MESSAGING_CLIENT_HANDLE iotHubMessagingHandle;
IOTHUB_MESSAGING_RESULT iotHubMessagingResult;
IOTHUB_MESSAGE_RESULT iotHubMessageResult;
EXPECTED_RECEIVE_DATA* receiveUserContext;
IOTHUB_MESSAGE_HANDLE messageHandle;
// act
IoTHub_Init();
// Create Service Client
iotHubServiceClientHandle = IoTHubServiceClientAuth_CreateFromConnectionString(IoTHubAccount_GetIoTHubConnString(g_iothubAcctInfo1));
ASSERT_IS_NOT_NULL(iotHubServiceClientHandle, "Could not initialize IoTHubServiceClient to send C2D messages to the device");
iotHubMessagingHandle = IoTHubMessaging_Create(iotHubServiceClientHandle);
ASSERT_IS_NOT_NULL(iotHubMessagingHandle, "Could not initialize IoTHubMessaging to send C2D messages to the device");
iotHubMessagingResult = IoTHubMessaging_Open(iotHubMessagingHandle, openCompleteCallback, (void*)"Context string for open");
ASSERT_ARE_EQUAL(int, IOTHUB_MESSAGING_OK, iotHubMessagingResult);
// Create user context and message
receiveUserContext = ReceiveUserContext_Create();
ASSERT_IS_NOT_NULL(receiveUserContext, "Could not create receive user context");
messageHandle = IoTHubMessage_CreateFromString(MSG_CONTENT1);
ASSERT_IS_NOT_NULL(messageHandle, "Could not create IoTHubMessage to send C2D messages to the device");
iotHubMessageResult = IoTHubMessage_SetMessageId(messageHandle, MSG_ID1);
ASSERT_ARE_EQUAL(int, IOTHUB_MESSAGING_OK, iotHubMessageResult);
iotHubMessageResult = IoTHubMessage_SetCorrelationId(messageHandle, MSG_CORRELATION_ID1);
ASSERT_ARE_EQUAL(int, IOTHUB_MESSAGING_OK, iotHubMessageResult);
MAP_HANDLE mapHandle = IoTHubMessage_Properties(messageHandle);
for (size_t i = 0; i < MSG_PROP_COUNT; i++)
{
if (Map_AddOrUpdate(mapHandle, MSG_PROP_KEYS[i], MSG_PROP_VALS[i]) != MAP_OK)
{
(void)printf("ERROR: Map_AddOrUpdate failed for property %zu!\r\n", i);
}
}
iotHubMessagingResult = IoTHubMessaging_SendAsync(iotHubMessagingHandle, deviceToUse->deviceId, messageHandle, sendCompleteCallback, receiveUserContext);
ASSERT_ARE_EQUAL(int, IOTHUB_MESSAGING_OK, iotHubMessagingResult, "IoTHubMessaging_SendAsync failed, could not send C2D message to the device");
iotHubClientHandle = IoTHubClient_CreateFromConnectionString(deviceToUse->connectionString, HTTP_Protocol);
ASSERT_IS_NOT_NULL(iotHubClientHandle, "Failure creating Iothub Client");
if (deviceToUse->howToCreate == IOTHUB_ACCOUNT_AUTH_X509) {
IOTHUB_CLIENT_RESULT result;
result = IoTHubClient_SetOption(iotHubClientHandle, OPTION_X509_CERT, deviceToUse->certificate);
ASSERT_ARE_EQUAL(IOTHUB_CLIENT_RESULT, IOTHUB_CLIENT_OK, result, "Could not set the device x509 certificate");
result = IoTHubClient_SetOption(iotHubClientHandle, OPTION_X509_PRIVATE_KEY, deviceToUse->primaryAuthentication);
ASSERT_ARE_EQUAL(IOTHUB_CLIENT_RESULT, IOTHUB_CLIENT_OK, result, "Could not set the device x509 privateKey");
}
IOTHUB_CLIENT_RESULT result = IoTHubClient_SetMessageCallback(iotHubClientHandle, ReceiveMessageCallback, receiveUserContext);
ASSERT_ARE_EQUAL(IOTHUB_CLIENT_RESULT, IOTHUB_CLIENT_OK, result, "Failure setting message callback");
unsigned int minimumPollingTime = 1; /*because it should not wait*/
if (IoTHubClient_SetOption(iotHubClientHandle, OPTION_MIN_POLLING_TIME, &minimumPollingTime) != IOTHUB_CLIENT_OK)
{
printf("failure to set option \"MinimumPollingTime\"\r\n");
}
time_t beginOperation, nowTime;
beginOperation = time(NULL);
while (
(
(nowTime = time(NULL)),
(difftime(nowTime, beginOperation) < MAX_CLOUD_TRAVEL_TIME) //time box
)
)
{
if (Lock(receiveUserContext->lock) != LOCK_OK)
{
ASSERT_FAIL("unable ot lock");
}
else
{
if (receiveUserContext->wasFound)
{
(void)Unlock(receiveUserContext->lock);
break;
}
(void)Unlock(receiveUserContext->lock);
}
ThreadAPI_Sleep(100);
}
// assert
ASSERT_IS_TRUE(receiveUserContext->wasFound, "Failure retrieving message that was sent to IotHub."); // was found is written by the callback...
// cleanup
IoTHubMessage_Destroy(messageHandle);
IoTHubMessaging_Close(iotHubMessagingHandle);
IoTHubMessaging_Destroy(iotHubMessagingHandle);
IoTHubServiceClientAuth_Destroy(iotHubServiceClientHandle);
IoTHubClient_Destroy(iotHubClientHandle);
ReceiveUserContext_Destroy(receiveUserContext);
}
void iothub_devicetwin_sample_run(void)
{
//IOTHUB_TWIN_REQUEST_GET GET {iot hub}/twins/{device id} // Get device twin
//IOTHUB_TWIN_REQUEST_UPDATE PATCH {iot hub}/twins/{device id} // Partally update device twin
//IOTHUB_TWIN_REQUEST_REPLACE_TAGS PUT {iot hub}/twins/{device id}/tags // Replace update tags
//IOTHUB_TWIN_REQUEST_REPLACE_DESIRED PUT {iot hub}/twins/{device id}/properties/desired // Replace update desired properties
//IOTHUB_TWIN_REQUEST_UPDATE_DESIRED PATCH {iot hub}/twins/{device id}/properties/desired // Partially update desired properties
xlogging_set_log_function(consolelogger_log);
(void)printf("Calling IoTHubServiceClientAuth_CreateFromConnectionString with the connection string\r\n");
IOTHUB_SERVICE_CLIENT_AUTH_HANDLE iotHubServiceClientHandle = IoTHubServiceClientAuth_CreateFromConnectionString(connectionString);
if (iotHubServiceClientHandle == NULL)
{
(void)printf("IoTHubServiceClientAuth_CreateFromConnectionString failed\r\n");
}
else
{
(void)printf("iotHubServiceClientHandle has been created successfully\r\n");
IOTHUB_SERVICE_CLIENT_DEVICE_TWIN_HANDLE serviceClientDeviceTwinHandle = IoTHubDeviceTwin_Create(iotHubServiceClientHandle);
if (serviceClientDeviceTwinHandle == NULL)
{
(void)printf("IoTHubDeviceTwin_Create failed\r\n");
}
else
{
(void)printf("Getting DeviceTwin...\r\n");
char* deviceTwinJson;
if ((deviceTwinJson = IoTHubDeviceTwin_GetTwin(serviceClientDeviceTwinHandle, deviceId)) == NULL)
{
(void)printf("IoTHubDeviceTwin_GetTwin failed\r\n");
}
else
{
(void)printf("\r\nDeviceTwin:\r\n");
printf("%s\r\n", deviceTwinJson);
const char* updateJson = "{\"properties\":{\"desired\":{\"telemetryInterval\":30}}}";
char* updatedDeviceTwinJson;
if ((updatedDeviceTwinJson = IoTHubDeviceTwin_UpdateTwin(serviceClientDeviceTwinHandle, deviceId, updateJson)) == NULL)
{
(void)printf("IoTHubDeviceTwin_UpdateTwin failed\r\n");
}
else
{
(void)printf("\r\nDeviceTwin has been successfully updated (partial update):\r\n");
printf("%s\r\n", updatedDeviceTwinJson);
free(updatedDeviceTwinJson);
}
free(deviceTwinJson);
}
IoTHubDeviceTwin_Destroy(serviceClientDeviceTwinHandle);
}
IoTHubServiceClientAuth_Destroy(iotHubServiceClientHandle);
}
}
void iothub_messaging_ll_sample_run(void)
{
xlogging_set_log_function(consolelogger_log);
if (platform_init() != 0)
{
(void)printf("Failed to initialize the platform.\r\n");
}
else
{
(void)printf("Calling IoTHubServiceClientAuth_CreateFromConnectionString with connection string\n");
iotHubServiceClientHandle = IoTHubServiceClientAuth_CreateFromConnectionString(connectionString);
if (iotHubServiceClientHandle == NULL)
{
(void)printf("IoTHubServiceClientAuth_CreateFromConnectionString failed\n");
}
else
{
(void)printf("Service Client Authentication handle has been created successfully\n");
(void)printf("Creating Messaging...\n");
iotHubMessagingHandle = IoTHubMessaging_LL_Create(iotHubServiceClientHandle);
if (iotHubMessagingHandle == NULL)
{
(void)printf("IoTHubMessaging_LL_Create failed\n");
}
else
{
(void)printf("Messaging has been created successfully\n");
(void)printf("Opening Messaging...\n");
iotHubMessagingResult = IoTHubMessaging_LL_SetFeedbackMessageCallback(iotHubMessagingHandle, feedbackReceivedCallback, "Context string for feedback");
if (iotHubMessagingResult != IOTHUB_MESSAGING_OK)
{
(void)printf("IoTHubMessaging_LL_SetFeedbackMessageCallback failed\n");
}
else
{
iotHubMessagingResult = IoTHubMessaging_LL_Open(iotHubMessagingHandle, openCompleteCallback, "Context string for open");
if (iotHubMessagingResult != IOTHUB_MESSAGING_OK)
{
(void)printf("IoTHubMessaging_LL_Open failed\n");
}
else
{
for (int i = 0; i < MESSAGE_COUNT; i++)
{
double avgWindSpeed = 10.0;
static char msgText[1024];
sprintf_s(msgText, sizeof(msgText), "{\"deviceId\":%s,\"windSpeed\":%.2f, \"i\":%d}", deviceId, avgWindSpeed + (rand() % 4 + 2), i);
IOTHUB_MESSAGE_HANDLE messageHandle = IoTHubMessage_CreateFromByteArray((const unsigned char*)msgText, strlen(msgText));
if (messageHandle == NULL)
{
(void)printf("IoTHubMessage_CreateFromByteArray failed\n");
break;
}
else
{
IOTHUB_MESSAGE_RESULT iotHubMessageResult;
const char* MSG_ID = "Sample_MessageId";
const char* MSG_CORRELATION_ID = "Sample_MessageCorrelationId";
const char* MSG_PROP_KEYS[3] = { "Sample_Key1", "Sample_Key2", "Sample_Key3" };
const char* MSG_PROP_VALS[3] = { "Sample_Val1", "Sample_Val2", "Sample_Val3" };
iotHubMessageResult = IoTHubMessage_SetMessageId(messageHandle, MSG_ID);
if (iotHubMessageResult != IOTHUB_MESSAGE_OK)
{
(void)printf("IoTHubMessage_SetMessageId failed. Exiting...\n");
IoTHubMessage_Destroy(messageHandle);
break;
}
else
{
iotHubMessageResult = IoTHubMessage_SetCorrelationId(messageHandle, MSG_CORRELATION_ID);
if (iotHubMessageResult != IOTHUB_MESSAGE_OK)
{
(void)printf("IoTHubMessage_SetCorrelationId failed. Exiting...\n");
IoTHubMessage_Destroy(messageHandle);
break;
}
else
{
MAP_HANDLE mapHandle = IoTHubMessage_Properties(messageHandle);
for (size_t j = 0; j < 3; j++)
{
if (Map_AddOrUpdate(mapHandle, MSG_PROP_KEYS[j], MSG_PROP_VALS[j]) != MAP_OK)
{
(void)printf("ERROR: Map_AddOrUpdate failed for property %zu!\r\n", j);
}
}
iotHubMessagingResult = IoTHubMessaging_LL_Send(iotHubMessagingHandle, deviceId, messageHandle, sendCompleteCallback, NULL);
if (iotHubMessagingResult != IOTHUB_MESSAGING_OK)
{
(void)printf("IoTHubMessaging_LL_Send failed\n");
}
else
{
(void)printf("IoTHubMessaging_LL_Send accepted data for transmission to IoT Hub.\r\n");
}
}
}
}
IoTHubMessage_Destroy(messageHandle);
}
feedbackCount = 0;
while (feedbackCount < MESSAGE_COUNT)
{
IoTHubMessaging_LL_DoWork(iotHubMessagingHandle);
ThreadAPI_Sleep(1);
}
/* Wait for user to press a key. */
(void)printf("Press any key to exit the application. \r\n");
(void)getchar();
IoTHubMessaging_LL_Close(iotHubMessagingHandle);
}
}
(void)printf("Calling IoTHubMessaging_LL_Destroy...\n");
IoTHubMessaging_LL_Destroy(iotHubMessagingHandle);
}
(void)printf("Calling IoTHubServiceClientAuth_Destroy...\n");
IoTHubServiceClientAuth_Destroy(iotHubServiceClientHandle);
}
platform_deinit();
}
}
