Mon Tutoriel de la voiture connectée Azure Sphere – Partie 3

/// <summary>
///     Callback invoked when a Direct Method is received from Azure IoT Hub.
/// </summary>
static int DeviceMethodCallback(const char *methodName, const unsigned char *payload,
                                size_t payloadSize, unsigned char **response, size_t *responseSize,
                                void *userContextCallback)
{
    // All methods are ignored
    int result = 0;
    char *responseString = "{\"result\":\"OK\"}";

    Log_Debug("Received Device Method callback: Method name %s.\n", methodName);

    // if 'response' is non-NULL, the Azure IoT library frees it after use, so copy it to heap
    *responseSize = strlen(responseString);
    *response = malloc(*responseSize);
    memcpy(*response, responseString, *responseSize);

    if (strcmp(methodName, "GoForward") == 0)
    {
        JoyitCar_GoForward();
    }
    else if (strcmp(methodName, "GoBackward") == 0)
    {
        JoyitCar_GoBackward();
    }
    else if (strcmp(methodName, "Break") == 0)
    {
        JoyitCar_Break();
    }
    else if (strcmp(methodName, "TurnRight") == 0)
    {
        JoyitCar_TurnRight();
    }
    else if (strcmp(methodName, "TurnLeft") == 0)
    {
        JoyitCar_TurnLeft();
    }
    else if (strcmp(methodName, "StartDemo") == 0)
    {
        JoyitCar_StartDemo();
    }
    else
    {
        responseString = "{\"result\":\"NotFound\"}";
        result = -1;
    }

    return result;
}

    IoTHubDeviceClient_LL_SetDeviceMethodCallback(iothubClientHandle, DeviceMethodCallback, NULL);

        private static void ConfigureServices(HostBuilderContext context, IServiceCollection services)
        {
            var ioTHubConnectionString = context.Configuration.GetValue<string>("IoTHubConnectionString");

            services.AddScoped<VehicleService>();
            
            services.AddSingleton(sp => ServiceClient.CreateFromConnectionString(ioTHubConnectionString));
            services.AddSingleton(sp => RegistryManager.CreateFromConnectionString(ioTHubConnectionString));
        }

   public class VehicleService
    {
        private readonly IConfiguration configuration;

        private readonly RegistryManager registryManager;

        private readonly ServiceClient serviceClient;

        private Device device;

        public VehicleService(IConfiguration configuration, RegistryManager registryManager, ServiceClient serviceClient)
        {
            this.configuration = configuration;
            this.registryManager = registryManager;
            this.serviceClient = serviceClient;
        }

        private void EnsureIsConnected()
        {
            if (device == null)
            {
                throw new InvalidProgramException("Service not initialized. Please call ConnectToDeviceAsync method before!");

            }

            if (device.ConnectionState == DeviceConnectionState.Disconnected)
            {
                throw new InvalidOperationException("Device is not connected!");
            }
        }

        public async Task ConnectToDeviceAsync()
        {
            device = await registryManager.GetDeviceAsync(this.configuration.GetValue<string>("DEVICE_ID"));

            if (device == null)
            {
                throw new InvalidOperationException("Device is not present in the registry!");
            }

            if (device.ConnectionState == DeviceConnectionState.Disconnected)
            {
                throw new InvalidOperationException("Device is not connected!");
            }
        }

        public async Task GoForward()
        {
            await this.SendMethod(nameof(GoForward));
        }

        public async Task GoBackward()
        {
            await this.SendMethod(nameof(GoBackward));
        }

        public async Task Break()
        {
            await this.SendMethod(nameof(Break));
        }

        public async Task TurnLeft()
        {
            await this.SendMethod(nameof(TurnLeft));
        }

        public async Task TurnRight()
        {
            await this.SendMethod(nameof(TurnRight));
        }

        private async Task SendMethod(string methodName)
        {
            this.EnsureIsConnected();
            
            var response = await this.serviceClient.InvokeDeviceMethodAsync(
                deviceId: this.device.Id, 
                new CloudToDeviceMethod(methodName));
        }
    }

        [Function("joyit_car_facade")]
        public async Task<HttpResponseData> Run([HttpTrigger(AuthorizationLevel.Function, "post")] HttpRequestData req,
            FunctionContext executionContext)
        {
            ILogger log = executionContext.GetLogger("joyit_car_facade");

            using (var reader = new StreamReader(req.Body))
            {
                var data = await reader.ReadToEndAsync();
                var query = JsonConvert.DeserializeObject<GoogleDialogFlowQuery>(data);

                var dialogResponse = GoogleDialogFlowResponse.FromQuery(query);

                await vehicleService.ConnectToDeviceAsync();

                switch (query.Intent.Name)
                {
                    case "actions.intent.MAIN":
                        break;
                    case "GoForward":
                        await vehicleService.GoForward();
                        break;
                    case "GoBackward":
                        await vehicleService.GoBackward();
                        break;
                    case "TurnLeft":
                        await vehicleService.TurnLeft();
                        break;
                    case "TurnRight":
                        await vehicleService.TurnRight();
                        break;
                    case "Break":
                        await vehicleService.Break();
                        break;
                    default:                
                        var response = req.CreateResponse(HttpStatusCode.NotFound);

                        await response.WriteStringAsync($"Intent {query.Intent.Name} is not handled!");

                        return response;
                }

                dialogResponse.Prompt.FirstSimple = new Simple
                {
                    Speech = "Ok"
                };

                dialogResponse.Prompt.Override = false;

                var httpResponse = req.CreateResponse(HttpStatusCode.OK);
                await httpResponse.WriteAsJsonAsync(dialogResponse);

                return httpResponse;
            }
        }