shamblett
commented
1 year ago In the code that doesn't work you seem to be not using username and password i.e. setting them to '' and using them in the connect call -
await client.connect(usern, passw);In the code that does work you are setting these to real values. if you pass a username and password to the connect method that are not null it will set them as authentication parameters in the connect message so the broker may be failing the connection on bad authentication. Either set these to the correct values or if you are not using them then just call connect -
await client.connect();Its odd to see ws working and wss not working in either case the client just checks the connection URL and passes them straight to the Dart runtime. If the suggestion above doesn't work you will have to look at your broker logs to see why it is refusing the connection.
adojang
ferrantejake
Hello! First off, thank you for making such an epic library!
I'm having some issues when trying to use the browserclient. The default example works for me. However, my server requires me to use WSS instead of just WS.
I'm able to access my WSS server using another MQTT client, but for some reason it doesn't work when I'm using dart.
Details to test from other MQTT client:
IP: 93.90.207.70 [Anonymous Access is Enabled] [Uses TLS Encryption from Cloudflare]
[x] -Try using that in any MQTT client and it'll work. [x] -It does not work when I run it in dart. [x] - have tried tons of different ports [x] - Double checked my host/provdier's firewall isn't blocking anything [x] - it works for plain WS on my server but not WSS (use port 8083 and change to 'ws://...' instead of 'wss://...',
The error I get is MqttBrowserWsConnection::connect - websocket has erred. Reading a few other posts, I thought it might be my mosquitto config:
But I'm not sure if that is the case, because I AM able to access it user other MQTT clients as shown here (Using MQTT Explorer):
Any help or suggestions would be highly appreciated!
Here's my adapted file:
`import 'dart:async'; import 'package:mqtt_client/mqtt_client.dart'; import 'package:mqtt_client/mqtt_browser_client.dart';
//THIS WORKS
// final client = MqttBrowserClient('wss://test.mosquitto.org', ''); // final port = 8091; // final String usern = 'rw'; // final String passw = 'readwrite';
//THIS DOES NOT WORK. (BUT WORKS WHEN YOU TRY ON ANOTHER CLIENT) final client = MqttBrowserClient('wss://93.90.207.70', ''); final port = 8091; final String usern = ''; final String passw = '';
Future main() async {
/// Set logging on if needed, defaults to off
client.logging(on: true);
/// Set the correct MQTT protocol for mosquito // client.setProtocolV311();
/// If you intend to use a keep alive you must set it here otherwise keep alive will be disabled. client.keepAlivePeriod = 20;
/// The connection timeout period can be set if needed, the default is 5 seconds. client.connectTimeoutPeriod = 2000; // milliseconds
/// The ws port for Mosquitto is 8080, for wss it is 8081 client.port = port;
/// Add the unsolicited disconnection callback client.onDisconnected = onDisconnected;
/// Add the successful connection callback client.onConnected = onConnected;
/// Add a subscribed callback, there is also an unsubscribed callback if you need it. /// You can add these before connection or change them dynamically after connection if /// you wish. There is also an onSubscribeFail callback for failed subscriptions, these /// can fail either because you have tried to subscribe to an invalid topic or the broker /// rejects the subscribe request. client.onSubscribed = onSubscribed;
/// Set a ping received callback if needed, called whenever a ping response(pong) is received /// from the broker. client.pongCallback = pong;
/// Set the appropriate websocket headers for your connection/broker. /// Mosquito uses the single default header, other brokers may be fine with the /// default headers. // client.websocketProtocols = MqttClientConstants.protocolsSingleDefault;
/// Create a connection message to use or use the default one. The default one sets the /// client identifier, any supplied username/password and clean session, /// an example of a specific one below. final connMess = MqttConnectMessage().withClientIdentifier('Mqtt_MyClientUniqueId'); // .withWillTopic('willtopic') // If you set this you must set a will message // .withWillMessage('My Will message') // .startClean() // Non persistent session for testing // .withWillQos(MqttQos.atLeastOnce); print('EXAMPLE::Mosquitto client connecting....'); client.connectionMessage = connMess;
/// Connect the client, any errors here are communicated by raising of the appropriate exception. Note /// in some circumstances the broker will just disconnect us, see the spec about this, we however will /// never send malformed messages. try { await client.connect(usern, passw); } on Exception catch (e) { print('EXAMPLE::client exception - $e'); client.disconnect(); return -1; }
/// Check we are connected if (client.connectionStatus!.state == MqttConnectionState.connected) { print('EXAMPLE::Mosquitto client connected'); } else { /// Use status here rather than state if you also want the broker return code. print( 'EXAMPLE::ERROR Mosquitto client connection failed - disconnecting, status is ${client.connectionStatus}'); client.disconnect(); return -1; }
/// Ok, lets try a subscription print('EXAMPLE::Subscribing to the test/lol topic'); const topic = 'pelicans/lol'; // Not a wildcard topic client.subscribe(topic, MqttQos.atMostOnce);
/// The client has a change notifier object(see the Observable class) which we then listen to to get /// notifications of published updates to each subscribed topic. client.updates!.listen((List<MqttReceivedMessage<MqttMessage?>>? c) { final recMess = c![0].payload as MqttPublishMessage; final pt = MqttPublishPayload.bytesToStringAsString(recMess.payload.message);
});
/// If needed you can listen for published messages that have completed the publishing /// handshake which is Qos dependant. Any message received on this stream has completed its /// publishing handshake with the broker. client.published!.listen((MqttPublishMessage message) { print( 'EXAMPLE::Published notification:: topic is ${message.variableHeader!.topicName}, with Qos ${message.header!.qos}'); });
/// Lets publish to our topic /// Use the payload builder rather than a raw buffer /// Our known topic to publish to const pubTopic = 'Dart/Mqtt_client/testtopic'; final builder = MqttClientPayloadBuilder(); builder.addString('Hello from mqtt_client');
/// Subscribe to it print('EXAMPLE::Subscribing to the Dart/Mqtt_client/testtopic topic'); client.subscribe(pubTopic, MqttQos.exactlyOnce);
/// Publish it print('EXAMPLE::Publishing our topic'); client.publishMessage(pubTopic, MqttQos.exactlyOnce, builder.payload!);
/// Ok, we will now sleep a while, in this gap you will see ping request/response /// messages being exchanged by the keep alive mechanism. print('EXAMPLE::Sleeping....'); await MqttUtilities.asyncSleep(60);
/// Finally, unsubscribe and exit gracefully print('EXAMPLE::Unsubscribing'); client.unsubscribe(topic);
/// Wait for the unsubscribe message from the broker if you wish. await MqttUtilities.asyncSleep(2); print('EXAMPLE::Disconnecting'); client.disconnect(); return 0; }
/// The subscribed callback void onSubscribed(String topic) { print('EXAMPLE::Subscription confirmed for topic $topic'); }
/// The unsolicited disconnect callback void onDisconnected() { print('EXAMPLE::OnDisconnected client callback - Client disconnection'); if (client.connectionStatus!.disconnectionOrigin == MqttDisconnectionOrigin.solicited) { print('EXAMPLE::OnDisconnected callback is solicited, this is correct'); } }
/// The successful connect callback void onConnected() { print( 'EXAMPLE::OnConnected client callback - Client connection was sucessful'); }
/// Pong callback void pong() { print('EXAMPLE::Ping response client callback invoked'); } `