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(); } }