private void Client_ApplicationMessageReceived(object sender, MqttApplicationMessageReceivedEventArgs e)
{
messageReceivingTopics.Add(e.ApplicationMessage.Topic);
ByteQueue queue = e.ApplicationMessage.Payload;
try
{
switch (e.ApplicationMessage.Topic)
{
case nameof(AllSongsShuffled):
AllSongsShuffled = queue.DequeueSongs();
break;
case nameof(AudioData):
AudioData = queue;
break;
case nameof(CurrentSong):
CurrentSong = queue.DequeueSong();
break;
case nameof(Duration):
Duration = queue.DequeueTimeSpan();
break;
case nameof(Format):
Format = queue.DequeueWaveFormat();
break;
case nameof(IsAllShuffle):
IsAllShuffle = queue.DequeueBool();
break;
case nameof(IsOnlySearch):
IsOnlySearch = queue.DequeueBool();
break;
case nameof(IsSearchShuffle):
IsSearchShuffle = queue.DequeueBool();
break;
case nameof(MediaSources):
MediaSources = queue.DequeueStrings();
break;
case nameof(PlayState):
PlayState = queue.DequeuePlayState();
break;
case nameof(Position):
Position = queue.DequeueTimeSpan();
break;
case nameof(SearchKey):
SearchKey = queue.DequeueString();
break;
case nameof(Volume):
Volume = queue.DequeueFloat();
break;
}
}
catch (Exception exc)
{
try
{
MqttApplicationMessage message = new MqttApplicationMessage()
{
Topic = "Debug",
Payload = Encoding.UTF8.GetBytes(Utils.GetTypeMessageAndStack(exc)),
QualityOfServiceLevel = MqttQualityOfServiceLevel.AtLeastOnce,
Retain = true
};
client.PublishAsync(message);
}
catch { }
}
if (initProps != null && initProps.Contains(e.ApplicationMessage.Topic))
{
lock (initProps)
{
initProps.Remove(e.ApplicationMessage.Topic);
Monitor.Pulse(initProps);
}
}
messageReceivingTopics.Remove(e.ApplicationMessage.Topic);
}
public Task PublishAsync(MqttApplicationMessage applicationMessage)
{
publishedMessages.Add(applicationMessage);
return(Task.CompletedTask);
}
public async Task PublishAsync(string payload)
{
MqttApplicationMessage msg = CreateMqttMessage(payload);
await this.client.PublishAsync(msg);
}
static Task PublishSingleMessage(MqttClient client, MqttApplicationMessage applicationMessage, ref int count)
{
Interlocked.Increment(ref count);
return(Task.Run(() => client.PublishAsync(applicationMessage)));
}
public MqttClientMessageQueueInterceptorContext(string senderClientId, string receiverClientId, MqttApplicationMessage applicationMessage, MqttQualityOfServiceLevel subscriptionQualityOfServiceLevel)
{
SenderClientId = senderClientId;
ReceiverClientId = receiverClientId;
ApplicationMessage = applicationMessage;
SubscriptionQualityOfServiceLevel = subscriptionQualityOfServiceLevel;
}
private MqttApplicationMessageInterceptorContext InterceptApplicationMessage(MqttClientSession sender, MqttApplicationMessage applicationMessage)
{
var interceptor = _options.ApplicationMessageInterceptor;
if (interceptor == null)
{
return(null);
}
var interceptorContext = new MqttApplicationMessageInterceptorContext(sender?.ClientId, applicationMessage);
interceptor(interceptorContext);
return(interceptorContext);
}
public async Task DispatchApplicationMessageAsync(MqttClientSession senderClientSession, MqttApplicationMessage applicationMessage)
{
try
{
applicationMessage = InterceptApplicationMessage(senderClientSession, applicationMessage);
if (applicationMessage == null)
{
return;
}
if (applicationMessage.Retain)
{
await _retainedMessagesManager.HandleMessageAsync(senderClientSession?.ClientId, applicationMessage).ConfigureAwait(false);
}
ApplicationMessageReceivedCallback?.Invoke(senderClientSession?.ClientId, applicationMessage);
}
catch (Exception exception)
{
_logger.Error <MqttClientSessionsManager>(exception, "Error while processing application message");
}
await _semaphore.WaitAsync().ConfigureAwait(false);
try
{
foreach (var clientSession in _sessions.Values)
{
await clientSession.EnqueueApplicationMessageAsync(applicationMessage);
}
}
finally
{
_semaphore.Release();
}
}
async void PublishButton_Clicked(object sender, EventArgs e)
{
var payload = Encoding.UTF8.GetBytes(textEntry.Text);
var message = new MqttApplicationMessage(topic, payload);
await client.PublishAsync(message, MqttQualityOfService.AtMostOnce, false);
}
public ApplicationMessageProcessedEventArgs(MqttApplicationMessage applicationMessage, Exception exception)
{
ApplicationMessage = applicationMessage ?? throw new ArgumentNullException(nameof(applicationMessage));
Exception = exception;
}
public InjectedMqttApplicationMessage(MqttApplicationMessage applicationMessage)
{
ApplicationMessage = applicationMessage ?? throw new ArgumentNullException(nameof(applicationMessage));
}
public async Task <ActionResult> PostMessage(MqttApplicationMessage message)
{
await _mqttServerService.PublishAsync(message);
return(Ok());
}
public async Task DispatchApplicationMessage(string senderId, MqttApplicationMessage applicationMessage)
{
try
{
if (applicationMessage.Retain)
{
await _retainedMessagesManager.UpdateMessage(senderId, applicationMessage).ConfigureAwait(false);
}
var deliveryCount = 0;
List <MqttSession> subscriberSessions;
lock (_sessionsManagementLock)
{
// only subscriber clients are of interest here.
subscriberSessions = _subscriberSessions.ToList();
}
// Calculate application message topic hash once for subscription checks
MqttSubscription.CalculateTopicHash(applicationMessage.Topic, out var topicHash, out _, out _);
foreach (var session in subscriberSessions)
{
var checkSubscriptionsResult = session.SubscriptionsManager.CheckSubscriptions(
applicationMessage.Topic,
topicHash,
applicationMessage.QualityOfServiceLevel,
senderId);
if (!checkSubscriptionsResult.IsSubscribed)
{
continue;
}
var newPublishPacket = _packetFactories.Publish.Create(applicationMessage);
newPublishPacket.QualityOfServiceLevel = checkSubscriptionsResult.QualityOfServiceLevel;
newPublishPacket.SubscriptionIdentifiers = checkSubscriptionsResult.SubscriptionIdentifiers;
if (newPublishPacket.QualityOfServiceLevel > 0)
{
newPublishPacket.PacketIdentifier = session.PacketIdentifierProvider.GetNextPacketIdentifier();
}
if (checkSubscriptionsResult.RetainAsPublished)
{
// Transfer the original retain state from the publisher. This is a MQTTv5 feature.
newPublishPacket.Retain = applicationMessage.Retain;
}
else
{
newPublishPacket.Retain = false;
}
session.EnqueuePacket(new MqttPacketBusItem(newPublishPacket));
deliveryCount++;
_logger.Verbose("Client '{0}': Queued PUBLISH packet with topic '{1}'.", session.Id, applicationMessage.Topic);
}
await FireApplicationMessageNotConsumedEvent(applicationMessage, deliveryCount, senderId);
}
catch (Exception exception)
{
_logger.Error(exception, "Unhandled exception while processing next queued application message.");
}
}
public static (string Name, string Sensor) ToTopic(this MqttApplicationMessage message)
{
var topic = message.Topic.Split('/');
return(topic[(int)Topic.Name], topic[(int)Topic.Sensor]);
}
public HildebrandState(MqttApplicationMessage message)
{
Topic = message.Topic;
Json = message.ConvertPayloadToString();
}
private async Task Publish(MqttApplicationMessage message)
{
await _serverEx.PublishAsync(message);
_logger.Log(LogLevel.Trace, $"Published MQTT topic '{message.Topic}.");
}
public async Task <MqttClient> ConnectTestClient(IMqttServer server, string clientId, MqttApplicationMessage willMessage = null)
{
var adapterA = new TestMqttCommunicationAdapter();
var adapterB = new TestMqttCommunicationAdapter();
adapterA.Partner = adapterB;
adapterB.Partner = adapterA;
var client = new MqttClient(new MqttCommunicationAdapterFactory(adapterA));
var connected = WaitForClientToConnect(server, clientId);
FireClientAcceptedEvent(adapterB);
await client.ConnectAsync(new MqttClientTcpOptions { ClientId = clientId, WillMessage = willMessage });
await connected;
return(client);
}
static void Main()
{
Thread publisher = new Thread(async() =>
{
// Setup and start a managed MQTT client.
var options = new ManagedMqttClientOptionsBuilder()
.WithAutoReconnectDelay(TimeSpan.FromSeconds(5))
.WithClientOptions(new MqttClientOptionsBuilder()
.WithClientId("Source")
.WithTcpServer("127.0.0.1")
.Build())
.Build();
var factory = new MqttFactory();
var mqttPublisherClient = factory.CreateManagedMqttClient(new MqttNetLogger("MyCustomID"));
MqttNetGlobalLogger.LogMessagePublished += (s, e) =>
{
var trace = $">> [{e.TraceMessage.Timestamp:O}] [{e.TraceMessage.ThreadId}] [{e.TraceMessage.Source}] [{e.TraceMessage.Level}]: {e.TraceMessage.Message}";
if (e.TraceMessage.Exception != null)
{
trace += Environment.NewLine + e.TraceMessage.Exception.ToString();
}
Debug.WriteLine('\x2' + trace);
};
await mqttPublisherClient.StartAsync(options);
Console.WriteLine("Source started\n");
while (true)
{
Console.WriteLine("Press 'P' to publish, 'X' to exit.");
var c = Console.ReadKey().KeyChar;
Console.WriteLine();
if (c == 'P' || c == 'p')
{
for (int i = 0; i < 10; ++i)
{
// 2018-03-18 KSM moving the message creation into the for-loop eliminates the need to
// have a delay inthe loop
var msg = new MqttApplicationMessage
{
Topic = $"source/property/i{i}",
QualityOfServiceLevel = MqttQualityOfServiceLevel.ExactlyOnce,
Retain = true,
Payload = new byte[] { 30 }
};
await mqttPublisherClient.PublishAsync(msg);
Console.WriteLine($"Published topic: {msg.Topic}");
//2018-03-18 KSM delay no longer needed when a new message within the above for-loop
//***************************************************************
//adjust this value to stop published messages from being dropped
//Thread.Sleep(0);
//***************************************************************
}
}
else if (c == 'X' || c == 'x')
{
break;
}
}
await mqttPublisherClient.StopAsync();
});
publisher.Start();
}
//----------------------------------------------------------
private async void SendMqttMessage(string mensageMqtt, strint topicoMQTT)
{
var message1 = new MqttApplicationMessage(topicoMQTT, Encoding.UTF8.GetBytes(mensageMqtt));
await client.PublishAsync(message1, MqttQualityOfService.AtMostOnce); //QoS0
}
public MqttConnectionValidatorContext(string clientId, string username, string password, MqttApplicationMessage willMessage, string endpoint)
{
ClientId = clientId;
Username = username;
Password = password;
WillMessage = willMessage;
Endpoint = endpoint;
}
private void OnMessageReceived(MqttApplicationMessage msg)
{
MessageReceived?.Invoke(msg);
}
private MqttApplicationMessage InterceptApplicationMessage(MqttClientSession senderClientSession, MqttApplicationMessage applicationMessage)
{
if (_options.ApplicationMessageInterceptor == null)
{
return(applicationMessage);
}
var interceptorContext = new MqttApplicationMessageInterceptorContext(
senderClientSession.ClientId,
applicationMessage);
_options.ApplicationMessageInterceptor(interceptorContext);
return(interceptorContext.ApplicationMessage);
}
public async Task PublishAsync(MqttApplicationMessage message, MqttQualityOfService qos)
{
await _mqttClient.PublishAsync(message, qos);
}
public static void Handler(MqttApplicationMessage message)
{
Console.WriteLine(message.Topic);
}
public async Task SafeNotifyApplicationMessageReceivedAsync(string senderClientId, MqttApplicationMessage applicationMessage)
{
try
{
var handler = ApplicationMessageReceivedHandler;
if (handler == null)
{
return;
}
await handler.HandleApplicationMessageReceivedAsync(new MqttApplicationMessageReceivedEventArgs(senderClientId, applicationMessage)).ConfigureAwait(false);;
}
catch (Exception exception)
{
_logger.Error(exception, "Error while handling custom 'ApplicationMessageReceived' event.");
}
}
public Messages(string instanceId, string version)
{
if (string.IsNullOrEmpty(instanceId))
{
throw new System.ArgumentException($"'{nameof(instanceId)}' cannot be null or empty.", nameof(instanceId));
}
if (string.IsNullOrEmpty(version))
{
throw new System.ArgumentException($"'{nameof(version)}' cannot be null or empty.", nameof(version));
}
ServiceCommandTopic = $"homeassistant/switch/nvs_occupancy_sensor/{instanceId}/set";
object device = new {
identifiers = new [] { $"id_{instanceId}_device" },
name = "NVs Occupancy Sensor",
sw_version = version,
model = "DYI Optical Occupancy Sensor",
manufacturer = "nvsnkv"
};
Configs = new[]
{
new MqttApplicationMessageBuilder()
.WithTopic($"homeassistant/binary_sensor/nvs_occupancy_sensor/{instanceId}/config")
.WithPayload(JsonConvert.SerializeObject(new
{
name = "Occupancy",
device_class = "occupancy",
state_topic = $"homeassistant/binary_sensor/nvs_occupancy_sensor/{instanceId}/state",
availability_topic = $"homeassistant/binary_sensor/nvs_occupancy_sensor/{instanceId}/availability",
unique_id = $"id_{instanceId}_sensor",
device
}))
.WithQualityOfServiceLevel(MqttQualityOfServiceLevel.AtLeastOnce)
.Build(),
new MqttApplicationMessageBuilder()
.WithTopic($"homeassistant/switch/nvs_occupancy_sensor/{instanceId}/config")
.WithPayload(JsonConvert.SerializeObject(new
{
name = "Service",
state_topic = $"homeassistant/switch/nvs_occupancy_sensor/{instanceId}/state",
command_topic = ServiceCommandTopic,
availability_topic = $"homeassistant/switch/nvs_occupancy_sensor/{instanceId}/availability",
payload_off = "OFF",
payload_on = "ON",
unique_id = $"id_{instanceId}_service",
device
}))
.WithQualityOfServiceLevel(MqttQualityOfServiceLevel.AtLeastOnce)
.Build()
};
ServiceAvailable = new MqttApplicationMessageBuilder()
.WithTopic($"homeassistant/switch/nvs_occupancy_sensor/{instanceId}/availability")
.WithPayload("online")
.Build();
ServiceUnavailable = new MqttApplicationMessageBuilder()
.WithTopic($"homeassistant/switch/nvs_occupancy_sensor/{instanceId}/availability")
.WithPayload("offline")
.Build();
SensorAvailable = new MqttApplicationMessageBuilder()
.WithTopic($"homeassistant/binary_sensor/nvs_occupancy_sensor/{instanceId}/availability")
.WithPayload("online")
.Build();
SensorUnavailable = new MqttApplicationMessageBuilder()
.WithTopic($"homeassistant/binary_sensor/nvs_occupancy_sensor/{instanceId}/availability")
.WithPayload("offline")
.Build();
ServiceEnabled = new MqttApplicationMessageBuilder()
.WithTopic($"homeassistant/switch/nvs_occupancy_sensor/{instanceId}/state")
.WithPayload("ON")
.Build();
ServiceDisabled = new MqttApplicationMessageBuilder()
.WithTopic($"homeassistant/switch/nvs_occupancy_sensor/{instanceId}/state")
.WithPayload("OFF")
.Build();
PresenceDetected = new MqttApplicationMessageBuilder()
.WithTopic($"homeassistant/binary_sensor/nvs_occupancy_sensor/{instanceId}/state")
.WithPayload("ON")
.Build();
NoPresenceDetected = new MqttApplicationMessageBuilder()
.WithTopic($"homeassistant/binary_sensor/nvs_occupancy_sensor/{instanceId}/state")
.WithPayload("OFF")
.Build();
}
async Task <MqttClientAuthenticateResult> AuthenticateAsync(IMqttChannelAdapter channelAdapter, MqttApplicationMessage willApplicationMessage, CancellationToken cancellationToken)
{
var connectPacket = channelAdapter.PacketFormatterAdapter.DataConverter.CreateConnectPacket(
willApplicationMessage,
Options);
var connAckPacket = await SendAndReceiveAsync <MqttConnAckPacket>(connectPacket, cancellationToken).ConfigureAwait(false);
var result = channelAdapter.PacketFormatterAdapter.DataConverter.CreateClientConnectResult(connAckPacket);
if (result.ResultCode != MqttClientConnectResultCode.Success)
{
throw new MqttConnectingFailedException(result);
}
_logger.Verbose("Authenticated MQTT connection with server established.");
return(result);
}
public MqttClientOptionsBuilder WithWillMessage(MqttApplicationMessage value)
{
_options.WillMessage = value;
return(this);
}
public static Task <MqttClientPublishResult> PublishAsync(this IMqttServer server, MqttApplicationMessage applicationMessage)
{
if (server == null)
{
throw new ArgumentNullException(nameof(server));
}
if (applicationMessage == null)
{
throw new ArgumentNullException(nameof(applicationMessage));
}
return(server.PublishAsync(applicationMessage, CancellationToken.None));
}
private Task SendMessageAsync(MqttApplicationMessage message, CancellationToken cancellationToken)
{
return(Client.PublishAsync(message, cancellationToken));
}
private void OnApplicationMessageReceived(string clientId, MqttApplicationMessage applicationMessage)
{
ApplicationMessageReceived?.Invoke(this, new MqttApplicationMessageReceivedEventArgs(clientId, applicationMessage));
}
