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