@annadata/capacitor-mqtt-quic 0.1.9 → 0.2.1

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

@@ -38,12 +38,16 @@ public final class MQTTClient {
     private var keepaliveTask: Task<Void, Never>?
     private var nextPacketId: UInt16 = 1
     private var subscribedTopics: [String: (Data) -> Void] = [:]
+    /// Optional global callback for every incoming PUBLISH (topic, payload). Used by plugin to forward to JS. Matches Android.
+    var onPublish: ((String, Data) -> Void)?
     /// Per-connection Topic Alias map (alias -> topic name) for MQTT 5.0 incoming PUBLISH.
     private var topicAliasMap: [Int: String] = [:]
     /// Handoff from message loop to subscribe() so SUBACK is not consumed by the loop (avoids race and "insufficientData(SUBACK packet ID)").
     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) {
@@ -343,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
@@ -356,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
@@ -401,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()
@@ -491,6 +547,12 @@ 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
@@ -515,7 +577,9 @@ public final class MQTTClient {
 
                         self.lock.lock()
                         let cb = self.subscribedTopics[topic]
+                        let globalCb = self.onPublish
                         self.lock.unlock()
+                        globalCb?(topic, payload)
                         cb?(payload)
 
                         if qos >= 1, let pid = packetId {
@@ -546,6 +610,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
@@ -117,6 +131,17 @@ public class MqttQuicPlugin: CAPPlugin, CAPBridgedPlugin {
                     break
                 }
                 client = MQTTClient(protocolVersion: protocolVersion)
+                // 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) { return str }
+                        return payload.base64EncodedString()
+                    }()
+                    DispatchQueue.main.async {
+                        self.notifyListeners("message", data: ["topic": topic as String, "payload": payloadStr as String])
+                    }
+                }
                 try await client.connect(
                     host: host,
                     port: UInt16(port),
@@ -257,14 +282,7 @@ public class MqttQuicPlugin: CAPPlugin, CAPBridgedPlugin {
         Task {
             do {
                 try await client.subscribe(topic: topic, qos: UInt8(min(qos, 2)), subscriptionIdentifier: subscriptionIdentifier)
-                // Deliver incoming PUBLISH for this topic to JS (avoids message loop having no handler; prevents stuck state)
-                client.onMessage(topic) { [weak self] payload in
-                    guard let self = self else { return }
-                    let str = String(data: payload, encoding: .utf8) ?? ""
-                    DispatchQueue.main.async {
-                        self.notifyListeners("message", data: ["topic": topic, "payload": str])
-                    }
-                }
+                // Incoming PUBLISH delivered via onPublish set in connect(); no per-topic handler needed
                 DispatchQueue.main.async { call.resolve(["success": true]) }
             } catch {
                 DispatchQueue.main.async { call.reject("\(error)") }

package/ios/Sources/MqttQuicPlugin/Transport/QUICStreamAdapter.swift

@@ -19,21 +19,16 @@ public final class QUICStreamReader: MQTTStreamReaderProtocol {
         try await stream.read(maxBytes: maxBytes)
     }
 
+    /// Read exactly n bytes. Waits indefinitely for data (matches Android behavior).
+    /// Previously had a 300ms limit which caused message loop to throw and disconnect before PUBLISH packets arrived.
     public func readexactly(_ n: Int) async throws -> Data {
         var acc = Data()
-        var emptyCount = 0
-        let maxEmptyRetries = 60  // ~300ms total (60 * 5ms) so SUBACK can arrive
         while acc.count < n {
             let chunk = try await stream.read(maxBytes: n - acc.count)
             if chunk.isEmpty {
-                emptyCount += 1
-                if emptyCount >= maxEmptyRetries {
-                    throw MQTTProtocolError.insufficientData("readexactly")
-                }
                 try await Task.sleep(nanoseconds: 5_000_000)  // 5ms
                 continue
             }
-            emptyCount = 0
             acc.append(chunk)
         }
         return acc

package/package.json

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