@annadata/capacitor-mqtt-quic 0.1.7 → 0.1.9

package/android/src/main/kotlin/ai/annadata/mqttquic/quic/QuicClientStub.kt

@@ -36,7 +36,7 @@ class QuicClientStub(private val initialReadData: List<Byte> = emptyList()) : Qu
     private var buffer: MockStreamBuffer? = null
     private var streamId = 0L
 
-    override suspend fun connect(host: String, port: Int) {
+    override suspend fun connect(host: String, port: Int, connectAddress: String?) {
         buffer = MockStreamBuffer(initialReadData.toByteArray())
         streamId = 0L
     }

package/android/src/main/kotlin/ai/annadata/mqttquic/quic/QuicTypes.kt

@@ -15,7 +15,7 @@ interface QuicStream {
  * QUIC client: connect, TLS handshake, open one bidirectional stream.
  */
 interface QuicClient {
-    suspend fun connect(host: String, port: Int)
+    suspend fun connect(host: String, port: Int, connectAddress: String? = null)
     suspend fun openStream(): QuicStream
     suspend fun close()
 }

package/android/src/main/kotlin/ai/annadata/mqttquic/transport/QUICStreamAdapter.kt

@@ -1,21 +1,96 @@
 package ai.annadata.mqttquic.transport
 
+import android.util.Log
+import ai.annadata.mqttquic.mqtt.MQTTProtocol
 import ai.annadata.mqttquic.quic.QuicStream
+import kotlinx.coroutines.delay
 
 /**
- * MQTTStreamReader over QUIC stream. Mirrors NGTCP2StreamReader.
+ * MQTTStreamReader over QUIC stream. Buffers excess bytes so readexactly(n)
+ * and read(maxBytes) get exactly the requested amount; native may return
+ * a full CONNACK (e.g. 18 bytes) in one read, so we must not lose the remainder.
+ *
+ * Efficient CONNACK/packet read: call [drain] to read until the stream has no more
+ * data, then [tryConsumeNextPacket] to take the first complete MQTT packet from
+ * the buffer. Repeat drain + tryConsumeNextPacket (with short delay) until you
+ * get a packet or timeout.
  */
 class QUICStreamReader(private val stream: QuicStream) : MQTTStreamReader {
 
-    override suspend fun read(maxBytes: Int): ByteArray = stream.read(maxBytes)
+    private val buffer = mutableListOf<Byte>()
+
+    override suspend fun available(): Int = buffer.size
+
+    /** Read from stream until no more data is available (drained). Call before tryConsumeNextPacket. */
+    suspend fun drain() {
+        while (true) {
+            val chunk = stream.read(8192)
+            if (chunk.isEmpty()) break
+            Log.i("MQTTClient", "QUICStreamReader: drain got ${chunk.size} bytes bufferTotal=${buffer.size + chunk.size}")
+            buffer.addAll(chunk.toList())
+        }
+    }
+
+    /** Consume the first n bytes from buffer and return them. Caller must ensure buffer.size >= n. */
+    fun consume(n: Int): ByteArray {
+        if (buffer.size < n) throw IllegalArgumentException("buffer has ${buffer.size} < $n")
+        val out = buffer.take(n).toByteArray()
+        repeat(n) { buffer.removeAt(0) }
+        return out
+    }
+
+    /**
+     * If buffer contains at least one complete MQTT packet (fixed header + payload), consume and return it; else return null.
+     * Call after [drain]; if null, delay and drain again (or timeout).
+     */
+    fun tryConsumeNextPacket(): ByteArray? {
+        val buf = buffer.toByteArray()
+        val totalLen = MQTTProtocol.getNextPacketLength(buf)
+        if (totalLen == null) {
+            if (buf.isNotEmpty()) {
+                Log.w("MQTTClient", "QUICStreamReader: getNextPacketLength returned null bufferSize=${buf.size} firstByte=0x${Integer.toHexString(buf[0].toInt() and 0xFF)}")
+            }
+            return null
+        }
+        if (buffer.size < totalLen) {
+            Log.i("MQTTClient", "QUICStreamReader: buffer.size=${buffer.size} < totalLen=$totalLen waiting for more")
+            return null
+        }
+        val packet = consume(totalLen)
+        Log.i("MQTTClient", "QUICStreamReader: tryConsumeNextPacket consumed $totalLen bytes type=0x${Integer.toHexString(packet[0].toInt() and 0xFF)}")
+        return packet
+    }
+
+    override suspend fun read(maxBytes: Int): ByteArray {
+        while (buffer.size < maxBytes) {
+            val chunk = stream.read(maxBytes - buffer.size)
+            if (chunk.isEmpty()) break
+            Log.i("MQTTClient", "QUICStreamReader: got chunk=${chunk.size} bufferSize=${buffer.size + chunk.size}")
+            buffer.addAll(chunk.toList())
+        }
+        val n = minOf(maxBytes, buffer.size)
+        if (n == 0) return ByteArray(0)
+        val result = buffer.subList(0, n).toByteArray()
+        repeat(n) { buffer.removeAt(0) }
+        Log.i("MQTTClient", "QUICStreamReader: returning $n bytes bufferRemain=${buffer.size}")
+        return result
+    }
 
     override suspend fun readexactly(n: Int): ByteArray {
+        Log.i("MQTTClient", "QUICStreamReader: readexactly($n) bufferHas=${buffer.size}")
         val acc = mutableListOf<Byte>()
         while (acc.size < n) {
-            val chunk = stream.read(n - acc.size)
-            if (chunk.isEmpty()) throw IllegalArgumentException("readexactly")
-            acc.addAll(chunk.toList())
+            drain()
+            val fromBuffer = minOf(n - acc.size, buffer.size)
+            if (fromBuffer > 0) {
+                acc.addAll(buffer.subList(0, fromBuffer).toList())
+                repeat(fromBuffer) { buffer.removeAt(0) }
+            } else {
+                // No data yet (e.g. message loop waiting for SUBACK/PUBLISH). Wait and retry instead of throwing.
+                delay(20L)
+            }
         }
+        Log.i("MQTTClient", "QUICStreamReader: readexactly($n) done")
         return acc.toByteArray()
     }
 }

package/android/src/main/kotlin/ai/annadata/mqttquic/transport/StreamTransport.kt

@@ -7,6 +7,8 @@ import kotlinx.coroutines.delay
  * Phase 2 implements over QUIC stream.
  */
 interface MQTTStreamReader {
+    /** Number of bytes currently buffered (without reading from stream). Used to skip unwanted packets only when safe. */
+    suspend fun available(): Int
     suspend fun read(maxBytes: Int): ByteArray
     suspend fun readexactly(n: Int): ByteArray
 }
@@ -50,6 +52,8 @@ class MockStreamBuffer(initialReadData: ByteArray = ByteArray(0)) {
  */
 class MockStreamReader(private val buffer: MockStreamBuffer) : MQTTStreamReader {
 
+    override suspend fun available(): Int = buffer.readBuffer.size
+
     override suspend fun read(maxBytes: Int): ByteArray {
         if (buffer.isClosed && buffer.readBuffer.isEmpty()) return ByteArray(0)
         val n = minOf(maxBytes, buffer.readBuffer.size)

package/docs/IMPLEMENTATION_SUMMARY.md

@@ -182,7 +182,7 @@ Implement `MqttQuicService` web fallback using `mqtt.js` or similar library.
 ```
 capacitor-mqtt-quic/
 ├── ios/
-│   ├── MqttQuicPlugin.podspec
+│   ├── AnnadataCapacitorMqttQuic.podspec
 │   └── Sources/MqttQuicPlugin/
 │       ├── MQTT/              # Phase 1
 │       ├── Transport/         # Phase 1, 2

package/docs/NGTCP2_IMPLEMENTATION_STATUS.md

@@ -129,7 +129,7 @@ The ngtcp2 integration replaces the stub QUIC implementations (`QuicClientStub`)
    - Implement TLS 1.3 handshake
    - Implement UDP packet handlers
 
-4. **Update `MqttQuicPlugin.podspec`:**
+4. **Update `AnnadataCapacitorMqttQuic.podspec`:**
    - Add ngtcp2 library linking
    - Add header search paths
 

package/docs/PRODUCTION_PUBLISH_STEPS.md

@@ -9,7 +9,7 @@ This checklist makes the plugin **production-grade**: pack everything needed (in
 ## Prerequisites
 
 - Node.js 18+
-- **iOS:** macOS, Xcode 14+
+- **iOS:** macOS, Xcode 15+
 - **Android:** Android Studio, NDK r25+ (e.g. via `$ANDROID_HOME/ndk/<version>`)
 - npm account with access to `@annadata` scope
 
@@ -32,9 +32,15 @@ This produces:
 
 The podspec’s `vendored_libraries` point at `ios/libs/`; these **must** be present when you pack/publish.
 
-### Android (optional but recommended for zero-config)
+### Android (required for zero-config / “complete” package)
 
-Android uses **WolfSSL** (same TLS backend as iOS). Build WolfSSL + nghttp3 + ngtcp2 for all ABIs so consumers don’t need to run the one-time setup:
+Android uses **WolfSSL** (same TLS backend as iOS). To ship a **complete** plugin so clients don’t run any native build, build WolfSSL + nghttp3 + ngtcp2 for all ABIs:
+
+```bash
+npm run build:android-prebuilts
+```
+
+Or manually:
 
 ```bash
 ./build-native.sh --android-only --abi arm64-v8a