@annadata/capacitor-mqtt-quic 0.2.0 → 0.2.1

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,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
@@ -550,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
@@ -120,14 +134,12 @@ 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])
+                        self.notifyListeners("message", data: ["topic": topic as String, "payload": payloadStr as String])
                     }
                 }
                 try await client.connect(

package/package.json

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