Пример #1
0
IOTHUB_MESSAGING_CLIENT_HANDLE IoTHubMessaging_Create(IOTHUB_SERVICE_CLIENT_AUTH_HANDLE serviceClientHandle)
{
    IOTHUB_MESSAGING_CLIENT_INSTANCE* result;

    /*Codes_SRS_IOTHUBMESSAGING_12_001: [ IoTHubMessaging_Create shall verify the serviceClientHandle input parameter and if it is NULL then return NULL. ]*/
    if (serviceClientHandle == NULL)
    {
        LogError("serviceClientHandle input parameter cannot be NULL");
        result = NULL;
    }
    else
    {
        /*Codes_SRS_IOTHUBMESSAGING_12_002: [ IoTHubMessaging_Create shall allocate a new IoTHubMessagingClient instance. ]*/
        if ((result = (IOTHUB_MESSAGING_CLIENT_INSTANCE*)malloc(sizeof(IOTHUB_MESSAGING_CLIENT_INSTANCE))) == NULL)
        {
            /*Codes_SRS_IOTHUBMESSAGING_12_003: [If allocating memory for the new IoTHubMessagingClient instance fails, then IoTHubMessaging_Create shall return NULL. ]*/
            LogError("malloc failed for IoTHubMessagingClient");
            result = NULL;
        }
        else
        {
            /*Codes_SRS_IOTHUBMESSAGING_12_004: [IoTHubMessaging_Create shall create a lock object to be used later for serializing IoTHubMessagingClient calls. ]*/
            result->LockHandle = Lock_Init();
            if (result->LockHandle == NULL)
            {
                /*Codes_SRS_IOTHUBMESSAGING_12_005: [If creating the lock fails, then IoTHubMessaging_Create shall return NULL. ]*/
                /*Codes_SRS_IOTHUBMESSAGING_12_008: [If IoTHubMessaging_Create fails, all resources allocated by it shall be freed. ]*/
                LogError("Lock_Init failed");
                free(result);
                result = NULL;
            }
            else
            {
                /*Codes_SRS_IOTHUBMESSAGING_12_006: [IoTHubMessaging_Create shall instantiate a new IoTHubMessaging_LL instance by calling IoTHubMessaging_LL_Create and passing the serviceClientHandle argument. ]*/
                result->IoTHubMessagingHandle = IoTHubMessaging_LL_Create(serviceClientHandle);
                if (result->IoTHubMessagingHandle == NULL)
                {
                    /*Codes_SRS_IOTHUBMESSAGING_12_007: [ If IoTHubMessaging_LL_Create fails, then IoTHubMessaging_Create shall return NULL. ]*/
                    /*Codes_SRS_IOTHUBMESSAGING_12_008: [If IoTHubMessaging_Create fails, all resources allocated by it shall be freed. ]*/
                    LogError("IoTHubMessaging_LL_Create failed");
                    Lock_Deinit(result->LockHandle);
                    free(result);
                    result = NULL;
                }
                else
                {
                    result->StopThread = 0;
                    result->ThreadHandle = NULL;
                }
            }
        }
    }
    return (IOTHUB_MESSAGING_CLIENT_HANDLE)result;
}
Пример #2
0
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();
    }
}
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();
    }
}