@annadata/capacitor-mqtt-quic 0.2.0 → 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

@@ -46,6 +46,8 @@ public final class MQTTClient {
     private var subackContinuation: CheckedContinuation<Data, Error>?
     /// Handoff from message loop to unsubscribe() for UNSUBACK.
     private var unsubackContinuation: CheckedContinuation<Data, Error>?
+    /// Pending PINGRESP for sendMqttPing(). Message loop completes when PINGRESP is read.
+    private var pendingPingresp: CheckedContinuation<Void, Error>?
     private let lock = NSLock()
 
     public init(protocolVersion: ProtocolVersion = .auto) {
@@ -345,6 +347,8 @@ public final class MQTTClient {
         subackContinuation = nil
         let unsubCont = unsubackContinuation
         unsubackContinuation = nil
+        let pingCont = pendingPingresp
+        pendingPingresp = nil
         let w = writer
         let version = activeProtocolVersion
         quicClient = nil
@@ -358,6 +362,7 @@ public final class MQTTClient {
         lock.unlock()
         subCont?.resume(throwing: MQTTProtocolError.insufficientData("disconnected"))
         unsubCont?.resume(throwing: MQTTProtocolError.insufficientData("disconnected"))
+        pingCont?.resume(throwing: MQTTProtocolError.insufficientData("disconnected"))
 
         if let w = w {
             let data: Data
@@ -403,6 +408,55 @@ public final class MQTTClient {
         return (fixed[0], rem, fixed)
     }
 
+    /// Send MQTT PINGREQ and wait for PINGRESP. Resets server's idle timer. Returns true if PINGRESP received within timeout.
+    public func sendMqttPing(timeoutMs: UInt64 = 5000) async -> Bool {
+        guard case .connected = getState() else { return false }
+        lock.lock()
+        if pendingPingresp != nil {
+            lock.unlock()
+            return false
+        }
+        let w = writer
+        lock.unlock()
+        do {
+            try await withCheckedThrowingContinuation { (cont: CheckedContinuation<Void, Error>) in
+                lock.lock()
+                pendingPingresp = cont
+                lock.unlock()
+                Task {
+                    try? await Task.sleep(nanoseconds: timeoutMs * 1_000_000)
+                    self.lock.lock()
+                    if let c = self.pendingPingresp {
+                        self.pendingPingresp = nil
+                        c.resume(throwing: MQTTProtocolError.insufficientData("PINGRESP timeout"))
+                    }
+                    self.lock.unlock()
+                }
+                if let w = w {
+                    Task {
+                        do {
+                            try await w.write(MQTTProtocol.buildPingreq())
+                            try await w.drain()
+                        } catch {
+                            self.lock.lock()
+                            if let c = self.pendingPingresp {
+                                self.pendingPingresp = nil
+                                c.resume(throwing: error)
+                            }
+                            self.lock.unlock()
+                        }
+                    }
+                }
+            }
+            return true
+        } catch {
+            lock.lock()
+            pendingPingresp = nil
+            lock.unlock()
+            return false
+        }
+    }
+
     /// Send PINGREQ at effectiveKeepalive interval so server sees activity and does not close (idle/keepalive). [MQTT-3.1.2-20]
     private func startKeepaliveLoop() {
         keepaliveTask?.cancel()
@@ -493,44 +547,56 @@ public final class MQTTClient {
                             try await w.write(Data(pr))
                             try await w.drain()
                         }
+                    case MQTTMessageType.PINGRESP.rawValue:
+                        self.lock.lock()
+                        let pingCont = self.pendingPingresp
+                        self.pendingPingresp = nil
+                        self.lock.unlock()
+                        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
@@ -550,6 +616,8 @@ public final class MQTTClient {
                         subackContinuation = nil
                         unsubackContinuation?.resume(throwing: error)
                         unsubackContinuation = nil
+                        pendingPingresp?.resume(throwing: error)
+                        pendingPingresp = nil
                         state = .disconnected
                         lock.unlock()
                     }

package/ios/Sources/MqttQuicPlugin/MqttQuicPlugin.swift

@@ -15,6 +15,7 @@ public class MqttQuicPlugin: CAPPlugin, CAPBridgedPlugin {
     public let jsName = "MqttQuic"
     public let pluginMethods: [CAPPluginMethod] = [
         CAPPluginMethod(name: "ping", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "sendKeepalive", returnType: CAPPluginReturnPromise),
         CAPPluginMethod(name: "connect", returnType: CAPPluginReturnPromise),
         CAPPluginMethod(name: "disconnect", returnType: CAPPluginReturnPromise),
         CAPPluginMethod(name: "publish", returnType: CAPPluginReturnPromise),
@@ -27,6 +28,19 @@ public class MqttQuicPlugin: CAPPlugin, CAPBridgedPlugin {
 
     @objc override public func load() {}
 
+    @objc func sendKeepalive(_ call: CAPPluginCall) {
+        let timeoutMs = UInt64(call.getInt("timeoutMs") ?? 5000)
+        let clamped = min(max(timeoutMs, 1000), 15000)
+        Task {
+            do {
+                let ok = await client.sendMqttPing(timeoutMs: clamped)
+                DispatchQueue.main.async { call.resolve(["ok": ok]) }
+            } catch {
+                DispatchQueue.main.async { call.reject("\(error)") }
+            }
+        }
+    }
+
     @objc func ping(_ call: CAPPluginCall) {
         let host = call.getString("host") ?? ""
         let port = call.getInt("port") ?? 1884
@@ -120,12 +134,10 @@ public class MqttQuicPlugin: CAPPlugin, CAPBridgedPlugin {
                 // Forward every incoming PUBLISH to JS so addListener('message', ...) receives topic + payload (matches Android)
                 client.onPublish = { [weak self] topic, payload in
                     guard let self = self else { return }
-                    let payloadStr: String
-                    if let str = String(data: payload, encoding: .utf8) {
-                        payloadStr = str
-                    } else {
-                        payloadStr = payload.base64EncodedString()
-                    }
+                    let payloadStr: String = {
+                        if let str = String(data: payload, encoding: .utf8) { return str }
+                        return payload.base64EncodedString()
+                    }()
                     DispatchQueue.main.async {
                         self.notifyListeners("message", data: ["topic": topic, "payload": payloadStr])
                     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@annadata/capacitor-mqtt-quic",
-  "version": "0.2.0",
+  "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",