public async Task StartAsync()
{
if (disposedValue)
{
throw new InvalidOperationException("Client is disposed.");
}
await clientLock.WaitAsync();
try
{
var options = new ManagedMqttClientOptionsBuilder()
.WithAutoReconnectDelay(TimeSpan.FromSeconds(10))
.WithClientOptions(new MqttClientOptionsBuilder()
.WithClientId(Guid.NewGuid().ToString())
.WithTcpServer(Server, Port)
.WithCredentials(AccessToken)
.WithTls(new MqttClientOptionsBuilderTlsParameters {
UseTls = UseTls
})
.Build())
.Build();
client = factory.CreateManagedMqttClient();
await client.StartAsync(options);
}
finally
{
clientLock.Release();
}
}
private async void cloudCred(string di, string ak, string ass)
{
clientId = di;
string mqttURI = "broker.losant.com";
string mqttUser = ak;
string mqttPassword = ass;
int mqttPort = 1883;
bool mqttSecure = false;
var messageBuilder = new MqttClientOptionsBuilder()
.WithClientId(clientId)
.WithCredentials(mqttUser, mqttPassword)
.WithTcpServer(mqttURI, mqttPort)
.WithCleanSession();
var options = mqttSecure
? messageBuilder
.WithTls()
.Build()
: messageBuilder
.Build();
var managedOptions = new ManagedMqttClientOptionsBuilder()
.WithAutoReconnectDelay(TimeSpan.FromSeconds(5))
.WithClientOptions(options)
.Build();
client = new MqttFactory().CreateManagedMqttClient();
client.ConnectedHandler = new MqttClientConnectedHandlerDelegate(connected);
client.DisconnectedHandler = new MqttClientDisconnectedHandlerDelegate(disconnected);
client.UseApplicationMessageReceivedHandler(e => { HandleMessageReceived(e.ApplicationMessage); });
await client.StartAsync(managedOptions);
}
private async void button1_Click(object sender, EventArgs e)
{
var factory = new MqttFactory();
_mqttClient = factory.CreateManagedMqttClient();
_mqttClient.ConnectedHandler = new MqttClientConnectedHandlerDelegate(OnSubscriberConnected);
_mqttClient.DisconnectedHandler = new MqttClientDisconnectedHandlerDelegate(OnSubscriberDisconnected);
_mqttClient.ApplicationMessageReceivedHandler = new MqttApplicationMessageReceivedHandlerDelegate(OnSubscriberMessageReceived);
await _mqttClient
.SubscribeAsync(new TopicFilterBuilder()
.WithTopic($"devices/{IdentifierBox.Text}/config")
.WithAtMostOnceQoS()
.Build());
var options = new ManagedMqttClientOptionsBuilder()
.WithClientOptions(new MqttClientOptionsBuilder()
.WithKeepAlivePeriod(TimeSpan.FromSeconds(5))
.WithClientId(IdentifierBox.Text)
.WithCredentials(UserName.Text, Password.Text)
.WithTcpServer(IpAddressBox.Text, int.Parse(ServerPort.Text))
.WithCleanSession())
.WithAutoReconnectDelay(TimeSpan.FromSeconds(5))
.Build();
await _mqttClient.StartAsync(options);
}
private static int _iLastUpdateThreshold = 10; // Minutes
public static async void StartMQTT(string strMQTTServer, string strClientId, string strUser, string strPassword, MessageHandler messageHandler)
{
Logging.WriteDebugLog("MQTT.StartMQTT()");
if (strMQTTServer == null || strMQTTServer == "")
{
return;
}
_timerMQTT = new Timer(Update, null, TimeSpan.FromSeconds(10), TimeSpan.FromMinutes(5));
_strClientId = strClientId;
_messageHandler = messageHandler;
IManagedMqttClientOptions options = new ManagedMqttClientOptionsBuilder().WithAutoReconnectDelay(TimeSpan.FromSeconds(5)).WithClientOptions(new MqttClientOptionsBuilder()
.WithClientId(_strClientId)
.WithCredentials(strUser, strPassword)
.WithTcpServer(strMQTTServer)
.Build())
.Build();
_mqtt = new MqttFactory().CreateManagedMqttClient();
_mqtt.ApplicationMessageReceivedHandler = new MqttApplicationMessageReceivedHandlerDelegate(MessageProcessor);
await _mqtt.StartAsync(options);
}
/// <summary>
/// 重启启动
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public async Task RestartAsync()
{
try
{
await StopAsync();
var model = await FileConfig.GetMqttSetAsync();
MqttClient = new MqttFactory().CreateManagedMqttClient();
var mqttClientOptions = new MqttClientOptionsBuilder()
.WithKeepAlivePeriod(TimeSpan.FromSeconds(29))
.WithClientId(model.ClientId)
.WithWebSocketServer($"{model.Host}:{model.Port}/mqtt")
.WithCredentials(model.UserName, model.Password);
if (model.ConnectionMethod == ConnectionMethod.WSS)
{
mqttClientOptions = mqttClientOptions.WithTls();
}
var options = new ManagedMqttClientOptionsBuilder()
.WithAutoReconnectDelay(TimeSpan.FromSeconds(5))
.WithClientOptions(mqttClientOptions.Build())
.Build();
await MqttClient.StartAsync(options);
}
catch (Exception ex)
{
Log.Logger.Error($"MQTT启动异常,{ex.Message}");
}
}
static async Task Main(string[] args)
{
var options = new ManagedMqttClientOptionsBuilder()
.WithAutoReconnectDelay(TimeSpan.FromSeconds(5))
.WithClientOptions(new MqttClientOptionsBuilder()
.WithClientId("Ali_Consumer")
.WithCredentials("testuser", "testpass")
.WithTcpServer("www.baltavista.com", 8883)
.WithCleanSession(true)
.Build())
.Build();
_mqttClient = new MqttFactory().CreateManagedMqttClient();
await _mqttClient.SubscribeAsync(new TopicFilterBuilder().WithTopic("test1").Build());
await _mqttClient.StartAsync(options);
_mqttClient.UseApplicationMessageReceivedHandler(e =>
{
Console.WriteLine($"({DateTime.Now}):{Encoding.UTF8.GetString(e.ApplicationMessage.Payload)}");
});
Console.WriteLine("-- MQTT Consumer started ---");
Console.ReadLine();
}
public MQTTHelper(string clientId, string mqttURI, string mqttUser, string mqttPassword, int mqttPort, string topicSubscribe = "", Action <string> CallBack = null, bool mqttSecure = false)
{
_CallBack = CallBack;
var messageBuilder = new MqttClientOptionsBuilder()
.WithClientId(clientId)
.WithCredentials(mqttUser, mqttPassword)
.WithTcpServer(mqttURI, mqttPort)
.WithCleanSession();
var options = mqttSecure
? messageBuilder
.WithTls()
.Build()
: messageBuilder
.Build();
var managedOptions = new ManagedMqttClientOptionsBuilder()
.WithAutoReconnectDelay(TimeSpan.FromSeconds(5))
.WithClientOptions(options)
.Build();
Client = new MqttFactory().CreateManagedMqttClient();
Client.StartAsync(managedOptions);
if (!string.IsNullOrEmpty(topicSubscribe))
{
var x = this.SubscribeAsync(topicSubscribe).Result;
}
this.Client.UseApplicationMessageReceivedHandler(e => {
string message = Encoding.UTF8.GetString(e.ApplicationMessage.Payload);
_CallBack?.Invoke(message);
});
}
public virtual async Task StartMqttClient()
{
_logger.Info("Starting MQTT client..");
_managedMqttClient = new MqttFactory().CreateManagedMqttClient();
// This is event is hit when we receive a message from the broker.
_managedMqttClient.ApplicationMessageReceived += (s, a) =>
{
var topic = a.ApplicationMessage.Topic;
var decodedString = Encoding.UTF8.GetString(a.ApplicationMessage.Payload);
_logger.Trace($"Message from topic '{topic}' received.");
_logger.Trace($"Decoded Message: {decodedString}");
HandleMqttApplicationMessageReceived(topic, decodedString);
};
// This just tells us that a message we sent was received successfully by the broker.
_managedMqttClient.ApplicationMessageProcessed += (s, a) =>
{
_logger.Trace("Client Message Processed by Broker", a);
if (a.HasSucceeded == false)
{
// TODO: What to do here?
// Add to a file? And retry later?
}
};
await _managedMqttClient.SubscribeAsync(new List <TopicFilter> {
new TopicFilterBuilder().WithTopic(_moduleConfiguration.MqttValuePushTopic).WithAtLeastOnceQoS().Build()
});
await _managedMqttClient.StartAsync(GetMqttClientOptions());
}
private async void StartMessagingClient()
{
_mqttClient = new MqttFactory().CreateManagedMqttClient();
//Build options for the MQTT client based off of config values
//If running as a Docker container on Ability Edge, the Edge runtime will supply these values to the container
var options = new ManagedMqttClientOptionsBuilder()
.WithClientOptions(
new MQTTnet.Client.MqttClientOptionsBuilder()
.WithClientId(this.Configuration.ClientId)
.WithTcpServer(
this.Configuration.ServerUri.Host,
this.Configuration.ServerUri.Port)
.WithCredentials(
this.Configuration.Username,
this.Configuration.Password)
.WithKeepAlivePeriod(
TimeSpan.FromMilliseconds(
DEFAULT_KEEP_ALIVE_PERIOD_MS))
.WithCleanSession(this.Configuration.CleanSession)
.Build())
.WithAutoReconnectDelay(
TimeSpan.FromMilliseconds(DEFAULT_AUTO_RECONNECT_DELAY_MS))
.Build();
_mqttClient.ApplicationMessageReceived += OnApplicationMessageReceived;
await _mqttClient.StartAsync(options);
Console.WriteLine($"MQTT client created and started.");
}
static async Task Main(string[] args)
{
var mqttFactory = new MqttFactory();
var tlsOptions = new MqttClientTlsOptions
{
UseTls = false,
IgnoreCertificateChainErrors = true,
IgnoreCertificateRevocationErrors = true,
AllowUntrustedCertificates = true
};
var options = new MqttClientOptions
{
ClientId = "Note",
ProtocolVersion = MqttProtocolVersion.V311,
ChannelOptions = new MqttClientTcpOptions
{
Server = "xx.xx.xx.xx",
Port = 1883,
TlsOptions = tlsOptions
}
};
if (options.ChannelOptions == null)
{
throw new InvalidOperationException();
}
options.Credentials = new MqttClientCredentials
{
Username = "******",
Password = Encoding.UTF8.GetBytes("123456")
};
var topicFilter = new MqttTopicFilter {
Topic = "esp32/dht/temperature"
};
options.CleanSession = true;
options.KeepAlivePeriod = TimeSpan.FromSeconds(5);
managedMqttClientSubscriber = mqttFactory.CreateManagedMqttClient();
managedMqttClientSubscriber.ConnectedHandler = new MqttClientConnectedHandlerDelegate(OnSubscriberConnected);
managedMqttClientSubscriber.DisconnectedHandler = new MqttClientDisconnectedHandlerDelegate(OnSubscriberDisconnected);
managedMqttClientSubscriber.ApplicationMessageReceivedHandler = new MqttApplicationMessageReceivedHandlerDelegate(OnSubscriberMessageReceived);
await managedMqttClientSubscriber.SubscribeAsync(topicFilter);
await managedMqttClientSubscriber.StartAsync(
new ManagedMqttClientOptions
{
ClientOptions = options
});
while (true)
{
}
}
private async void OnStarted()
{
var brokerSettings = _configuration.GetSection("BrokerSettings").Get <BrokerSettings>();
var options = new ManagedMqttClientOptionsBuilder()
.WithAutoReconnectDelay(TimeSpan.FromSeconds(5))
.WithClientOptions(new MqttClientOptionsBuilder()
.WithClientId(_serviceSettings.NodeId)
.WithTcpServer(brokerSettings.Host, brokerSettings.Port)
.WithCredentials(brokerSettings.Username, brokerSettings.Password)
.WithCleanSession(false)
.Build())
.Build();
_client.UseConnectedHandler(handler =>
{
_logger.LogInformation("Connected successfully with MQTT Brokers.");
});
_client.UseDisconnectedHandler(handler =>
{
_logger.LogWarning("Disconnected from MQTT Brokers.");
});
await _client.StartAsync(options);
_timer = new Timer(HandleTimerCallback, null, TimeSpan.Zero,
TimeSpan.FromMilliseconds(_serviceSettings.TimeSpan));
}
public MqttService(IHubContext <DevicesHub> hubContext)
{
#if true
_hubContext = hubContext;
var messageBuilder = new MqttClientOptionsBuilder().WithClientId(clientId) /*.WithCredentials(mqttUser, mqttPassword)*/.WithTcpServer(mqttURI, mqttPort).WithCleanSession();
var options = mqttSecure
? messageBuilder
.WithTls()
.Build()
: messageBuilder
.Build();
var managedOptions = new ManagedMqttClientOptionsBuilder().WithAutoReconnectDelay(TimeSpan.FromSeconds(5))
.WithClientOptions(options)
.Build();
client = new MqttFactory().CreateManagedMqttClient();
client.StartAsync(managedOptions);
client.UseConnectedHandler(ClientConnectedHandler);
//client.UseDisconnectedHandler(ClientDisconnectedHandler);
client.ConnectingFailedHandler = new ConnectingFailedHandlerDelegate(OnConnectingFailed);
client.UseApplicationMessageReceivedHandler(ClientMessageReceivedHandler);
#endif
}
public async Task Start()
{
var optionsBuilder = new ManagedMqttClientOptionsBuilder();
optionsBuilder = optionsBuilder.WithClientOptions(
o => o
.WithTcpServer(_parameters.Server, _parameters.Port)
.WithCredentials(_parameters.Username, _parameters.Password)
.WithClientId(_parameters.ClientId)
.WithTls(new MqttClientOptionsBuilderTlsParameters
{
UseTls = _parameters.UseTls
}));
if (!string.IsNullOrEmpty(_parameters.ClientId))
{
optionsBuilder = optionsBuilder.WithClientOptions(o => o.WithClientId(_parameters.ClientId));
}
var options = optionsBuilder.Build();
if (_mqttService.IsLowLevelMqttLoggingEnabled)
{
_mqttClient = new MqttFactory().CreateManagedMqttClient(); //new LoggerAdapter(_logger));
}
else
{
_mqttClient = new MqttFactory().CreateManagedMqttClient();
}
await _mqttClient.SubscribeAsync(_parameters.Topic, _parameters.QualityOfServiceLevel).ConfigureAwait(false);
_mqttClient.UseApplicationMessageReceivedHandler(e => OnApplicationMessageReceived(e));
await _mqttClient.StartAsync(options).ConfigureAwait(false);
}
public MqttSink(MqttSinkOptions options, IManagedMqttClient client) : base(options)
{
MqttClient = client;
Topics = options.Topics.ToList();
Options = options;
var builder = new MqttClientOptionsBuilder()
.WithTcpServer(options.Server, options.Port);
if (options.Password != null && options.Username != null)
{
builder = builder.WithCredentials(options.Username, options.Password);
}
var clientOptions = builder.Build();
MqttClientOptions = new ManagedMqttClientOptionsBuilder()
.WithPendingMessagesOverflowStrategy(MQTTnet.Server.MqttPendingMessagesOverflowStrategy.DropOldestQueuedMessage)
.WithClientOptions(clientOptions)
.WithMaxPendingMessages(1).WithAutoReconnectDelay(TimeSpan.FromSeconds(10)).Build();
MqttClient.UseDisconnectedHandler(HandleDisconnected);
MqttClient.UseConnectedHandler(HandleConnected);
client.StartAsync(MqttClientOptions).Wait();
Next.Subscribe(payload =>
{
Publish(payload).Wait();
});
}
private MqttIpcServer(MqttIpcServerConfiguration configuration, IIpcSerializer serializer, IIpcPacketRouter router, IIpcPacketHandlersContainer packetHandlersContainer)
{
_serializer = serializer;
_router = router;
_packetHandlersContainer = packetHandlersContainer;
string clientName = configuration.ClientName;
string endPoint = configuration.EndPoint;
_client = new MqttFactory().CreateManagedMqttClient(new MqttNetLogger(clientName));
_packetFactory = new PacketContainerFactory();
_queues = new HashSet <string>();
_packetHandlersContainer.Registered += (sender, type) => CheckRouting(type).ConfigureAwait(false).GetAwaiter().GetResult();
_packetHandlersContainer.Unregistered += (sender, type) =>
{
IRoutingInformation infos = _router.GetRoutingInformationsAsync(type).ConfigureAwait(false).GetAwaiter().GetResult();
_client.UnsubscribeAsync(infos.IncomingTopic).ConfigureAwait(false).GetAwaiter().GetResult();
};
ManagedMqttClientOptions options = new ManagedMqttClientOptionsBuilder()
.WithAutoReconnectDelay(TimeSpan.FromSeconds(5))
.WithClientOptions(new MqttClientOptionsBuilder()
.WithClientId(clientName)
.WithTcpServer(endPoint)
.Build())
.Build();
_client.ApplicationMessageReceived += (sender, args) => OnMessage(args.ClientId, args.ApplicationMessage);
_client.StartAsync(options).ConfigureAwait(false).GetAwaiter().GetResult();
_client.Connected += (sender, args) => _log.Info($"[CONNECTED] {clientName} is connected on MQTT Broker {endPoint}");
_client.Disconnected += (sender, args) => _log.Info($"[DISCONNECTED] {clientName} has been disconnected on MQTT Broker {endPoint}");
}
public bool TryConnect()
{
lock (_syncRoot)
{
if (IsConnected)
{
// prevent duplicated concurrent re-connection
return(true);
}
if (!_mqttClient.IsStarted)
{
_logger.LogInformation("Mqtt Client is trying to connect");
_mqttClient.StartAsync(_clientOptions).Wait();
_mqttClient.UseConnectedHandler(e => { _logger.LogInformation("MQTT Server connected!"); });
_mqttClient.UseDisconnectedHandler((e) =>
{
_logger.LogError("MQTT Server disconnected: " + e?.Exception?.Message);
});
}
return(_mqttClient.IsConnected);
}
}
public async Task ConnectAsync(string clientId)
{
var messageBuilder = new MqttClientOptionsBuilder()
.WithClientId(clientId)
.WithCredentials(mqttUser, mqttPassword)
.WithTcpServer(mqttURI, mqttPort)
.WithCleanSession();
var options = mqttSecure
? messageBuilder
.WithTls()
.Build()
: messageBuilder
.Build();
var managedOptions = new ManagedMqttClientOptionsBuilder()
.WithAutoReconnectDelay(TimeSpan.FromSeconds(100))
.WithClientOptions(options)
.Build();
if (clientMqtt != null)
{
await clientMqtt.StartAsync(managedOptions);
}
}
public async Task ConnectAsync()
{
string clientId = Guid.NewGuid().ToString();
string mqttURI = "farmer.cloudmqtt.com";
string mqttUser = "******";
string mqttPassword = "******";
int mqttPort = 22017;
bool mqttSecure = true;
var messageBuilder = new MqttClientOptionsBuilder()
.WithClientId(clientId)
.WithCredentials(mqttUser, mqttPassword)
.WithTcpServer(mqttURI, mqttPort)
.WithCleanSession();
var options = mqttSecure
? messageBuilder
.WithTls()
.Build()
: messageBuilder
.Build();
var managedOptions = new ManagedMqttClientOptionsBuilder()
.WithAutoReconnectDelay(TimeSpan.FromSeconds(5))
.WithClientOptions(options)
.Build();
Client = new MqttFactory().CreateManagedMqttClient();
await Client.StartAsync(managedOptions);
}
public async Task ConnectAsync()
{
string clientId = Guid.NewGuid().ToString();
string mqttURI = "mqtt://*****:*****@farmer.cloudmqtt.com:10472";
string mqttUser = "******";
string mqttPassword = "******";
int mqttPort = 10472;
bool mqttSecure = false;
var messageBuilder = new MqttClientOptionsBuilder()
.WithClientId(clientId)
.WithCredentials(mqttUser, mqttPassword)
.WithTcpServer(mqttURI, mqttPort)
.WithCleanSession();
var options = mqttSecure
? messageBuilder
.WithTls()
.Build()
: messageBuilder
.Build();
var managedOptions = new ManagedMqttClientOptionsBuilder()
.WithAutoReconnectDelay(TimeSpan.FromSeconds(5))
.WithClientOptions(options)
.Build();
await client.StartAsync(managedOptions);
}
private void CreateMQTTClient()
{
var clientOptions = new MqttClientOptions()
{
ClientId = _config.RobotName,
ProtocolVersion = MqttProtocolVersion.V500,
ChannelOptions = new MqttClientTcpOptions()
{
Server = $"{_brokerIP}",
Port = _brokerPort,
TlsOptions = _config.TLSOptions
},
KeepAlivePeriod = _config.KeepalivePeriod,
CleanSession = _config.CleanSession
};
_mqttClient = new MqttFactory().CreateManagedMqttClient();
_mqttClient.ConnectedHandler = new MqttClientConnectedHandlerDelegate(OnConnected);
_mqttClient.DisconnectedHandler = new MqttClientDisconnectedHandlerDelegate(OnDisconnected);
_mqttClient.ApplicationMessageReceivedHandler = new MqttApplicationMessageReceivedHandlerDelegate(OnMessageReceived);
_mqttClient.StartAsync(new ManagedMqttClientOptions()
{
ClientOptions = clientOptions
}).Wait();
}
public MessageSender(MessageSenderConfiguration messageSenderConfiguration)
{
_messageSenderConfiguration = messageSenderConfiguration;
if (!_messageSenderConfiguration.Enabled)
{
return;
}
var messageBuilder = new MqttClientOptionsBuilder()
.WithClientId(messageSenderConfiguration.ClientId)
.WithTcpServer(messageSenderConfiguration.Uri, messageSenderConfiguration.PortNumber)
.WithCleanSession();
var options = messageSenderConfiguration.Secure? messageBuilder.WithTls().Build() : messageBuilder.Build();
var managedOptions = new ManagedMqttClientOptionsBuilder()
.WithAutoReconnectDelay(TimeSpan.FromSeconds(messageSenderConfiguration.AutoConnectDelaySeconds))
.WithClientOptions(options)
.Build();
var clientFactory = new MqttFactory();
_messageClient = clientFactory.CreateManagedMqttClient();
_messageClient.StartAsync(managedOptions);
}
/// <summary>
/// Opens the MQTT connection.
/// </summary>
public async Task StartAsync(IProcesMqttMessage messageHandler)
{
try
{
lock (startupLock)
{
if (_managedMqttClient != null || ConnectionState == ConnectionState.Connected)
{
return;
}
_messageHandler = messageHandler;
ConnectionState = ConnectionState.Connecting;
_managedMqttClient = _mqttClientFactory.CreateManagedMqttClient();
_managedMqttClient.ApplicationMessageReceivedHandler = this;
_managedMqttClient.ApplicationMessageProcessedHandler = this;
_managedMqttClient.ConnectedHandler = this;
_managedMqttClient.ConnectingFailedHandler = this;
_managedMqttClient.SynchronizingSubscriptionsFailedHandler = this;
_managedMqttClient.DisconnectedHandler = this;
}
await _managedMqttClient.StartAsync(_config.Options).ConfigureAwait(false);
}
catch (Exception e)
{
_logger.LogCritical(new EventId(0), e, $"Exception while setting up the mqttclient to {this}");
throw new MqttConnectionException($"Exception while setting up the mqttclient to {this}", e);
}
}
/// <summary>
/// Start the service by building the MQTT configuration
/// </summary>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public async Task StartAsync(CancellationToken cancellationToken)
{
_client = new MqttFactory().CreateManagedMqttClient();
// Setup and start a managed MQTT client.
var mqttClientOptions = new ManagedMqttClientOptionsBuilder()
.WithAutoReconnectDelay(TimeSpan.FromSeconds(5))
.WithClientOptions(new MqttClientOptionsBuilder()
.WithCommunicationTimeout(TimeSpan.FromSeconds(10))
.WithTcpServer(_options.BrokerAddress, _options.BrokerPort)
.Build())
.Build();
_client.UseConnectedHandler(async e =>
{
_logger.LogInformation("### CONNECTED WITH SERVER ###");
await _client.SubscribeAsync(new TopicFilterBuilder().WithTopic(typeof(T).GetTopicName()).Build());
_logger.LogInformation("### SUBSCRIBED ###");
});
_client.UseApplicationMessageReceivedHandler(e =>
{
var obj = JsonConvert.DeserializeObject <T>(Encoding.UTF8.GetString(e.ApplicationMessage.Payload));
_topicHandler.Work(_client, obj);
});
_logger.LogInformation($"Connecting to server [{JsonConvert.SerializeObject(mqttClientOptions)}]...");
await _client.StartAsync(mqttClientOptions);
}
public static async Task ConnectAsync()
{
var clientId = Guid.NewGuid().ToString();
var mqttURI = "localhost";
var mqttUser = "******";
var mqttPassword = "******";
var mqttPort = 1883;
var messageBuilder = new MqttClientOptionsBuilder()
.WithClientId(clientId)
.WithCredentials(mqttUser, mqttPassword)
.WithTcpServer(mqttURI, mqttPort)
.WithCleanSession();
var options = messageBuilder
.Build();
var managedOptions = new ManagedMqttClientOptionsBuilder()
.WithAutoReconnectDelay(TimeSpan.FromSeconds(5))
.WithClientOptions(options)
.Build();
await client.StartAsync(managedOptions);
client.UseConnectedHandler(e => { Console.WriteLine("Connected successfully with MQTT Brokers."); });
client.UseDisconnectedHandler(e => { Console.WriteLine("Disconnected from MQTT Brokers."); });
}
public void Start()
{
var optionsBuilder = new ManagedMqttClientOptionsBuilder();
optionsBuilder = optionsBuilder.WithClientOptions(
o => o
.WithTcpServer(_parameters.Server, _parameters.Port)
.WithCredentials(_parameters.Username, _parameters.Password)
.WithClientId(_parameters.ClientId)
.WithTls(new MqttClientOptionsBuilderTlsParameters
{
UseTls = _parameters.UseTls
}));
if (!string.IsNullOrEmpty(_parameters.ClientId))
{
optionsBuilder = optionsBuilder.WithClientOptions(o => o.WithClientId(_parameters.ClientId));
}
var options = optionsBuilder.Build();
_mqttClient = new MqttFactory().CreateManagedMqttClient(new LoggerAdapter(_logger));
_mqttClient.SubscribeAsync(_parameters.Topic, _parameters.QualityOfServiceLevel).GetAwaiter().GetResult();
_mqttClient.UseApplicationMessageReceivedHandler(e => OnApplicationMessageReceived(e));
_mqttClient.StartAsync(options).GetAwaiter().GetResult();
}
public async Task ConnectAsync()
{
string clientId = Guid.NewGuid().ToString();
string mqttURI = "YOUR_MQTT_URI_HERE";
string mqttUser = "******";
string mqttPassword = "******";
int mqttPort = 000000000;
bool mqttSecure = false;
var messageBuilder = new MqttClientOptionsBuilder()
.WithClientId(clientId)
.WithCredentials(mqttUser, mqttPassword)
.WithTcpServer(mqttURI, mqttPort)
.WithCleanSession();
var options = mqttSecure ? messageBuilder.WithTls().Build()
: messageBuilder.Build();
var managedOptions = new ManagedMqttClientOptionsBuilder()
.WithAutoReconnectDelay(TimeSpan.FromSeconds(5))
.WithClientOptions(options)
.Build();
client = new MqttFactory().CreateManagedMqttClient();
await client.StartAsync(managedOptions);
}
/// <summary>
/// Opens the MQTT connection
/// </summary>
public async Task StartAsync()
{
try
{
lock (startupLock)
{
if (_managedMqttClient != null || ConnectionState == ConnectionState.Connected)
{
return;
}
ConnectionState = ConnectionState.Connecting;
_managedMqttClient = _mqttClientFactory.CreateManagedMqttClient();
_managedMqttClient.ApplicationMessageReceived += ManagedMqttClientApplicationMessageReceived;
_managedMqttClient.ApplicationMessageProcessed += ManagedMqttClientApplicationMessageProcessed;
_managedMqttClient.Connected += ManagedMqttClientConnected;
_managedMqttClient.Disconnected += ManagedMqttClientDisconnected;
}
await _managedMqttClient.StartAsync(_config.Options).ConfigureAwait(false);
}
catch (Exception e)
{
_logger.LogCritical($"Exception while setting up the mqttclient to {this}", e);
throw new MqttConnectionException($"Exception while setting up the mqttclient to {this}", e);
}
}
/// <summary>
/// Start logic
/// </summary>
/// <returns></returns>
public async Task Start()
{
var clientOptions = new MqttClientOptionsBuilder()
.WithClientId($"BluewalkNukiBridge2Mqtt-{Environment.MachineName}-{Environment.UserName}")
.WithTcpServer(_mqttHost, _mqttPort);
if (!string.IsNullOrEmpty(Configuration.Instance.Config.Mqtt.Username))
{
clientOptions = clientOptions.WithCredentials(Configuration.Instance.Config.Mqtt.Username,
Configuration.Instance.Config.Mqtt.Password);
}
var managedOptions = new ManagedMqttClientOptionsBuilder()
.WithAutoReconnectDelay(TimeSpan.FromSeconds(5))
.WithClientOptions(clientOptions);
Log.Information($"MQTT: Connecting to {_mqttHost}:{_mqttPort}");
await _mqttClient.StartAsync(managedOptions.Build());
Log.Information($"Starting callback listener on {_httpListener.Prefixes.First()}");
_stopHttpListener = false;
HttpListenAsync();
InitializeCallback();
DiscoverLocks();
if (_infoTimer.Interval > 0)
{
_infoTimer.Start();
}
}
public async Task StartAsync(CancellationToken cancellationToken)
{
await _mqttClient.StartAsync(_options);
await _mqttClient.SubscribeAsync(_zigbeeEvents.BridgeState);
await _mqttClient.SubscribeAsync(_zigbeeEvents.BridgeLog);
await _mqttClient.SubscribeAsync(_zigbeeEvents.ConnectedDevices);
await _mqttClient.SubscribeAsync(_brokerEvents.NewClientConnected);
await _mqttClient.SubscribeAsync(_brokerEvents.NewClientDisconnected);
using (var scope = _serviceScopeFactory.CreateScope())
{
var mediator = scope.ServiceProvider.GetService <IMediator>();
var messages = await mediator.Send(new GetAllMqttSubscriptionMessagesQuery());
if (messages != null)
{
foreach (var message in messages)
{
await _mqttClient.SubscribeAsync(message.Topic);
}
}
}
}
public void initialize(string ip, string clientName, int AutoReconnectAfter, UnityAction <mqttMessage> messageReceivedCallback, string loggerName = null)
{
if (ranOnce)
{
return;
}
var options = new ManagedMqttClientOptionsBuilder()
.WithAutoReconnectDelay(TimeSpan.FromSeconds(AutoReconnectAfter))
.WithClientOptions(new MqttClientOptionsBuilder()
.WithClientId(clientName)
.WithTcpServer(ip)
.WithKeepAlivePeriod(TimeSpan.FromSeconds(40))
.WithKeepAliveSendInterval(TimeSpan.FromSeconds(5))
//.WithCleanSession(true)
.WithCommunicationTimeout(TimeSpan.FromSeconds(40))
//.WithCleanSession(false)
.Build())
.Build();
if (loggerName != null)
{
client = new MqttFactory().CreateManagedMqttClient(new MqttNetLogger(loggerName));
#if DEBUG
// Write all trace messages to the console window.
//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.Log("[LOGTRACE]: " + trace);
//};
#endif
}
else
{
client = new MqttFactory().CreateManagedMqttClient();
}
//when connected
client.Connected += clientConnected;
client.Disconnected += clientDisconnected;
// register to message received
client.ApplicationMessageReceived += client_MqttMsgPublishReceived;
client.ApplicationMessageProcessed += client_MqttMsgPublishProcessed;
//internal Processing of new messages
this.messageReceivedCallback = messageReceivedCallback;
Debug.Log("newClient start async");
client.StartAsync(options);
ranOnce = true;
}
