@annadata/capacitor-mqtt-quic 0.2.1 → 0.2.2

package/android/src/main/cpp/ngtcp2_jni.cpp

@@ -233,6 +233,20 @@ class QuicClient {
     state.recv_buf.insert(state.recv_buf.end(), data, data + datalen);
     LOGI("recv stream data stream_id=%" PRId64 " len=%zu recv_buf_total=%zu",
          (int64_t)stream_id, datalen, state.recv_buf.size());
+    if (datalen > 2 && datalen <= 32) {
+      char hex[128];
+      size_t n = datalen < 16 ? datalen : 16u;
+      char *p = hex;
+      for (size_t i = 0; i < n && p < hex + sizeof(hex) - 4; i++)
+        p += snprintf(p, (size_t)(hex + sizeof(hex) - p), "%02x", data[i]);
+      LOGI("recv first bytes (type 0x%02x = %s) hex=%s",
+           (unsigned)data[0],
+           (data[0] & 0xF0) == 0x30 ? "PUBLISH" : (data[0] == (uint8_t)0xd0 ? "PINGRESP" : "other"),
+           hex);
+    } else if (datalen > 32) {
+      LOGI("recv large chunk len=%zu first_byte=0x%02x (PUBLISH=0x30)",
+          datalen, (unsigned)data[0]);
+    }
     if (flags & NGTCP2_STREAM_DATA_FLAG_FIN) {
       state.fin_received = true;
     }

package/android/src/main/kotlin/ai/annadata/mqttquic/MqttQuicPlugin.kt

@@ -121,7 +121,10 @@ class MqttQuicPlugin : Plugin() {
                     } catch (_: Exception) {
                         Base64.encodeToString(payload, Base64.NO_WRAP)
                     }
-                    val data = JSObject().put("topic", topic).put("payload", payloadStr)
+                    // Ensure non-null strings so Capacitor bridge never receives undefined
+                    val safeTopic = topic ?: ""
+                    val safePayload = payloadStr ?: ""
+                    val data = JSObject().put("topic", safeTopic).put("payload", safePayload)
                     Handler(Looper.getMainLooper()).post {
                         notifyListeners("message", data)
                     }

package/android/src/main/kotlin/ai/annadata/mqttquic/client/MQTTClient.kt

@@ -613,30 +613,35 @@ class MQTTClient {
                         }
                         MQTTMessageType.PUBLISH -> {
                             val qos = (msgType.toInt() shr 1) and 0x03
-                            val (topic, packetId, payload) = lock.withLock {
-                                if (activeProtocolVersion == MQTTProtocolLevel.V5) {
-                                    MQTT5Protocol.parsePublishV5(rest, 0, qos, topicAliasMap)
-                                } else {
-                                    MQTTProtocol.parsePublish(rest, 0, qos)
-                                }
-                            }
-
-                            val (cb, globalCb) = lock.withLock {
-                                subscribedTopics[topic] to onPublish
-                            }
-                            globalCb?.invoke(topic, payload)
-                            cb?.invoke(payload)
-
-                            if (qos >= 1 && packetId != null) {
-                                val w = lock.withLock { writer }
-                                w?.let {
-                                    if (qos == 1) {
-                                        it.write(MQTTProtocol.buildPuback(packetId))
+                            try {
+                                val (topic, packetId, payload) = lock.withLock {
+                                    if (activeProtocolVersion == MQTTProtocolLevel.V5) {
+                                        MQTT5Protocol.parsePublishV5(rest, 0, qos, topicAliasMap)
                                     } else {
-                                        it.write(MQTTProtocol.buildPubrec(packetId))
+                                        MQTTProtocol.parsePublish(rest, 0, qos)
+                                    }
+                                }
+                                val (cb, globalCb) = lock.withLock {
+                                    subscribedTopics[topic] to onPublish
+                                }
+                                globalCb?.invoke(topic, payload)
+                                cb?.invoke(payload)
+
+                                if (qos >= 1 && packetId != null) {
+                                    val w = lock.withLock { writer }
+                                    w?.let {
+                                        if (qos == 1) {
+                                            it.write(MQTTProtocol.buildPuback(packetId))
+                                        } else {
+                                            it.write(MQTTProtocol.buildPubrec(packetId))
+                                        }
+                                        it.drain()
                                     }
-                                    it.drain()
                                 }
+                            } catch (e: Exception) {
+                                // PUBLISH parse failed: log and skip this message (don't disconnect)
+                                val hex = rest.take(64).joinToString("") { "%02x".format(it) }
+                                Log.w("MQTTClient", "PUBLISH parse failed: ${e.message} restLen=${rest.size} hex=$hex", e)
                             }
                         }
                         MQTTMessageType.PUBREL -> {

package/ios/Sources/MqttQuicPlugin/Client/MQTTClient.swift

@@ -555,42 +555,48 @@ public final class MQTTClient {
                         pingCont?.resume()
                     case MQTTMessageType.PUBLISH.rawValue:
                         let qos = (msgType >> 1) & 0x03
-                        let topic: String
-                        let packetId: UInt16?
-                        let payload: Data
-                        self.lock.lock()
-                        let version = self.activeProtocolVersion
-                        if version == MQTTProtocolLevel.v5 {
-                            var map = self.topicAliasMap
-                            self.lock.unlock()
-                            (topic, packetId, payload) = try MQTT5Protocol.parsePublishV5(Data(rest), offset: 0, qos: UInt8(qos), topicAliasMap: &map)
+                        do {
+                            let topic: String
+                            let packetId: UInt16?
+                            let payload: Data
                             self.lock.lock()
-                            self.topicAliasMap = map
-                            self.lock.unlock()
-                        } else {
-                            self.lock.unlock()
-                            let (t, pid, pl, _) = try MQTTProtocol.parsePublish(Data(rest), offset: 0, qos: UInt8(qos))
-                            topic = t
-                            packetId = pid
-                            payload = pl
-                        }
-
-                        self.lock.lock()
-                        let cb = self.subscribedTopics[topic]
-                        let globalCb = self.onPublish
-                        self.lock.unlock()
-                        globalCb?(topic, payload)
-                        cb?(payload)
+                            let version = self.activeProtocolVersion
+                            if version == MQTTProtocolLevel.v5 {
+                                var map = self.topicAliasMap
+                                self.lock.unlock()
+                                (topic, packetId, payload) = try MQTT5Protocol.parsePublishV5(Data(rest), offset: 0, qos: UInt8(qos), topicAliasMap: &map)
+                                self.lock.lock()
+                                self.topicAliasMap = map
+                                self.lock.unlock()
+                            } else {
+                                self.lock.unlock()
+                                let (t, pid, pl, _) = try MQTTProtocol.parsePublish(Data(rest), offset: 0, qos: UInt8(qos))
+                                topic = t
+                                packetId = pid
+                                payload = pl
+                            }
 
-                        if qos >= 1, let pid = packetId {
                             self.lock.lock()
-                            let wPuback = self.writer
+                            let cb = self.subscribedTopics[topic]
+                            let globalCb = self.onPublish
                             self.lock.unlock()
-                            if let wPuback = wPuback {
-                                let puback = MQTTProtocol.buildPuback(packetId: pid)
-                                try await wPuback.write(Data(puback))
-                                try await wPuback.drain()
+                            globalCb?(topic, payload)
+                            cb?(payload)
+
+                            if qos >= 1, let pid = packetId {
+                                self.lock.lock()
+                                let wPuback = self.writer
+                                self.lock.unlock()
+                                if let wPuback = wPuback {
+                                    let puback = MQTTProtocol.buildPuback(packetId: pid)
+                                    try await wPuback.write(Data(puback))
+                                    try await wPuback.drain()
+                                }
                             }
+                        } catch {
+                            // PUBLISH parse failed: log and skip this message (don't disconnect)
+                            let hex = rest.prefix(64).map { String(format: "%02x", $0) }.joined()
+                            print("[MqttQuic] PUBLISH parse failed: \(error) restLen=\(rest.count) hex=\(hex)")
                         }
                     default:
                         break

package/ios/Sources/MqttQuicPlugin/MqttQuicPlugin.swift

@@ -139,7 +139,7 @@ public class MqttQuicPlugin: CAPPlugin, CAPBridgedPlugin {
                         return payload.base64EncodedString()
                     }()
                     DispatchQueue.main.async {
-                        self.notifyListeners("message", data: ["topic": topic as String, "payload": payloadStr as String])
+                        self.notifyListeners("message", data: ["topic": topic, "payload": payloadStr])
                     }
                 }
                 try await client.connect(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@annadata/capacitor-mqtt-quic",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "type": "module",
   "description": "MQTT-over-QUIC client for Capacitor (iOS, Android, Web). Native: ngtcp2+WolfSSL; Web: MQTT over WebSocket (WSS), same API.",
   "main": "dist/plugin.cjs.js",