public async Task CallAlert(SensorType type)
{
_logger.LogWarning("入侵报警计划任务");
if (_lightHelper != null && _mqttHelper != null)
{
if (_lightHelper.CurrentStateMode == StateMode.Out)
{
_logger.LogWarning("入侵报警执行中...");
MqttApplicationMessage message;
switch (type)
{
case SensorType.Door:
message = new MqttApplicationMessageBuilder()
.WithTopic("Home/Sensor/Door")
.WithPayload("1")
.WithAtLeastOnceQoS()
.Build();
await _mqttHelper.Publish(message);
_notify.Send("门道");
break;
case SensorType.Aisle:
message = new MqttApplicationMessageBuilder()
.WithTopic("Home/Sensor/Aisle")
.WithPayload("1")
.WithAtLeastOnceQoS()
.Build();
await _mqttHelper.Publish(message);
_notify.Send("走道");
break;
default:
break;
}
}
_logger.LogWarning("入侵报警取消...");
}
}
private void StartPolling()
{
var cancellableDisposable = new CancellationDisposable();
_devicePolling.Disposable = cancellableDisposable;
var ct = cancellableDisposable.Token;
var t = PollingTask(); // start it
async Task PollingTask()
{
var settings = _settings.CurrentSettings;
long count = 0;
await Task.Delay(5000, ct);
while (!ct.IsCancellationRequested)
{
var msg = new MqttApplicationMessageBuilder()
.WithTopic($"{settings.BaseTopic}/bridge/config/devices/get")
.Build();
await _client.PublishAsync(msg);
if (count % 3 == 0)
{
var msg2 = new MqttApplicationMessageBuilder()
.WithTopic($"{settings.BaseTopic}/bridge/networkmap")
.WithPayload("raw")
.Build();
await _client.PublishAsync(msg2);
}
await Task.Delay(TimeSpan.FromMinutes(5), ct);
}
}
}
public async void Publish(string topic, string payload)
{
if (!mqttClient.IsConnected)
{
try
{
await Connect();
}
catch (TaskCanceledException) {; }
}
MqttApplicationMessage message = new MqttApplicationMessageBuilder()
.WithTopic(topic)
.WithPayload(payload)
.WithQualityOfServiceLevel(MQTTnet.Protocol.MqttQualityOfServiceLevel.AtLeastOnce)
.WithRetainFlag(false)
.Build();
await mqttClient.PublishAsync(message, CancellationToken.None);
}
public async Task <TResponse> Request <TRequest, TResponse>(TRequest message, string endpoint)
where TRequest : class, IMessage
where TResponse : class
{
Topic topic = new Topic
{
MessageId = Guid.NewGuid(),
MessageBodyType = message.GetType().FullName,
MessageType = MessageTypes.Command,
SourceClientId = _mqttClient.Options.ClientId,
SourceEndpoint = _options.Endpoint,
TargetClientId = "*",
TargetEndpoint = endpoint
};
var payload = new MqttApplicationMessageBuilder()
.WithPayload(JsonConvert.SerializeObject(message))
.WithAtMostOnceQoS()
.WithTopic(topic.ToString());
await _mqttClient.PublishAsync(payload.Build());
Waiter theWaiter = new Waiter {
Sp = new Semaphore(0, 1)
};
RequestWaiter.WaitingDic[topic.MessageId] = theWaiter;
bool success = theWaiter.Sp.WaitOne(TimeSpan.FromSeconds(_options.SendMessageTimeout));
RequestWaiter.WaitingDic.TryRemove(topic.MessageId, out _);
if (!success)
{
throw new TimeoutException("请求超时");
}
return(JsonConvert.DeserializeObject <TResponse>(theWaiter.ResponseJson));
}
public MainPage()
{
InitializeComponent();
MasterBehavior = MasterBehavior.Popover;
MenuPages.Add((int)MenuItemType.Browse, (NavigationPage)Detail);
MQTTSetup();
MessagingCenter.Subscribe <ItemsPage, Item>(this, "selected", async(obj, item) =>
{
var newItem = item as Item;
var message = new MqttApplicationMessageBuilder()
.WithTopic("my/item")
.WithPayload(item.Text)
.WithExactlyOnceQoS()
.WithRetainFlag()
.Build();
await _mqttClient.PublishAsync(message);
});
}
private void PublishSingleValues_UpdateItem(
AasEventMsgEnvelope ev,
AdminShell.ReferableRootInfo ri,
AdminShell.KeyList startPath,
AasPayloadUpdateValueItem ui)
{
// trivial
if (ev == null || ui == null || startPath == null || ui.Path == null)
{
return;
}
// value of the leaf
var valStr = "" + ui.Value;
// build a complete path of keys
var path = startPath + ui.Path;
var pathStr = path.BuildIdShortPath();
// publish
if (_diaData.LogDebug)
{
_logger?.Info("Publish single value (update value)");
}
var message = new MqttApplicationMessageBuilder()
.WithTopic(GenerateTopic(
_diaData.EventTopic, defaultIfNull: "SingleValue",
aasIdShort: ri?.AAS?.idShort, aasId: ri?.AAS?.identification,
smIdShort: ri?.Submodel?.idShort, smId: ri?.Submodel?.identification,
path: pathStr))
.WithPayload(valStr)
.WithExactlyOnceQoS()
.WithRetainFlag(_diaData.MqttRetain)
.Build();
// publish
_mqttClient.PublishAsync(message).GetAwaiter().GetResult();
LogStatus(incSingleValue: 1);
}
public async Task CustomMqttConfigProviderGetsTriggered()
{
var message = new MqttApplicationMessageBuilder()
.WithTopic("TestTopic/random")
.WithPayload("{ \"test\":\"case\" }")
.WithAtLeastOnceQoS()
.Build();
using (var mqttServer = await MqttServerHelper.Get(_logger))
using (var jobHost = await JobHostHelper <CustomMqttConfigProviderTestFunction> .RunFor(_testLoggerProvider))
{
await mqttServer.PublishAsync(message);
await WaitFor(() => CustomMqttConfigProviderTestFunction.CallCount >= 1);
}
Assert.Equal(1, CustomMqttConfigProviderTestFunction.CallCount);
Assert.Equal("TestTopic/random", CustomMqttConfigProviderTestFunction.LastReceivedMessage.Topic);
var messageBody = Encoding.UTF8.GetString(CustomMqttConfigProviderTestFunction.LastReceivedMessage.GetMessage());
Assert.Equal("{ \"test\":\"case\" }", messageBody);
}
public async Task invioAsync(string sq)
{
var factory = new MqttFactory();
var mqttClient = factory.CreateMqttClient();
var options = new MqttClientOptionsBuilder()
.WithTcpServer("192.168.101.49", 1883) // Port is optional
.Build();
await mqttClient.ConnectAsync(options, CancellationToken.None);
var message = new MqttApplicationMessageBuilder()
.WithTopic("")
.WithPayload(sq)
.WithExactlyOnceQoS()
.WithRetainFlag()
.Build();
await mqttClient.PublishAsync(message);
/*
* HttpWebRequest httpWebRequest = (HttpWebRequest)WebRequest.Create("http://192.168.102.11:8011/tables/AB123");
* httpWebRequest.ContentType = "text/json";
* httpWebRequest.Method = "POST";
*
* using (var streamWriter = new StreamWriter(httpWebRequest.GetRequestStream()))
* {
* streamWriter.Write(sq);
* }
*
* var httpResponse = (HttpWebResponse)httpWebRequest.GetResponse();
*
* Console.Out.WriteLine(httpResponse.StatusCode);
*
* httpResponse.Close();
*
* System.Threading.Thread.Sleep(1000);*/
}
public async Task Publish_From_Server()
{
using (var testEnvironment = new TestEnvironment(TestContext))
{
var server = await testEnvironment.StartServerAsync();
var receivedMessagesCount = 0;
var client = await testEnvironment.ConnectClientAsync();
client.UseApplicationMessageReceivedHandler(c => Interlocked.Increment(ref receivedMessagesCount));
var message = new MqttApplicationMessageBuilder().WithTopic("a").WithAtLeastOnceQoS().Build();
await client.SubscribeAsync(new TopicFilter { Topic = "a", QualityOfServiceLevel = MqttQualityOfServiceLevel.AtLeastOnce });
await server.PublishAsync(message);
await Task.Delay(1000);
Assert.AreEqual(1, receivedMessagesCount);
}
}
public async Task Client_Publish()
{
var server = new MqttFactory().CreateMqttServer();
try
{
var receivedMessages = new List <MqttApplicationMessage>();
await server.StartAsync(new MqttServerOptions());
var client1 = new MqttFactory().CreateMqttClient();
client1.ApplicationMessageReceived += (_, e) =>
{
lock (receivedMessages)
{
receivedMessages.Add(e.ApplicationMessage);
}
};
await client1.ConnectAsync(new MqttClientOptionsBuilder().WithTcpServer("127.0.0.1").Build());
await client1.SubscribeAsync("a");
var client2 = new MqttFactory().CreateMqttClient();
await client2.ConnectAsync(new MqttClientOptionsBuilder().WithTcpServer("127.0.0.1").Build());
var message = new MqttApplicationMessageBuilder().WithTopic("a").WithRetainFlag().Build();
await client2.PublishAsync(message);
await Task.Delay(500);
Assert.AreEqual(1, receivedMessages.Count);
Assert.IsFalse(receivedMessages.First().Retain); // Must be false even if set above!
}
finally
{
await server.StopAsync();
}
}
private async void Btn_pub_Click(object sender, EventArgs e)
{
mqttTopicPub = textBox_pub.Text;
string payload = this.textBox_send.Text;
var message = new MqttApplicationMessageBuilder()
.WithTopic(mqttTopicPub)
.WithPayload(payload)
.WithExactlyOnceQoS()
.Build();
try
{
await mqttClient.PublishAsync(message);
}
catch (Exception err)
{
Invoke((new Action(() =>
{
this.textBox_recv.AppendText(Environment.NewLine + err.ToString());
})));
}
}
// обновление документа
public async Task UpdateFromUIAsync(Client client, Device device)
{
if (device.TypeOfDevice == "Light")
{
if (ConnectSingleton.IsConnected == false)
{
await _mqttClientService.ConnectAsync(client.Id);
await _mqttClientService.SubscribeAsync(device.Topic);
ConnectSingleton.getInstance(true);
}
var messagePayload = new MqttApplicationMessageBuilder()
.WithTopic(device.Topic)
.WithPayload(device.Payload)
.WithExactlyOnceQoS()
.WithRetainFlag()
.Build();
await _mqttClientService.PublishAsync(messagePayload);
}
await Devices.ReplaceOneAsync(new BsonDocument("_id", new ObjectId(device.Id)), device);
}
private void RegisterMqtt(Mqtt_Settings settings)
{
Console.WriteLine($"Sub started in {settings.ClientId}");
var factory = new MqttFactory();
Client = factory.CreateMqttClient();
ClientOptions = new MqttClientOptionsBuilder()
.WithClientId(settings.ClientId)
.WithTcpServer(settings.Host)
.Build();
var PublishOptions = new MqttApplicationMessageBuilder()
.WithTopic("MyTopic")
.WithPayload("Hello World")
.WithExactlyOnceQoS()
.WithRetainFlag()
.Build();
Client.ConnectedHandler = new MqttClientConnectedHandlerDelegate(e => {
Client.SubscribeAsync(new TopicFilterBuilder().WithTopic(settings.SuscribeTopic).Build());
});
}
private void btn_send_Click(object sender, EventArgs e)
{
if (this.mqttclient.IsConnected)
{
for (int i = 0; i < int.Parse(this.nud_sendNum.Value.ToString()); i++)
{
MqttApplicationMessageBuilder builder = new MqttApplicationMessageBuilder();
builder.WithPayload(this.mtb_sendmsg.Text.Trim())
.WithTopic(this.mtb_sendTopic.Text.Trim());
switch (this.cb_sendQos.SelectedText)
{
case "0":
builder.WithAtMostOnceQoS();
break;
case "1":
builder.WithAtLeastOnceQoS();
break;
case "2":
builder.WithExactlyOnceQoS();
break;
}
if (this.nud_sendDelay.Value > 0)
{
Task.Delay(new TimeSpan(0, 0, 0, 0, int.Parse(this.nud_sendDelay.Value.ToString()))).Wait();
}
this.mqttclient.PublishAsync(builder.Build());
insertLog($"topic:{this.mtb_sendTopic.Text.Trim()},value:{this.mtb_sendmsg.Text.Trim()}");
}
}
else
{
MessageBox.Show("当前连接已断开，请连接后重试", "系统提示");
}
}
private async void Button_Offline_Click(object sender, RoutedEventArgs e)
{
var topic = InputPublishTopic.Text;
if (topic.Length > 0)
{
var deviceId = topic.Substring(topic.LastIndexOf("/"));
topic = "tamefire/tf5156/offline" + deviceId;
PrintLog("开始发送离线到:" + topic);
MqttApplicationMessage msg = new MqttApplicationMessageBuilder()
.WithTopic(topic)
.WithPayload(new byte[] { })
.WithQualityOfServiceLevel(MqttQualityOfServiceLevel.ExactlyOnce)
.WithRetainFlag(false)
.Build();
await mqttClient.PublishAsync(msg);
PrintLog("发送离线成功!");
Console.WriteLine("### PUBLISHED ###");
}
}
public async Task Inject_ApplicationMessage_At_Server_Level()
{
using (var testEnvironment = CreateTestEnvironment())
{
var server = await testEnvironment.StartServer();
var receiver = await testEnvironment.ConnectClient();
var messageReceivedHandler = testEnvironment.CreateApplicationMessageHandler(receiver);
await receiver.SubscribeAsync("#");
var injectedApplicationMessage = new MqttApplicationMessageBuilder().WithTopic("InjectedOne").Build();
await server.InjectApplicationMessage(new InjectedMqttApplicationMessage(injectedApplicationMessage));
await LongTestDelay();
Assert.AreEqual(1, messageReceivedHandler.ReceivedEventArgs.Count);
Assert.AreEqual("InjectedOne", messageReceivedHandler.ReceivedEventArgs[0].ApplicationMessage.Topic);
}
}
public async Task SendMessageAsync(string deviceName, string message, int port = 1, bool confirmed = false)
{
var mqttMessage = new MqttApplicationMessageBuilder()
.WithTopic($"{_aplicationName}/devices/{deviceName}/down")
.WithPayload(JsonConvert.SerializeObject(
new Message()
{
confirmed = confirmed,
payload_raw = Convert.ToBase64String(ASCIIEncoding.UTF8.GetBytes(message)),
port = port
}))
.Build();
try
{
await _client.PublishAsync(mqttMessage);
}
catch (Exception)
{
throw;
}
}
/// <summary>
/// Sends the client status to "status/categories/{category}/nodes/{clientId}".
/// </summary>
/// <param name="server">IMqttServer</param>
/// <param name="clientId">string</param>
/// <param name="state">NodeState</param>
/// <returns>Task</returns>
public static Task SendClientStatus(IMqttServer server, string clientId, NodeState state)
{
if (!server.IsStarted)
{
return(Task.CompletedTask);
}
if (clientId.StartsWith("client-") || string.IsNullOrWhiteSpace(clientId) || state == null || state.Category == null)
{
return(Task.CompletedTask);
}
var message = new MqttApplicationMessageBuilder()
.WithTopic($"status/categories/{state.Category}/nodes/{clientId}")
.WithPayload(JsonSerializer.Serialize(state))
.WithExactlyOnceQoS()
.WithRetainFlag()
.Build();
server.PublishAsync(message, CancellationToken.None).GetAwaiter().GetResult();
return(Task.CompletedTask);
}
public async Task SendData(GlobalVars globalVars, ApiResponse apiResponse)
{
var triggers = _monitoringSystem.GetTriggers();
if (globalVars.mqttIsConnect == true)
{
try
{
globalVars.upTime = GetUptime().ToString(@"dd\.hh\:mm\:ss");
var send_data = new MqttApplicationMessageBuilder()
.WithTopic("devices/" + apiResponse.Params.Token + "/data")
.WithPayload("token=" + apiResponse.Params.Token +
"&gpu=" + globalVars.card +
"&temp=" + string.Join(",", ((OHMSensor)triggers[0].Sensor).Sensors) +
"&fan=" + globalVars.fan +
"&start_timestamp=" + globalVars.start_timestamp.ToString() +
"&v=" + apiResponse.Params.Version +
"&load=" + globalVars.load +
"&clock=" + globalVars.clock +
"&mem=" + globalVars.mem +
"&upTime=" + globalVars.upTime)
.WithExactlyOnceQoS()
.WithRetainFlag()
.Build();
await globalVars.client.PublishAsync(send_data);
}
catch (MQTTnet.Exceptions.MqttCommunicationException ex)
{
// MqttConnect();
Debug.WriteLine("Send data MqttCommunicationException: " + ex.Message);
Message("Send data MqttCommunicationException: " + ex.Message, globalVars, apiResponse);
}
catch (Exception ex)
{
Message("Send data Ex: " + ex.Message, globalVars, apiResponse);
}
}
}
public async Task MultipleTriggersReceiveOwnMessages()
{
using (var mqttServer = await MqttServerHelper.Get(_logger))
using (var jobHost = await JobHostHelper <MultipleTriggersTestFunction> .RunFor(_testLoggerProvider))
{
await mqttServer.PublishAsync(DefaultMessage);
var secondMessage = new MqttApplicationMessageBuilder()
.WithTopic("test/topic2")
.WithPayload("{ \"test\":\"case\" }")
.WithAtLeastOnceQoS()
.Build();
await mqttServer.PublishAsync(secondMessage);
await WaitFor(() => MultipleTriggersTestFunction.CallCountFunction1 >= 1 && MultipleTriggersTestFunction.CallCountFunction2 >= 1);
}
Assert.Equal(1, MultipleTriggersTestFunction.CallCountFunction1);
Assert.Equal(1, MultipleTriggersTestFunction.CallCountFunction2);
Assert.Equal("test/topic", MultipleTriggersTestFunction.LastReceivedMessageFunction1.Topic);
Assert.Equal("test/topic2", MultipleTriggersTestFunction.LastReceivedMessageFunction2.Topic);
}
public async Task Subscribe_Lots_In_Multiple_Requests()
{
using (var testEnvironment = new TestEnvironment(TestContext))
{
var receivedMessagesCount = 0;
await testEnvironment.StartServer();
var c1 = await testEnvironment.ConnectClient();
c1.UseApplicationMessageReceivedHandler(c => Interlocked.Increment(ref receivedMessagesCount));
for (var i = 0; i < 500; i++)
{
var so = new MqttClientSubscribeOptionsBuilder()
.WithTopicFilter(i.ToString()).Build();
await c1.SubscribeAsync(so).ConfigureAwait(false);
await Task.Delay(10);
}
var c2 = await testEnvironment.ConnectClient();
var messageBuilder = new MqttApplicationMessageBuilder();
for (var i = 0; i < 500; i++)
{
messageBuilder.WithTopic(i.ToString());
await c2.PublishAsync(messageBuilder.Build()).ConfigureAwait(false);
await Task.Delay(10);
}
SpinWait.SpinUntil(() => receivedMessagesCount == 500, 5000);
Assert.AreEqual(500, receivedMessagesCount);
}
}
public async void PublishAsync()
{
using var mock = AutoMock.GetLoose();
mock.Mock <IManagedMqttClient>();
var rxMqttClinet = mock.Create <RxMqttClient>();
var message = new MqttApplicationMessageBuilder()
.WithTopic("T")
.WithPayload("P")
.WithExactlyOnceQoS()
.Build();
var mangedMessage = new ManagedMqttApplicationMessageBuilder()
.WithApplicationMessage(message)
.Build();
// act
await rxMqttClinet.PublishAsync(mangedMessage);
// test
mock.Mock <IManagedMqttClient>().Verify(x => x.PublishAsync(mangedMessage));
}
public async Task No_Payload()
{
using (var testEnvironment = new TestEnvironment(TestContext))
{
await testEnvironment.StartServer();
var sender = await testEnvironment.ConnectClient();
var receiver = await testEnvironment.ConnectClient();
var message = new MqttApplicationMessageBuilder().WithTopic("A");
await receiver.SubscribeAsync(
new MqttClientSubscribeOptions
{
TopicFilters = new List <MqttTopicFilter> {
new MqttTopicFilter {
Topic = "#"
}
}
},
CancellationToken.None);
MqttApplicationMessage receivedMessage = null;
receiver.ApplicationMessageReceivedAsync += e =>
{
receivedMessage = e.ApplicationMessage;
return(PlatformAbstractionLayer.CompletedTask);
};
await sender.PublishAsync(message.Build(), CancellationToken.None);
await Task.Delay(1000);
Assert.IsNotNull(receivedMessage);
Assert.AreEqual("A", receivedMessage.Topic);
Assert.AreEqual(null, receivedMessage.Payload);
}
}
public async Task Use_User_Properties()
{
using (var testEnvironment = new TestEnvironment(TestContext))
{
await testEnvironment.StartServerAsync();
var sender = await testEnvironment.ConnectClientAsync(new MqttClientOptionsBuilder().WithProtocolVersion(MqttProtocolVersion.V500));
var receiver = await testEnvironment.ConnectClientAsync(new MqttClientOptionsBuilder().WithProtocolVersion(MqttProtocolVersion.V500));
var message = new MqttApplicationMessageBuilder()
.WithTopic("A")
.WithUserProperty("x", "1")
.WithUserProperty("y", "2")
.WithUserProperty("z", "3")
.WithUserProperty("z", "4"); // z is here two times to test list of items
await receiver.SubscribeAsync(new MqttClientSubscribeOptions
{
TopicFilters = new List <TopicFilter>
{
new TopicFilter {
Topic = "#"
}
}
}, CancellationToken.None);
MqttApplicationMessage receivedMessage = null;
receiver.UseApplicationMessageReceivedHandler(e => receivedMessage = e.ApplicationMessage);
await sender.PublishAsync(message.Build(), CancellationToken.None);
await Task.Delay(1000);
Assert.IsNotNull(receivedMessage);
Assert.AreEqual("A", receivedMessage.Topic);
Assert.AreEqual(4, receivedMessage.UserProperties.Count);
}
}
/// <summary>
/// Publish a message to an MQTT topic
/// </summary>
/// <param name="topic"></param>
/// <param name="message"></param>
/// <param name="retain"></param>
/// <returns></returns>
private async Task Publish(string topic, string message, bool retain = true)
{
if (_mqttClient == null || !_mqttClient.IsConnected)
{
return;
}
topic = $"{_mqttRootTopic}/{topic}";
#if DEBUG
topic = $"dev/{topic}";
#endif
Log.Information($"MQTT: Publishing message to {topic}");
Log.Debug($"MQTT: Message: {message}");
var msg = new MqttApplicationMessageBuilder()
.WithTopic(topic)
.WithPayload(message)
.WithExactlyOnceQoS()
.WithRetainFlag(retain)
.Build();
await _mqttClient.PublishAsync(msg);
}
public async Task Subscribe_Lots_In_Single_Request()
{
using (var testEnvironment = CreateTestEnvironment())
{
var receivedMessagesCount = 0;
await testEnvironment.StartServer();
var c1 = await testEnvironment.ConnectClient();
c1.ApplicationMessageReceivedAsync += e =>
{
Interlocked.Increment(ref receivedMessagesCount);
return(PlatformAbstractionLayer.CompletedTask);
};
var optionsBuilder = new MqttClientSubscribeOptionsBuilder();
for (var i = 0; i < 500; i++)
{
optionsBuilder.WithTopicFilter(i.ToString());
}
await c1.SubscribeAsync(optionsBuilder.Build()).ConfigureAwait(false);
var c2 = await testEnvironment.ConnectClient();
var messageBuilder = new MqttApplicationMessageBuilder();
for (var i = 0; i < 500; i++)
{
messageBuilder.WithTopic(i.ToString());
await c2.PublishAsync(messageBuilder.Build()).ConfigureAwait(false);
}
SpinWait.SpinUntil(() => receivedMessagesCount == 500, TimeSpan.FromSeconds(20));
Assert.AreEqual(500, receivedMessagesCount);
}
}
public async Task PublishRemoveIDMCommand(Guid moduleId)
{
var mqttOptions = new MqttClientOptionsBuilder()
.WithClientId("LiveboltServer")
.WithTcpServer("localhost")
.WithCredentials("livebolt", "livebolt")
.Build();
var mqttClient = new MqttFactory().CreateMqttClient();
await mqttClient.ConnectAsync(mqttOptions);
var message = new MqttApplicationMessageBuilder()
.WithTopic($"idm/remove/{moduleId}")
.WithPayload(1.ToString())
.WithExactlyOnceQoS()
.Build();
await mqttClient.PublishAsync(message);
await mqttClient.DisconnectAsync();
}
public async Task PublicshAsync(string topic, byte[] payload, int retain = 0, int qos = 0)
{
if (mqttClient != null)
{
bool retainFlag = retain == 1;
var mqMessageBuilder = new MqttApplicationMessageBuilder().WithTopic(topic).WithPayload(payload).WithRetainFlag(retainFlag);
mqMessageBuilder.WithAtMostOnceQoS();
var result = await mqttClient.PublishAsync(mqMessageBuilder.Build());
if (result.ReasonCode != MQTTnet.Client.Publishing.MqttClientPublishReasonCode.Success)
{
Console.WriteLine("发送消息失败，topic[" + topic + "],Code:" + result.ReasonCode.ToString());
}
else
{
Console.WriteLine("发送消息成功topic[" + topic + "]：" + Encoding.UTF8.GetString(payload));
}
}
}
static Task PublishAsync(CancellationToken token, int sleepMiliseconds = 1000)
{
Task task = null;
task = Task.Run(() =>
{
var rnd = new Random();
while (true)
{
if (token.IsCancellationRequested)
{
throw new TaskCanceledException(task);
}
if (!_mqttClient.IsStarted || !_mqttClient.IsConnected)
{
Thread.Sleep(1000);
continue;
}
var payload = $"{rnd.Next(0, 50)}";
var message = new MqttApplicationMessageBuilder()
.WithTopic("test1")
.WithPayload(payload)
.WithAtMostOnceQoS()
.WithRetainFlag()
.Build();
_mqttClient.PublishAsync(message);
Console.WriteLine($"PUBLISHED: {payload}");
Thread.Sleep(sleepMiliseconds);
}
});
return(task);
}
private static void Main(string[] args)
{
Console.WriteLine("Hello World!");
MQTTnet.MqttFactory factory = new MQTTnet.MqttFactory();
var client = factory.CreateMqttClient();
var options = new MqttClientOptionsBuilder()
.WithClientId(Guid.NewGuid().ToString())
.WithTcpServer("localhost")
.WithCredentials("3cb97cd31fbc40b08d12ec47a6fad622", "")//token
.Build();
client.UseApplicationMessageReceivedHandler(ax =>
{
Console.WriteLine($"ClientId{ ax.ClientId},msg={ax.ApplicationMessage.ConvertPayloadToString()}");
});
Task.Run(async() =>
{
await client.ConnectAsync(options);
do
{
var message = new MqttApplicationMessageBuilder()
.WithTopic("/devices/me/telemetry")
.WithPayload(JsonConvert.SerializeObject(new
{
RandomString = Guid.NewGuid().ToString(),
NowTime = DateTime.Now
}))
.Build();
Console.WriteLine(message.ConvertPayloadToString());
await client.PublishAsync(message);
await Task.Delay(TimeSpan.FromSeconds(10));
await client.SubscribeAsync("/devices/me/attributes/response/+");
await client.PublishAsync("/devices/me/attributes/request/1", "{\"anySide\":\"Doublevalue,longvalue,Doublevalue,longvalue\"}");
} while (Console.ReadKey().Key != ConsoleKey.Escape);
await client.DisconnectAsync();
}).Wait();
}
