public void Connect(bool verbose) { // Connect to broker. IPAddress ipAdress = IPAddress.Parse(ip); // disable weird obsolote constructor warning. #pragma warning disable 618 client = new MqttClient(ipAdress, port, false, null, null, MqttSslProtocols.None); // Run connect as task so we can wait for timeout (cant be programatically changed otherwise and is really long...). Task t = Task.Run(() => { byte msg = client.Connect(Guid.NewGuid().ToString()); MqttMsgConnack connack = new MqttMsgConnack(); //for debugging. connack.GetBytes(msg); // Set callback on message. client.MqttMsgPublishReceived += ReceivedMessage; if (verbose) { UnityEngine.Debug.Log(String.Format("Succesfully connected to MQTT Broker at: {0}:{1}", ip, port)); } }); TimeSpan ts = TimeSpan.FromMilliseconds(1000); if (!t.Wait(ts)) { UnityEngine.Debug.LogError(String.Format("Could not connect to MQTT broker at {0}:{1}", ip, port)); } }
/// <summary> /// Connect to broker /// </summary> /// <param name="clientId">Client identifier</param> /// <param name="username">Username</param> /// <param name="password">Password</param> /// <param name="willRetain">Will retain flag</param> /// <param name="willQosLevel">Will QOS level</param> /// <param name="willFlag">Will flag</param> /// <param name="willTopic">Will topic</param> /// <param name="willMessage">Will message</param> /// <param name="cleanSession">Clean sessione flag</param> /// <param name="keepAlivePeriod">Keep alive period</param> /// <returns>Return code of CONNACK message from broker</returns> public byte Connect(string clientId, string username = null, string password = null, bool willRetain = false, byte willQosLevel = MqttMsgConnect.QOS_LEVEL_AT_LEAST_ONCE, bool willFlag = false, string willTopic = null, string willMessage = null, bool cleanSession = true, ushort keepAlivePeriod = MqttMsgConnect.KEEP_ALIVE_PERIOD_DEFAULT) { // create CONNECT message MqttMsgConnect connect = new MqttMsgConnect(clientId, username, password, willRetain, willQosLevel, willFlag, willTopic, willMessage, cleanSession, keepAlivePeriod); try { this.socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); // try connection to the broker this.socket.Connect(new IPEndPoint(this.brokerIpAddress, this.brokerPort)); } catch { throw new MqttConnectionException(); } this.lastSend = 0; this.isRunning = true; // start thread for receiving messages from broker this.receiveThread = new Thread(this.ReceiveThread); this.receiveThread.Start(); MqttMsgConnack connack = (MqttMsgConnack)this.SendReceive(connect.GetBytes()); // if connection accepted, start keep alive timer if (connack.ReturnCode == MqttMsgConnack.CONN_ACCEPTED) { this.IsConnected = true; this.keepAlivePeriod = keepAlivePeriod * 1000; // convert in ms // start thread for sending keep alive message to the broker this.keepAliveThread = new Thread(this.KeepAliveThread); this.keepAliveThread.Start(); } return(connack.ReturnCode); }
public void ConnackBasicDecodeTest5() { // Arrange byte[] correctEncoded = new byte[] { 3, 1, 138, 0 }; MokChannel mokChannel = new MokChannel(correctEncoded); // Act MqttMsgConnack connack = MqttMsgConnack.Parse((byte)(MqttMessageType.ConnectAck) << 4, MqttProtocolVersion.Version_5, mokChannel); // Assert Assert.Equal(true, connack.SessionPresent); Assert.Equal((byte)MqttReasonCode.Banned, (byte)connack.ReturnCode); }
public MqttMsgConnack CreateConnack(MqttProtocolVersion proctocolVersion, byte returnCode, bool sessionPresent) { var connack = new MqttMsgConnack { ReturnCode = returnCode }; if (proctocolVersion == MqttProtocolVersion.Version_3_1_1) { connack.SessionPresent = sessionPresent; } return(connack); }
private void SendConnack(uint clientIndex, bool cleanSession, byte returnCode, bool isWebSocketClient) { MqttMsgConnack connack = MsgBuilder.BuildConnack(cleanSession, returnCode); if (!isWebSocketClient) { tcpServer.Send(clientIndex, connack.GetBytes()); } else { wsServer.Send(clientIndex, connack.GetBytes()); } //Send(clientIndex, connack.GetBytes(), connack.GetBytes().Length); }
public static MqttMsgConnack BuildConnack(bool sp, byte returnCode) { MqttMsgConnack connack = new MqttMsgConnack(); //Fixed header first byte byte fixedHeaderB1 = (byte)(MqttMsgBase.MQTT_MSG_CONNACK_TYPE << MqttMsgBase.MSG_TYPE_OFFSET); //Variable header bytes byte variableHeaderB1 = (sp) ? (byte)0x01 : (byte)0x00; byte variableHeaderB2 = returnCode; int remainingLenght = variableHeaderB1 + variableHeaderB2; byte[] data = new byte[fixedHeaderB1 + remainingLenght]; data[0] = fixedHeaderB1; connack.encodeRemainingLength(remainingLenght, data, 1); return(connack); }
public void ConnackAdvanceDecodeTestv5() { //Arrange byte[] encodedCorrect = new byte[] { 124, 1, 138, 121, 17, 0, 0, 9, 164, 33, 0, 89, 36, 1, 37, 1, 39, 0, 0, 17, 215, 18, 0, 6, 84, 97, 103, 97, 100, 97, 34, 0, 148, 31, 0, 4, 110, 111, 110, 101, 38, 0, 3, 79, 110, 101, 0, 8, 80, 114, 111, 112, 101, 114, 116, 121, 38, 0, 3, 84, 119, 111, 0, 10, 80, 114, 111, 112, 101, 114, 116, 105, 101, 115, 40, 1, 41, 1, 42, 1, 19, 5, 77, 26, 0, 11, 105, 110, 102, 114, 111, 109, 97, 116, 105, 111, 110, 28, 0, 9, 114, 101, 102, 101, 114, 101, 110, 99, 101, 21, 0, 6, 109, 101, 116, 104, 111, 100, 22, 0, 4, 1, 2, 3, 4 }; MokChannel mokChannel = new MokChannel(encodedCorrect); // Act MqttMsgConnack connack = MqttMsgConnack.Parse((byte)(MqttMessageType.ConnectAck) << 4, MqttProtocolVersion.Version_5, mokChannel); // Assert Assert.Equal(true, connack.SessionPresent); Assert.Equal((byte)MqttReasonCode.Banned, (byte)connack.ReturnCode); Assert.Equal(connack.AssignedClientIdentifier, "Tagada"); Assert.Equal(connack.AuthenticationData, new byte[] { 1, 2, 3, 4 }); Assert.Equal(connack.AuthenticationMethod, "method"); Assert.Equal(connack.MaximumPacketSize, 4567); Assert.Equal(connack.MaximumQoS, true); Assert.Equal(connack.Reason, "none"); Assert.Equal(connack.ReceiveMaximum, (ushort)89); Assert.Equal(connack.ResponseInformation, "infromation"); Assert.Equal(connack.RetainAvailable, true); Assert.Equal(connack.ServerKeepAlive, (ushort)1357); Assert.Equal(connack.ServerReference, "reference"); Assert.Equal(connack.SessionExpiryInterval, 2468); Assert.Equal(connack.SharedSubscriptionAvailable, true); Assert.Equal(connack.SubscriptionIdentifiersAvailable, true); Assert.Equal(connack.TopicAliasMaximum, (ushort)148); Assert.Equal(connack.UserProperties.Count, 2); var prop = new UserProperty("One", "Property"); Assert.Equal(((UserProperty)connack.UserProperties[0]).Name, prop.Name); Assert.Equal(((UserProperty)connack.UserProperties[0]).Value, prop.Value); prop = new UserProperty("Two", "Properties"); Assert.Equal(((UserProperty)connack.UserProperties[1]).Name, prop.Name); Assert.Equal(((UserProperty)connack.UserProperties[1]).Value, prop.Value); Assert.Equal(connack.WildcardSubscriptionAvailable, true); }
public static void Connack(MqttClientConnection clientConnection, MqttMsgConnect connect, byte returnCode, string clientId, bool sessionPresent) { clientConnection.LastCommunicationTime = Environment.TickCount; MqttMsgConnack connack = new MqttMsgConnack(); connack.ReturnCode = returnCode; if (clientConnection.ProtocolVersion == MqttProtocolVersion.Version_3_1_1) { connack.SessionPresent = sessionPresent; } // ... send it to the client Send(clientConnection, connack); // connection accepted, start keep alive thread checking if (returnCode == MqttMsgConnack.CONN_ACCEPTED) { // [v3.1.1] if client id isn't null, the CONNECT message has a cliend id with zero bytes length // and broker assigned a unique identifier to the client clientConnection.ClientId = (clientId == null) ? connect.ClientId : clientId; clientConnection.CleanSession = connect.CleanSession; clientConnection.WillFlag = connect.WillFlag; clientConnection.WillTopic = connect.WillTopic; clientConnection.WillMessage = connect.WillMessage; clientConnection.WillQosLevel = connect.WillQosLevel; clientConnection.KeepAlivePeriod = connect.KeepAlivePeriod * 1000; // convert in ms // broker has a tolerance of 1.5 specified keep alive period clientConnection.KeepAlivePeriod += (clientConnection.KeepAlivePeriod / 2); clientConnection.IsConnectionClosing = false; clientConnection.IsConnected = true; } // connection refused, close TCP/IP channel else { clientConnection.OnConnectionClosed(); } }
public static MqttMsgBase DecodeControlPacket(byte[] data) { byte fixedHeaderFirstByte = (byte)(data[0] >> MqttMsgBase.MSG_TYPE_OFFSET); switch (fixedHeaderFirstByte) { case MqttMsgBase.MQTT_MSG_CONNECT_TYPE: { return(MqttMsgConnect.Parse(data)); } case MqttMsgBase.MQTT_MSG_CONNACK_TYPE: { return(MqttMsgConnack.Parse(data)); } case MqttMsgBase.MQTT_MSG_PUBLISH_TYPE: { return(MqttMsgPublish.Parse(data)); } case MqttMsgBase.MQTT_MSG_PUBACK_TYPE: { return(MqttMsgPuback.Parse(data)); } case MqttMsgBase.MQTT_MSG_PUBREC_TYPE: { return(MqttMsgPubrec.Parse(data)); } case MqttMsgBase.MQTT_MSG_PUBREL_TYPE: { return(MqttMsgPubrel.Parse(data)); } case MqttMsgBase.MQTT_MSG_PUBCOMP_TYPE: { return(MqttMsgPubcomp.Parse(data)); } case MqttMsgBase.MQTT_MSG_SUBSCRIBE_TYPE: { return(MqttMsgSubscribe.Parse(data)); } case MqttMsgBase.MQTT_MSG_SUBACK_TYPE: { return(MqttMsgSuback.Parse(data)); } case MqttMsgBase.MQTT_MSG_UNSUBSCRIBE_TYPE: { return(MqttMsgUnsubscribe.Parse(data)); } case MqttMsgBase.MQTT_MSG_UNSUBACK_TYPE: { return(MqttMsgUnsuback.Parse(data)); } case MqttMsgBase.MQTT_MSG_PINGREQ_TYPE: { return(MqttMsgPingReq.Parse(data)); } case MqttMsgBase.MQTT_MSG_PINGRESP_TYPE: { return(MqttMsgPingResp.Parse(data)); } case MqttMsgBase.MQTT_MSG_DISCONNECT_TYPE: { CrestronLogger.WriteToLog("PACKETDECODER - Riconosciuto DISCONNNECT: ", 1); return(MqttMsgDisconnect.Parse(data)); } default: { throw new FormatException(); } } }
/// <summary> /// Thread for receiving messages from broker /// </summary> private void ReceiveThread() { int readBytes; byte[] fixedHeaderFirstByte = new byte[1]; byte msgType; while (this.isRunning) { try { // read first byte (fixed header) readBytes = this.socket.Receive(fixedHeaderFirstByte); if (readBytes > 0) { // extract message type from received byte msgType = (byte)((fixedHeaderFirstByte[0] & MqttMsgBase.MSG_TYPE_MASK) >> MqttMsgBase.MSG_TYPE_OFFSET); switch (msgType) { // impossible, broker can't send CONNECT message case MqttMsgBase.MQTT_MSG_CONNECT_TYPE: throw new MqttClientException(MqttClientErrorCode.WrongBrokerMessage); // CONNACK message received from broker case MqttMsgBase.MQTT_MSG_CONNACK_TYPE: this.msgReceived = MqttMsgConnack.Parse(fixedHeaderFirstByte[0], this.socket); this.endReceiving.Set(); break; // impossible, broker can't send PINGREQ message case MqttMsgBase.MQTT_MSG_PINGREQ_TYPE: throw new MqttClientException(MqttClientErrorCode.WrongBrokerMessage); // CONNACK message received from broker case MqttMsgBase.MQTT_MSG_PINGRESP_TYPE: this.msgReceived = MqttMsgPingResp.Parse(fixedHeaderFirstByte[0], this.socket); this.endReceiving.Set(); break; // impossible, broker can't send SUBSCRIBE message case MqttMsgBase.MQTT_MSG_SUBSCRIBE_TYPE: throw new MqttClientException(MqttClientErrorCode.WrongBrokerMessage); // SUBACK message received from broker case MqttMsgBase.MQTT_MSG_SUBACK_TYPE: this.msgReceived = MqttMsgSuback.Parse(fixedHeaderFirstByte[0], this.socket); this.endReceiving.Set(); // raise subscribed topic event (SUBACK message received) this.OnMqttMsgSubscribed((MqttMsgSuback)this.msgReceived); break; // PUBLISH message received from broker case MqttMsgBase.MQTT_MSG_PUBLISH_TYPE: MqttMsgPublish msgReceived = MqttMsgPublish.Parse(fixedHeaderFirstByte[0], this.socket); // for QoS Level 1 and 2, client sends PUBACK message to broker if ((this.msgReceived.QosLevel == MqttMsgBase.QOS_LEVEL_AT_LEAST_ONCE) || (this.msgReceived.QosLevel == MqttMsgBase.QOS_LEVEL_EXACTLY_ONCE)) { MqttMsgPuback puback = new MqttMsgPuback(); puback.MessageId = (msgReceived).MessageId; this.Send(puback.GetBytes()); } // raise PUBLISH message received event this.OnMqttMsgPublishReceived(msgReceived); break; // PUBACK message received from broker case MqttMsgBase.MQTT_MSG_PUBACK_TYPE: this.msgReceived = MqttMsgPuback.Parse(fixedHeaderFirstByte[0], this.socket); this.endReceiving.Set(); // raise published message event // (PUBACK received for QoS Level 1) this.OnMqttMsgPublished(((MqttMsgPuback)this.msgReceived).MessageId); break; // PUBREC message received from broker case MqttMsgBase.MQTT_MSG_PUBREC_TYPE: this.msgReceived = MqttMsgPubrec.Parse(fixedHeaderFirstByte[0], this.socket); this.endReceiving.Set(); break; // impossible, broker can't send PUBREL message case MqttMsgBase.MQTT_MSG_PUBREL_TYPE: throw new MqttClientException(MqttClientErrorCode.WrongBrokerMessage); // PUBCOMP message received from broker case MqttMsgBase.MQTT_MSG_PUBCOMP_TYPE: this.msgReceived = MqttMsgPubcomp.Parse(fixedHeaderFirstByte[0], this.socket); this.endReceiving.Set(); // raise published message event // (PUBCOMP received for QoS Level 2) this.OnMqttMsgPublished(((MqttMsgPuback)this.msgReceived).MessageId); break; // impossible, broker can't send UNSUBSCRIBE message case MqttMsgBase.MQTT_MSG_UNSUBSCRIBE_TYPE: throw new MqttClientException(MqttClientErrorCode.WrongBrokerMessage); // UNSUBACK message received from broker case MqttMsgBase.MQTT_MSG_UNSUBACK_TYPE: this.msgReceived = MqttMsgUnsuback.Parse(fixedHeaderFirstByte[0], this.socket); this.endReceiving.Set(); // raise unsubscribed topic event this.OnMqttMsgUnsubscribed(((MqttMsgUnsuback)this.msgReceived).MessageId); break; default: throw new MqttClientException(MqttClientErrorCode.WrongBrokerMessage); } this.exReceiving = null; } } catch (Exception) { this.exReceiving = new MqttCommunicationException(); } } }
public MqttMsgBase DecodeControlPacket(byte[] data) { byte fixedHeaderFirstByte = (byte)(data[0] >> MSG_TYPE_OFFSET); switch (fixedHeaderFirstByte) { case MqttMsgBase.MQTT_MSG_CONNECT_TYPE: { return(MqttMsgConnect.Parse(data)); } case MqttMsgBase.MQTT_MSG_CONNACK_TYPE: { return(MqttMsgConnack.Parse(data)); } case MqttMsgBase.MQTT_MSG_PUBLISH_TYPE: { return(MqttMsgPublish.Parse(data)); } case MqttMsgBase.MQTT_MSG_PUBACK_TYPE: { return(MqttMsgPuback.Parse(data)); } case MqttMsgBase.MQTT_MSG_PUBREC_TYPE: { return(MqttMsgPubrec.Parse(data)); } case MqttMsgBase.MQTT_MSG_PUBREL_TYPE: { return(MqttMsgPubrel.Parse(data)); } case MqttMsgBase.MQTT_MSG_PUBCOMP_TYPE: { return(MqttMsgPubcomp.Parse(data)); } case MqttMsgBase.MQTT_MSG_SUBSCRIBE_TYPE: { return(MqttMsgSubscribe.Parse(data)); } case MqttMsgBase.MQTT_MSG_SUBACK_TYPE: { return(MqttMsgSuback.Parse(data)); } case MqttMsgBase.MQTT_MSG_UNSUBSCRIBE_TYPE: { return(MqttMsgUnsubscribe.Parse(data)); } case MqttMsgBase.MQTT_MSG_UNSUBACK_TYPE: { return(MqttMsgUnsuback.Parse(data)); } case MqttMsgBase.MQTT_MSG_PINGREQ_TYPE: { return(MqttMsgPingReq.Parse(data)); } case MqttMsgBase.MQTT_MSG_PINGRESP_TYPE: { return(MqttMsgPingResp.Parse(data)); } case MqttMsgBase.MQTT_MSG_DISCONNECT_TYPE: { return(MqttMsgDisconnect.Parse(data)); } default: { throw new FormatException(" First byte shifted : " + fixedHeaderFirstByte); } } }
static void Main(string[] args) { // Pre-amble Console.WriteLine("Please ensure the scaling is set to 1 for calibration\n"); msgBuffer = new List <Data>(); // Read settings file. DirectoryInfo mainDir = new DirectoryInfo(Directory.GetCurrentDirectory()); var yamlFiles = mainDir.GetFiles("settings.yml"); if (yamlFiles.Length == 0) { Exit("Could not find settings.yml"); } FileInfo yamlFile = yamlFiles[0]; var dse = new Deserializer(); //Console.WriteLine("Reading YAML: {0}", yamlFile.FullName); using (var yamlStream = yamlFile.Open(FileMode.Open)) { using (var yamlReader = new StreamReader(yamlStream, Encoding.UTF8, true)) { settings = dse.Deserialize <Settings>(yamlReader); } } // Connect to broker. #region Connect to Broker. IPAddress ipAdress = IPAddress.Parse("127.0.0.1"); Console.WriteLine(String.Format("Connecting to: 127.0.0.1:1883")); client = new MqttClient(settings.brokerIp, 1883, false, null, null, MqttSslProtocols.None); try { byte msg = client.Connect(Guid.NewGuid().ToString()); MqttMsgConnack connack = new MqttMsgConnack(); connack.GetBytes(msg); if (!client.IsConnected) { Exit("Failed to connect"); } } catch { Exit("Failed to connect"); } #endregion // Subscribe to topic. #region Subscribe to topic client.MqttMsgPublishReceived += receiveMessage; string topic = string.Format("{0}/Data", settings.deviceName); Console.WriteLine(String.Format("Subscribing to topic: {0}\n", topic)); try { client.Subscribe(new string[] { topic }, new byte[] { MqttMsgBase.QOS_LEVEL_EXACTLY_ONCE }); } catch { Exit("Failed to subscribe to topic"); } #endregion // Ask radius. float circumference = 2f * (float)Math.PI * settings.radius; float arcLength = circumference / 2; // Request axis to calibrate. ConsoleKeyInfo axisString = new ConsoleKeyInfo(); while (axisString.Key != ConsoleKey.E) { Console.Write("Calibrate: (P)itch, (R)oll, (Y)aw (E)xit\n"); axisString = Console.ReadKey(); int axis = 0; switch (axisString.Key) { case ConsoleKey.P: { axis = 1; break; } case ConsoleKey.R: { axis = 2; break; } case ConsoleKey.Y: { axis = 3; break; } case ConsoleKey.E: { continue; } default: { Exit("Not recognized"); break; } } // Ask average. int averageNum = int.Parse(QuestionString("Average over how many measurements?:")); // Start measurement. string[] axisNames = { "Pitch", "Roll", "Yaw" }; float[] measurements = new float[averageNum]; for (int i = 0; i < averageNum; i++) { // clean buffer. msgBuffer.Clear(); Console.WriteLine(string.Format( "Rotate treadmill +180 degrees in {0} direction (Left-hand rule)\nand press any key.", axisNames[axis - 1])); Console.ReadKey(); // collect data Data result = new Data(); lock (msgBuffer) { result.pitch = msgBuffer.Sum(x => x.pitch); result.roll = msgBuffer.Sum(x => x.roll); result.yaw = msgBuffer.Sum(x => x.yaw); } // read buffer. switch (axis) { case 1: measurements[i] = result.pitch; break; case 2: measurements[i] = result.roll; break; case 3: measurements[i] = result.yaw; break; } // Output. Console.WriteLine(string.Format("\nPitch: {0:0.00},\tRoll: {1:0.00},\tYaw: {2:0.00}", result.pitch, result.roll, result.yaw)); // Yaw: degrees. if (axis == 3) { Console.WriteLine(string.Format("Calibration value: {0:0.0000000}", Math.Abs(180 / measurements[i]))); } // Pitch/Roll: arc length. else { Console.WriteLine(string.Format("Calibration value: {0:0.0000000}", Math.Abs(arcLength / measurements[i]))); } } // Averaged result. Console.WriteLine("\nResult:"); // Yaw: degrees. if (axis == 3) { Console.WriteLine(string.Format("Averaged calibration value: {0:0.0000000}", Math.Abs(180 / measurements.Average()))); } // Pitch/Roll: arc length. else { Console.WriteLine(string.Format("Averaged calibration value: {0:0.0000000}", Math.Abs(arcLength / measurements.Average()))); } } Exit("\nDone!"); }
private void HandleCONNACKType(MqttMsgConnack mqttMsgConnack) { SubscribeToTopics(); //StartKeepAlive(); tcpClient.ReceiveDataAsync(ReceiveCallback); }
public MqttMsgBase DecodeControlPacket(byte[] data) { #if PACKET_DEBUG CrestronLogger.WriteToLog("MQTTCLIENT - RECEIVE - " + BitConverter.ToString(data), 2); #endif byte fixedHeaderFirstByte = (byte)(data[0] >> MSG_TYPE_OFFSET); switch (fixedHeaderFirstByte) { case MqttMsgBase.MQTT_MSG_CONNECT_TYPE: { return(MqttMsgConnect.Parse(data)); } case MqttMsgBase.MQTT_MSG_CONNACK_TYPE: { return(MqttMsgConnack.Parse(data)); } case MqttMsgBase.MQTT_MSG_PUBLISH_TYPE: { return(MqttMsgPublish.Parse(data)); } case MqttMsgBase.MQTT_MSG_PUBACK_TYPE: { return(MqttMsgPuback.Parse(data)); } case MqttMsgBase.MQTT_MSG_PUBREC_TYPE: { return(MqttMsgPubrec.Parse(data)); } case MqttMsgBase.MQTT_MSG_PUBREL_TYPE: { return(MqttMsgPubrel.Parse(data)); } case MqttMsgBase.MQTT_MSG_PUBCOMP_TYPE: { return(MqttMsgPubcomp.Parse(data)); } case MqttMsgBase.MQTT_MSG_SUBSCRIBE_TYPE: { return(MqttMsgSubscribe.Parse(data)); } case MqttMsgBase.MQTT_MSG_SUBACK_TYPE: { return(MqttMsgSuback.Parse(data)); } case MqttMsgBase.MQTT_MSG_UNSUBSCRIBE_TYPE: { return(MqttMsgUnsubscribe.Parse(data)); } case MqttMsgBase.MQTT_MSG_UNSUBACK_TYPE: { return(MqttMsgUnsuback.Parse(data)); } case MqttMsgBase.MQTT_MSG_PINGREQ_TYPE: { return(MqttMsgPingReq.Parse(data)); } case MqttMsgBase.MQTT_MSG_PINGRESP_TYPE: { return(MqttMsgPingResp.Parse(data)); } case MqttMsgBase.MQTT_MSG_DISCONNECT_TYPE: { return(MqttMsgDisconnect.Parse(data)); } default: { throw new FormatException(" First byte shifted : " + fixedHeaderFirstByte); } } }
private void HandleCONNACKType(MqttMsgConnack mqttMsgConnack) { SubscribeToTopics(); ClientReceiveDataAsync(); OnConnectionStateChanged(1); // SIMPL+ doesn't need to think we're connected until the login process is complete }