Reorganize solution structure.

Source/MQTTnet.Extensions.Rpc/MQTTnet.Extensions.Rpc.csproj

@@ -0,0 +1,31 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFrameworks>netstandard1.3;netstandard2.0;net452;net461;uap10.0</TargetFrameworks>
+    <AssemblyVersion>0.0.0.0</AssemblyVersion>
+    <FileVersion>0.0.0.0</FileVersion>
+    <Product />
+    <Company />
+    <Authors />
+    <PackageId />
+    <Version>0.0.0.0</Version>
+  </PropertyGroup>
+
+  <PropertyGroup Condition="'$(TargetFramework)' == 'uap10.0'">
+    <CopyLocalLockFileAssemblies>false</CopyLocalLockFileAssemblies>
+    <NugetTargetMoniker>UAP,Version=v10.0</NugetTargetMoniker>
+    <TargetPlatformIdentifier>UAP</TargetPlatformIdentifier>
+    <TargetPlatformVersion>10.0.17134.0</TargetPlatformVersion>
+    <TargetPlatformMinVersion>10.0.10240.0</TargetPlatformMinVersion>
+    <TargetFrameworkIdentifier>.NETCore</TargetFrameworkIdentifier>
+    <TargetFrameworkVersion>v5.0</TargetFrameworkVersion>
+    <DefineConstants>$(DefineConstants);WINDOWS_UWP</DefineConstants>
+    <DefaultLanguage>en</DefaultLanguage>
+    <LanguageTargets>$(MSBuildExtensionsPath)\Microsoft\WindowsXaml\v$(VisualStudioVersion)\Microsoft.Windows.UI.Xaml.CSharp.targets</LanguageTargets>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\MQTTnet\MQTTnet.csproj" />
+  </ItemGroup>
+
+</Project>

Source/MQTTnet.Extensions.Rpc/MqttRpcClient.cs

@@ -0,0 +1,130 @@
+using System;
+using System.Collections.Concurrent;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using MQTTnet.Client;
+using MQTTnet.Exceptions;
+using MQTTnet.Protocol;
+
+namespace MQTTnet.Extensions.Rpc
+{
+    public class MqttRpcClient : IDisposable
+    {
+        private readonly ConcurrentDictionary<string, TaskCompletionSource<byte[]>> _waitingCalls = new ConcurrentDictionary<string, TaskCompletionSource<byte[]>>();
+        private readonly IMqttClient _mqttClient;
+
+        public MqttRpcClient(IMqttClient mqttClient)
+        {
+            _mqttClient = mqttClient ?? throw new ArgumentNullException(nameof(mqttClient));
+
+            _mqttClient.ApplicationMessageReceived += OnApplicationMessageReceived;
+        }
+
+        public Task<byte[]> ExecuteAsync(TimeSpan timeout, string methodName, string payload, MqttQualityOfServiceLevel qualityOfServiceLevel)
+        {
+            return ExecuteAsync(timeout, methodName, Encoding.UTF8.GetBytes(payload), qualityOfServiceLevel, CancellationToken.None);
+        }
+
+        public Task<byte[]> ExecuteAsync(TimeSpan timeout, string methodName, string payload, MqttQualityOfServiceLevel qualityOfServiceLevel, CancellationToken cancellationToken)
+        {
+            return ExecuteAsync(timeout, methodName, Encoding.UTF8.GetBytes(payload), qualityOfServiceLevel, cancellationToken);
+        }
+
+        public Task<byte[]> ExecuteAsync(TimeSpan timeout, string methodName, byte[] payload, MqttQualityOfServiceLevel qualityOfServiceLevel)
+        {
+            return ExecuteAsync(timeout, methodName, payload, qualityOfServiceLevel, CancellationToken.None);
+        }
+
+        public async Task<byte[]> ExecuteAsync(TimeSpan timeout, string methodName, byte[] payload, MqttQualityOfServiceLevel qualityOfServiceLevel, CancellationToken cancellationToken)
+        {
+            if (methodName == null) throw new ArgumentNullException(nameof(methodName));
+
+            if (methodName.Contains("/") || methodName.Contains("+") || methodName.Contains("#"))
+            {
+                throw new ArgumentException("The method name cannot contain /, + or #.");
+            }
+
+            var requestTopic = $"MQTTnet.RPC/{Guid.NewGuid():N}/{methodName}";
+            var responseTopic = requestTopic + "/response";
+
+            var requestMessage = new MqttApplicationMessageBuilder()
+                .WithTopic(requestTopic)
+                .WithPayload(payload)
+                .WithQualityOfServiceLevel(qualityOfServiceLevel)
+                .Build();
+
+            try
+            {
+                var tcs = new TaskCompletionSource<byte[]>();
+                if (!_waitingCalls.TryAdd(responseTopic, tcs))
+                {
+                    throw new InvalidOperationException();
+                }
+
+                await _mqttClient.SubscribeAsync(responseTopic, qualityOfServiceLevel).ConfigureAwait(false);
+                await _mqttClient.PublishAsync(requestMessage).ConfigureAwait(false);
+                
+                using (var timeoutCts = new CancellationTokenSource(timeout))
+                using (var linkedCts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, timeoutCts.Token))
+                {
+                    linkedCts.Token.Register(() =>
+                    {
+                        if (!tcs.Task.IsCompleted && !tcs.Task.IsFaulted && !tcs.Task.IsCanceled)
+                        {
+                            tcs.TrySetCanceled();
+                        }
+                    });
+
+                    try
+                    {
+                        var result = await tcs.Task.ConfigureAwait(false);
+                        timeoutCts.Cancel(false);
+                        return result;
+                    }
+                    catch (TaskCanceledException taskCanceledException)
+                    {
+                        if (timeoutCts.IsCancellationRequested && !cancellationToken.IsCancellationRequested)
+                        {
+                            throw new MqttCommunicationTimedOutException(taskCanceledException);
+                        }
+                        else
+                        {
+                            throw;
+                        }
+                    }
+                }
+            }
+            finally
+            {
+                _waitingCalls.TryRemove(responseTopic, out _);
+                await _mqttClient.UnsubscribeAsync(responseTopic).ConfigureAwait(false);
+            }
+        }
+
+        private void OnApplicationMessageReceived(object sender, MqttApplicationMessageReceivedEventArgs eventArgs)
+        {
+            if (!_waitingCalls.TryRemove(eventArgs.ApplicationMessage.Topic, out var tcs))
+            {
+                return;
+            }
+
+            if (tcs.Task.IsCompleted || tcs.Task.IsCanceled)
+            {
+                return;
+            }
+
+            tcs.TrySetResult(eventArgs.ApplicationMessage.Payload);
+        }
+
+        public void Dispose()
+        {
+            foreach (var tcs in _waitingCalls)
+            {
+                tcs.Value.SetCanceled();
+            }
+
+            _waitingCalls.Clear();
+        }
+    }
+}

Source/MQTTnet.Extensions.Rpc/SampleCCode.c

@@ -0,0 +1,29 @@
+// If using the MQTT client PubSubClient it must be ensured  that the request topic for each method is subscribed like the following.
+_mqttClient.subscribe("MQTTnet.RPC/+/ping");
+_mqttClient.subscribe("MQTTnet.RPC/+/do_something");
+
+// It is not allowed to change the structure of the topic. Otherwise RPC will not work. So method names can be separated using
+// an _ or . but no +, # or . If it is required to distinguish between devices own rules can be defined like the following.
+_mqttClient.subscribe("MQTTnet.RPC/+/deviceA.ping");
+_mqttClient.subscribe("MQTTnet.RPC/+/deviceB.ping");
+_mqttClient.subscribe("MQTTnet.RPC/+/deviceC.getTemperature");
+
+// Within the callback of the MQTT client the topic must be checked if it belongs to MQTTnet RPC. The following code shows one
+// possible way of doing this.
+void mqtt_Callback(char *topic, byte *payload, unsigned int payloadLength)
+{
+	String topicString = String(topic);
+
+	if (topicString.startsWith("MQTTnet.RPC/")) {
+		String responseTopic = topicString + String("/response");
+
+		if (topicString.endsWith("/deviceA.ping")) {
+			mqtt_publish(responseTopic, "pong", false);
+			return;
+		}
+	}
+}
+
+// Important notes:
+// ! Do not send response message with the _retain_ flag set to true.
+// ! All required data for a RPC call and the result must be placed into the payload.