@annadata/capacitor-mqtt-quic 0.1.8 → 0.2.0

package/docs/diff-node_modules-vs-standalone-android-src.patch

@@ -0,0 +1,1031 @@
+diff -Naur capacitor-mqtt-quic/android/src/main/cpp/ngtcp2_jni.cpp annadata-app/node_modules/@annadata/capacitor-mqtt-quic/android/src/main/cpp/ngtcp2_jni.cpp
+--- capacitor-mqtt-quic/android/src/main/cpp/ngtcp2_jni.cpp	2026-02-18 22:28:55
++++ annadata-app/node_modules/@annadata/capacitor-mqtt-quic/android/src/main/cpp/ngtcp2_jni.cpp	2026-02-19 10:27:58
+@@ -24,6 +24,7 @@
+ #include <algorithm>
+ #include <atomic>
+ #include <chrono>
++#include <cinttypes>
+ #include <cstdarg>
+ #include <cstdlib>
+ #include <cstdio>
+@@ -73,7 +74,11 @@
+ class QuicClient {
+  public:
+   QuicClient(std::string host, uint16_t port)
+-      : host_(std::move(host)),
++      : QuicClient(std::move(host), "", port) {}
++
++  QuicClient(std::string host_for_tls, std::string connect_addr, uint16_t port)
++      : host_(std::move(host_for_tls)),
++        connect_addr_(connect_addr.empty() ? host_ : std::move(connect_addr)),
+         port_(port),
+         fd_(-1),
+         ssl_ctx_(nullptr),
+@@ -181,6 +186,9 @@
+       buffer[i] = state.recv_buf.front();
+       state.recv_buf.pop_front();
+     }
++    if (n > 0) {
++      LOGI("read_stream stream_id=%" PRId64 " returning %zu bytes", (int64_t)stream_id, n);
++    }
+     return (ssize_t)n;
+   }
+ 
+@@ -223,6 +231,8 @@
+     std::lock_guard<std::mutex> lock(stream_mutex_);
+     StreamState &state = streams_[stream_id];
+     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 (flags & NGTCP2_STREAM_DATA_FLAG_FIN) {
+       state.fin_received = true;
+     }
+@@ -254,7 +264,8 @@
+ 
+     char port_str[16];
+     snprintf(port_str, sizeof(port_str), "%u", port_);
+-    int rv = getaddrinfo(host_.c_str(), port_str, &hints, &res);
++    const char *resolve_host = connect_addr_.empty() ? host_.c_str() : connect_addr_.c_str();
++    int rv = getaddrinfo(resolve_host, port_str, &hints, &res);
+     if (rv != 0) {
+       setError(gai_strerror(rv));
+       return -1;
+@@ -269,6 +280,13 @@
+       if (::connect(fd, rp->ai_addr, rp->ai_addrlen) == 0) {
+         memcpy(&remote_addr_, rp->ai_addr, rp->ai_addrlen);
+         remote_addrlen_ = (socklen_t)rp->ai_addrlen;
++        char buf[INET6_ADDRSTRLEN];
++        const void *src = (rp->ai_family == AF_INET)
++            ? (void *)&((struct sockaddr_in *)rp->ai_addr)->sin_addr
++            : (void *)&((struct sockaddr_in6 *)rp->ai_addr)->sin6_addr;
++        if (inet_ntop(rp->ai_family, src, buf, sizeof(buf))) {
++          resolved_address_ = buf;
++        }
+         break;
+       }
+       ::close(fd);
+@@ -651,30 +669,44 @@
+   }
+ 
+   void cleanup() {
+-    if (conn_) {
+-      ngtcp2_conn_del(conn_);
++    ngtcp2_conn *conn_to_del = nullptr;
++    void *ssl_to_free = nullptr;
++    void *ssl_ctx_to_free = nullptr;
++    int fd_to_close = -1;
++    int wake0 = -1, wake1 = -1;
++    {
++      std::lock_guard<std::mutex> lock(cleanup_mutex_);
++      conn_to_del = conn_;
+       conn_ = nullptr;
+-    }
+-    if (ssl_) {
+-      wolfSSL_free(ssl_);
++      ssl_to_free = ssl_;
+       ssl_ = nullptr;
+-    }
+-    if (ssl_ctx_) {
+-      wolfSSL_CTX_free(ssl_ctx_);
++      ssl_ctx_to_free = ssl_ctx_;
+       ssl_ctx_ = nullptr;
+-    }
+-    if (fd_ != -1) {
+-      ::close(fd_);
++      fd_to_close = fd_;
+       fd_ = -1;
+-    }
+-    if (wakeup_fds_[0] != -1) {
+-      ::close(wakeup_fds_[0]);
++      wake0 = wakeup_fds_[0];
++      wake1 = wakeup_fds_[1];
+       wakeup_fds_[0] = -1;
+-    }
+-    if (wakeup_fds_[1] != -1) {
+-      ::close(wakeup_fds_[1]);
+       wakeup_fds_[1] = -1;
+     }
++    if (conn_to_del) {
++      ngtcp2_conn_del(conn_to_del);
++    }
++    if (ssl_to_free) {
++      wolfSSL_free(static_cast<WOLFSSL *>(ssl_to_free));
++    }
++    if (ssl_ctx_to_free) {
++      wolfSSL_CTX_free(static_cast<WOLFSSL_CTX *>(ssl_ctx_to_free));
++    }
++    if (fd_to_close != -1) {
++      ::close(fd_to_close);
++    }
++    if (wake0 != -1) {
++      ::close(wake0);
++    }
++    if (wake1 != -1) {
++      ::close(wake1);
++    }
+   }
+ 
+   void clearError() {
+@@ -766,9 +798,14 @@
+     return client->on_handshake_completed();
+   }
+ 
++ public:
++  const std::string &resolved_address() const { return resolved_address_; }
++
+  private:
+   std::string host_;
++  std::string connect_addr_;
+   uint16_t port_;
++  std::string resolved_address_;
+ 
+   int fd_;
+   struct sockaddr_storage remote_addr_;
+@@ -800,6 +837,8 @@
+ 
+   mutable std::mutex err_mutex_;
+   std::string last_error_str_;
++
++  std::mutex cleanup_mutex_;
+ };
+ 
+ static std::map<jlong, std::unique_ptr<QuicClient>> connections;
+@@ -827,6 +866,27 @@
+   return handle;
+ }
+ 
++JNIEXPORT jlong JNICALL
++Java_ai_annadata_mqttquic_quic_NGTCP2Client_nativeCreateConnectionWithAddress(
++    JNIEnv *env, jobject thiz, jstring hostnameForTls, jstring connectAddress, jint port) {
++  const char *tls_str = env->GetStringUTFChars(hostnameForTls, nullptr);
++  const char *addr_str = env->GetStringUTFChars(connectAddress, nullptr);
++  if (!tls_str || !addr_str) {
++    if (tls_str) env->ReleaseStringUTFChars(hostnameForTls, tls_str);
++    return 0;
++  }
++  std::string host_for_tls(tls_str);
++  std::string connect_addr(addr_str);
++  env->ReleaseStringUTFChars(hostnameForTls, tls_str);
++  env->ReleaseStringUTFChars(connectAddress, addr_str);
++
++  auto client = std::make_unique<QuicClient>(host_for_tls, connect_addr, (uint16_t)port);
++  std::lock_guard<std::mutex> lock(connections_mutex);
++  jlong handle = next_handle++;
++  connections[handle] = std::move(client);
++  return handle;
++}
++
+ JNIEXPORT jint JNICALL
+ Java_ai_annadata_mqttquic_quic_NGTCP2Client_nativeConnect(
+     JNIEnv *env, jobject thiz, jlong connHandle) {
+@@ -929,6 +989,21 @@
+     return env->NewStringUTF("invalid connection");
+   }
+   return env->NewStringUTF(it->second->last_error());
++}
++
++JNIEXPORT jstring JNICALL
++Java_ai_annadata_mqttquic_quic_NGTCP2Client_nativeGetLastResolvedAddress(
++    JNIEnv *env, jobject thiz, jlong connHandle) {
++  std::lock_guard<std::mutex> lock(connections_mutex);
++  auto it = connections.find(connHandle);
++  if (it == connections.end()) {
++    return nullptr;
++  }
++  const std::string &addr = it->second->resolved_address();
++  if (addr.empty()) {
++    return nullptr;
++  }
++  return env->NewStringUTF(addr.c_str());
+ }
+ 
+ // Debug-build alias: Kotlin/AGP can mangle the method name to include the module suffix.
+diff -Naur capacitor-mqtt-quic/android/src/main/kotlin/ai/annadata/mqttquic/MqttQuicPlugin.kt annadata-app/node_modules/@annadata/capacitor-mqtt-quic/android/src/main/kotlin/ai/annadata/mqttquic/MqttQuicPlugin.kt
+--- capacitor-mqtt-quic/android/src/main/kotlin/ai/annadata/mqttquic/MqttQuicPlugin.kt	2026-02-18 22:28:55
++++ annadata-app/node_modules/@annadata/capacitor-mqtt-quic/android/src/main/kotlin/ai/annadata/mqttquic/MqttQuicPlugin.kt	2026-02-19 10:26:46
+@@ -13,10 +13,13 @@
+ import android.util.Base64
+ import kotlinx.coroutines.CoroutineScope
+ import kotlinx.coroutines.Dispatchers
++import kotlinx.coroutines.delay
+ import kotlinx.coroutines.launch
++import kotlinx.coroutines.withContext
+ import java.nio.charset.StandardCharsets
+ import java.io.File
+ import java.io.IOException
++import java.net.InetAddress
+ 
+ /**
+  * Capacitor plugin bridge. Phase 3: connect/publish/subscribe call into MQTTClient.
+@@ -27,6 +30,29 @@
+     private var client = MQTTClient(MQTTClient.ProtocolVersion.AUTO)
+     private val scope = CoroutineScope(Dispatchers.Main)
+ 
++    /** Last resolved IP per host (used when DNS fails on reconnect). */
++    @Volatile
++    private var lastResolvedHost: String? = null
++    @Volatile
++    private var lastResolvedIp: String? = null
++
++    /** Resolve hostname to IP for socket connect (avoids "No address" on reconnect). Returns null if resolution fails. */
++    private fun resolveHostToIp(host: String): String? {
++        return try {
++            InetAddress.getAllByName(host).firstOrNull()?.hostAddress?.also { ip ->
++                lastResolvedHost = host
++                lastResolvedIp = ip
++            }
++        } catch (e: Exception) {
++            null
++        }
++    }
++
++    /** Use cached IP for this host if fresh resolve failed (e.g. on reconnect). */
++    private fun resolveOrCachedIp(host: String): String? {
++        return resolveHostToIp(host) ?: if (host == lastResolvedHost) lastResolvedIp else null
++    }
++
+     private fun bundledCaFilePath(): String? {
+         return try {
+             val assetName = "mqttquic_ca.pem"
+@@ -100,9 +126,38 @@
+                         notifyListeners("message", data)
+                     }
+                 }
+-                client.connect(host, port, clientId, username, password, cleanSession ?: true, keepalive ?: 20, sessionExpiryInterval)
+-                call.resolve(JSObject().put("connected", true))
+-                notifyListeners("connected", JSObject().put("connected", true))
++                // Resolve host to IP on IO so native getaddrinfo gets an IP (avoids "No address associated with hostname" on reconnect)
++                val noAddressMsg = "No address associated with hostname"
++                var lastException: Exception? = null
++                for (attempt in 1..2) {
++                    try {
++                        withContext(Dispatchers.IO) {
++                            val resolvedIp = resolveOrCachedIp(host)
++                            client.connect(host, port, clientId, username, password, cleanSession ?: true, keepalive ?: 20, sessionExpiryInterval, connectAddress = resolvedIp)
++                        }
++                        // Cache resolved IP from native so reconnect can use it when Java DNS fails
++                        client.getLastResolvedAddress()?.let { ip ->
++                            lastResolvedHost = host
++                            lastResolvedIp = ip
++                        }
++                        call.resolve(JSObject().put("connected", true))
++                        notifyListeners("connected", JSObject().put("connected", true))
++                        return@launch
++                    } catch (e: Exception) {
++                        // Cache resolved IP from native even on failure (e.g. CONNACK timeout) so reconnect can use it
++                        client.getLastResolvedAddress()?.let { ip ->
++                            lastResolvedHost = host
++                            lastResolvedIp = ip
++                        }
++                        lastException = e
++                        if (attempt == 1 && e.message?.contains(noAddressMsg, ignoreCase = true) == true) {
++                            delay(2000L)
++                            continue
++                        }
++                        break
++                    }
++                }
++                call.reject(lastException?.message ?: "Connection failed")
+             } catch (e: Exception) {
+                 call.reject(e.message ?: "Connection failed")
+             }
+diff -Naur capacitor-mqtt-quic/android/src/main/kotlin/ai/annadata/mqttquic/client/MQTTClient.kt annadata-app/node_modules/@annadata/capacitor-mqtt-quic/android/src/main/kotlin/ai/annadata/mqttquic/client/MQTTClient.kt
+--- capacitor-mqtt-quic/android/src/main/kotlin/ai/annadata/mqttquic/client/MQTTClient.kt	2026-02-19 13:50:48
++++ annadata-app/node_modules/@annadata/capacitor-mqtt-quic/android/src/main/kotlin/ai/annadata/mqttquic/client/MQTTClient.kt	2026-02-19 12:34:46
+@@ -1,5 +1,6 @@
+ package ai.annadata.mqttquic.client
+ 
++import android.util.Log
+ import ai.annadata.mqttquic.mqtt.MQTT5PropertyType
+ import ai.annadata.mqttquic.mqtt.MQTTConnAckCode
+ import ai.annadata.mqttquic.mqtt.MQTTMessageType
+@@ -15,6 +16,7 @@
+ import ai.annadata.mqttquic.transport.MQTTStreamWriter
+ import ai.annadata.mqttquic.transport.QUICStreamReader
+ import ai.annadata.mqttquic.transport.QUICStreamWriter
++import kotlinx.coroutines.CompletableDeferred
+ import kotlinx.coroutines.CoroutineScope
+ import kotlinx.coroutines.Dispatchers
+ import kotlinx.coroutines.delay
+@@ -24,6 +26,9 @@
+ import kotlinx.coroutines.sync.Mutex
+ import kotlinx.coroutines.sync.withLock
+ import kotlinx.coroutines.SupervisorJob
++import kotlinx.coroutines.CancellationException
++import kotlinx.coroutines.TimeoutCancellationException
++import kotlinx.coroutines.withTimeout
+ 
+ /**
+  * High-level MQTT client: connect, publish, subscribe, disconnect.
+@@ -62,6 +67,10 @@
+     var onPublish: ((String, ByteArray) -> Unit)? = null
+     /** Per-connection Topic Alias map (alias -> topic name) for MQTT 5.0 incoming PUBLISH. */
+     private val topicAliasMap = mutableMapOf<Int, String>()
++    /** Pending SUBACK by packet ID. Message loop completes with (fullPacket, hdrLen). Single reader: only message loop reads stream. */
++    private val pendingSubacks = mutableMapOf<Int, CompletableDeferred<Pair<ByteArray, Int>>>()
++    /** Pending UNSUBACK by packet ID. Message loop completes when UNSUBACK is read. */
++    private val pendingUnsubacks = mutableMapOf<Int, CompletableDeferred<Unit>>()
+     private val lock = Mutex()
+     private val scope = CoroutineScope(Dispatchers.Default + SupervisorJob())
+ 
+@@ -77,6 +86,29 @@
+     /** Assigned Client Identifier from CONNACK when client sent empty ClientID; null otherwise. */
+     fun getAssignedClientIdentifier(): String? = runBlocking { lock.withLock { assignedClientIdentifier } }
+ 
++    /** Resolved IP used for the current/last QUIC connection (from native getaddrinfo). Used by plugin to cache for reconnect when Java DNS fails. */
++    fun getLastResolvedAddress(): String? = (quicClient as? NGTCP2Client)?.getLastResolvedAddress()
++
++    /** Read full MQTT fixed header (1 byte type + 1–4 bytes remaining length per MQTT v5.0 §2.1.4). Returns (msgType, remLen, fixedHeaderBytes). */
++    private suspend fun readFixedHeader(r: MQTTStreamReader): Triple<Byte, Int, ByteArray> {
++        Log.i("MQTTClient", "readFixedHeader: requesting first byte")
++        var fixed = r.readexactly(1).toMutableList()
++        val firstByte = fixed[0].toInt() and 0xFF
++        Log.i("MQTTClient", "readFixedHeader: got type byte 0x${Integer.toHexString(firstByte)} ($firstByte)")
++        repeat(5) { // 1 type + up to 4 remaining-length bytes (Variable Byte Integer)
++            try {
++                val (rem, _) = MQTTProtocol.decodeRemainingLength(fixed.toByteArray(), 1)
++                Log.i("MQTTClient", "readFixedHeader: decoded remLen=$rem fixedSize=${fixed.size}")
++                return Triple(fixed[0], rem, fixed.toByteArray())
++            } catch (_: IllegalArgumentException) {
++                if (fixed.size > 5) throw IllegalArgumentException("Invalid remaining length")
++                fixed.addAll(r.readexactly(1).toList())
++                Log.i("MQTTClient", "readFixedHeader: added byte, fixedSize=${fixed.size}")
++            }
++        }
++        throw IllegalArgumentException("Invalid remaining length")
++    }
++
+     suspend fun connect(
+         host: String,
+         port: Int,
+@@ -85,7 +117,8 @@
+         password: String?,
+         cleanSession: Boolean,
+         keepalive: Int,
+-        sessionExpiryInterval: Int? = null
++        sessionExpiryInterval: Int? = null,
++        connectAddress: String? = null
+     ) {
+         lock.withLock {
+             if (state == State.CONNECTING) {
+@@ -109,7 +142,7 @@
+             } else {
+                 QuicClientStub(connack.toList())
+             }
+-            quic.connect(host, port)
++            quic.connect(host, port, connectAddress)
+             val s = quic.openStream()
+             val r = QUICStreamReader(s)
+             val w = QUICStreamWriter(s)
+@@ -146,50 +179,118 @@
+             w.write(connectData)
+             w.drain()
+ 
+-            // MQTT 5.0: server may send AUTH before CONNACK; loop until CONNACK
++            // MQTT 5.0: server may send AUTH before CONNACK; loop until CONNACK. Timeout so we don't block 30s until ERR_IDLE_CLOSE.
++            // Efficient path: drain stream (read until empty), then parse first complete packet; repeat until CONNACK or timeout.
+             var full: ByteArray
+             var hdrLen: Int
+-            if (activeProtocolVersion == MQTTProtocolLevel.V5) {
+-                while (true) {
+-                    val fixed = r.readexactly(2)
+-                    val (msgType, remLen, hLen) = MQTTProtocol.parseFixedHeader(fixed)
+-                    val rest = r.readexactly(remLen)
+-                    full = fixed + rest
+-                    hdrLen = hLen
+-                    when (msgType) {
+-                        MQTTMessageType.CONNACK -> break
+-                        MQTTMessageType.AUTH -> {
+-                            lock.withLock { state = State.ERROR }
+-                            try {
+-                                w.write(MQTT5Protocol.buildDisconnectV5(MQTT5ReasonCode.BAD_AUTHENTICATION_METHOD_DISC))
+-                                w.drain()
+-                                w.close()
+-                            } catch (_: Exception) { /* ignore */ }
+-                            throw IllegalArgumentException("Enhanced authentication not supported")
++            val connackTimeoutMs = 15_000L
++            try {
++                if (activeProtocolVersion == MQTTProtocolLevel.V5) {
++                    Log.i("MQTTClient", "reading CONNACK (MQTT5) timeout=${connackTimeoutMs}ms (drain then parse)")
++                    withTimeout(connackTimeoutMs) {
++                        while (true) {
++                            if (r is QUICStreamReader) {
++                                r.drain()
++                                val avail = r.available()
++                                Log.i("MQTTClient", "CONNACK loop: after drain available=$avail")
++                                val packet = r.tryConsumeNextPacket()
++                                if (packet != null) {
++                                    val (msgType, _, fixedLen) = MQTTProtocol.parseFixedHeader(packet.copyOf(minOf(5, packet.size)))
++                                    val typeByte = msgType.toInt() and 0xFF
++                                    Log.i("MQTTClient", "CONNACK loop: packet type=0x${Integer.toHexString(typeByte)} len=${packet.size} hdrLen=$fixedLen")
++                                    when (typeByte) {
++                                        0x20 -> {
++                                            full = packet
++                                            hdrLen = fixedLen
++                                            return@withTimeout
++                                        }
++                                        0xF0 -> {
++                                            lock.withLock { state = State.ERROR }
++                                            try {
++                                                w.write(MQTT5Protocol.buildDisconnectV5(MQTT5ReasonCode.BAD_AUTHENTICATION_METHOD_DISC))
++                                                w.drain()
++                                                w.close()
++                                            } catch (_: Exception) { /* ignore */ }
++                                            throw IllegalArgumentException("Enhanced authentication not supported")
++                                        }
++                                        0xE0 -> {
++                                            lock.withLock { state = State.ERROR }
++                                            throw IllegalArgumentException("Server sent DISCONNECT before CONNACK")
++                                        }
++                                        else -> Log.i("MQTTClient", "CONNACK loop: skipping non-CONNACK packet type=0x${Integer.toHexString(typeByte)}")
++                                    }
++                                } else {
++                                    // Only delay when no data; if we have data but no packet, retry soon (avoid suspend then timeout before next iteration)
++                                    if (avail == 0) delay(50) else delay(10)
++                                }
++                            } else {
++                                // Fallback for non-QUIC reader (e.g. mock)
++                                val (msgType, remLen, fixed) = readFixedHeader(r)
++                                val typeByte = fixed[0].toInt() and 0xFF
++                                val rest = r.readexactly(remLen)
++                                full = fixed + rest
++                                hdrLen = fixed.size
++                                when (typeByte) {
++                                    0x20 -> return@withTimeout
++                                    0xF0 -> {
++                                        lock.withLock { state = State.ERROR }
++                                        try {
++                                            w.write(MQTT5Protocol.buildDisconnectV5(MQTT5ReasonCode.BAD_AUTHENTICATION_METHOD_DISC))
++                                            w.drain()
++                                            w.close()
++                                        } catch (_: Exception) { /* ignore */ }
++                                        throw IllegalArgumentException("Enhanced authentication not supported")
++                                    }
++                                    0xE0 -> {
++                                        lock.withLock { state = State.ERROR }
++                                        throw IllegalArgumentException("Server sent DISCONNECT before CONNACK")
++                                    }
++                                    else -> { /* skip; continue */ }
++                                }
++                            }
+                         }
+-                        MQTTMessageType.DISCONNECT -> {
+-                            lock.withLock { state = State.ERROR }
+-                            throw IllegalArgumentException("Server sent DISCONNECT before CONNACK")
++                    }
++                    Log.i("MQTTClient", "got CONNACK (MQTT5) (fullLen=${full.size} hdrLen=$hdrLen)")
++                } else {
++                    Log.i("MQTTClient", "reading CONNACK (3.1.1) timeout=${connackTimeoutMs}ms")
++                    withTimeout(connackTimeoutMs) {
++                        if (r is QUICStreamReader) {
++                            while (true) {
++                                r.drain()
++                                val packet = r.tryConsumeNextPacket()
++                                if (packet != null) {
++                                    val (msgType, _, fixedLen) = MQTTProtocol.parseFixedHeader(packet.copyOf(minOf(5, packet.size)))
++                                    if (msgType == MQTTMessageType.CONNACK) {
++                                        full = packet
++                                        hdrLen = fixedLen
++                                        break
++                                    }
++                                    lock.withLock { state = State.ERROR }
++                                    throw IllegalArgumentException("expected CONNACK, got $msgType")
++                                }
++                                delay(50)
++                            }
++                        } else {
++                            val (msgType, remLen, fixed) = readFixedHeader(r)
++                            val rest = r.readexactly(remLen)
++                            full = fixed + rest
++                            hdrLen = fixed.size
++                            if (msgType != MQTTMessageType.CONNACK) {
++                                lock.withLock { state = State.ERROR }
++                                throw IllegalArgumentException("expected CONNACK, got $msgType")
++                            }
+                         }
+-                        else -> {
+-                            lock.withLock { state = State.ERROR }
+-                            throw IllegalArgumentException("Expected CONNACK or AUTH, got $msgType")
+-                        }
++                        Log.i("MQTTClient", "got CONNACK (3.1.1)")
+                     }
+                 }
+-            } else {
+-                val fixed = r.readexactly(2)
+-                val (msgType, remLen, hLen) = MQTTProtocol.parseFixedHeader(fixed)
+-                val rest = r.readexactly(remLen)
+-                full = fixed + rest
+-                hdrLen = hLen
+-                if (msgType != MQTTMessageType.CONNACK) {
+-                    lock.withLock { state = State.ERROR }
+-                    throw IllegalArgumentException("expected CONNACK, got $msgType")
+-                }
++            } catch (e: TimeoutCancellationException) {
++                lock.withLock { state = State.ERROR }
++                Log.w("MQTTClient", "CONNACK read timed out after ${connackTimeoutMs}ms", e)
++                throw IllegalStateException("CONNACK read timed out. Drain+parse did not receive a complete CONNACK in time. Ask server to send full CONNACK (loop writev_stream until all bytes sent); or check network.", e)
+             }
+ 
+             if (activeProtocolVersion == MQTTProtocolLevel.V5) {
++                Log.i("MQTTClient", "parsing CONNACK v5 (offset=$hdrLen)")
+                 val (_, reasonCode, props) = MQTT5Protocol.parseConnackV5(full, hdrLen)
+                 if (reasonCode != MQTT5ReasonCode.SUCCESS) {
+                     lock.withLock { state = State.ERROR }
+@@ -210,21 +311,37 @@
+             }
+ 
+             lock.withLock { state = State.CONNECTED }
++            Log.i("MQTTClient", "state=CONNECTED, starting message and keepalive loops")
+             startMessageLoop()
+             startKeepaliveLoop()
+         } catch (e: Exception) {
+-            val wr = lock.withLock {
++            val (wr, quic) = lock.withLock {
+                 val w = writer
++                val q = quicClient
+                 quicClient = null
+                 stream = null
+                 reader = null
+                 writer = null
+                 state = State.ERROR
+-                w
++                Pair(w, q)
+             }
+             try {
+                 wr?.close()
+             } catch (_: Exception) { /* ignore */ }
++            // Skip quic.close() on timeout/cancellation: server may have already sent idle close, and native close() can crash. Prefer leak over crash.
++            val isTimeoutOrCancel = e is TimeoutCancellationException ||
++                e is CancellationException ||
++                e.cause is TimeoutCancellationException ||
++                (e.message?.contains("Timed out", ignoreCase = true) == true)
++            if (!isTimeoutOrCancel) {
++                try {
++                    quic?.close()
++                } catch (ex: Exception) {
++                    Log.w("MQTTClient", "Error closing QUIC connection on connect failure", ex)
++                }
++            } else {
++                Log.i("MQTTClient", "Skipping quic.close() on timeout/cancellation to avoid native crash")
++            }
+             throw e
+         }
+     }
+@@ -260,59 +377,66 @@
+ 
+     suspend fun subscribe(topic: String, qos: Int, subscriptionIdentifier: Int? = null) {
+         if (getState() != State.CONNECTED) throw IllegalStateException("not connected")
+-        val (r, w, version) = lock.withLock { Triple(reader, writer, activeProtocolVersion) }
+-        if (r == null || w == null) throw IllegalStateException("no reader/writer")
++        val (w, version) = lock.withLock { writer to activeProtocolVersion }
++        if (w == null) throw IllegalStateException("no writer")
+ 
+         val pid = nextPacketIdUsed()
+-        val data: ByteArray
+-        if (version == MQTTProtocolLevel.V5) {
+-            data = MQTT5Protocol.buildSubscribeV5(pid, topic, qos, subscriptionIdentifier)
+-        } else {
+-            data = MQTTProtocol.buildSubscribe(pid, topic, qos)
+-        }
+-        w.write(data)
+-        w.drain()
++        val deferred = CompletableDeferred<Pair<ByteArray, Int>>()
++        lock.withLock { pendingSubacks[pid] = deferred }
++        try {
++            val data: ByteArray
++            if (version == MQTTProtocolLevel.V5) {
++                data = MQTT5Protocol.buildSubscribeV5(pid, topic, qos, subscriptionIdentifier)
++            } else {
++                data = MQTTProtocol.buildSubscribe(pid, topic, qos)
++            }
++            w.write(data)
++            w.drain()
+ 
+-        val fixed = r.readexactly(2)
+-        val (_, remLen, hdrLen) = MQTTProtocol.parseFixedHeader(fixed)
+-        val rest = r.readexactly(remLen)
+-        val full = fixed + rest
+-        
+-        if (version == MQTTProtocolLevel.V5) {
+-            val (_, reasonCodes, _) = MQTT5Protocol.parseSubackV5(full, hdrLen)
+-            if (reasonCodes.isNotEmpty()) {
+-                val firstRC = reasonCodes[0]
+-                if (firstRC != MQTT5ReasonCode.GRANTED_QOS_0 && firstRC != MQTT5ReasonCode.GRANTED_QOS_1 && firstRC != MQTT5ReasonCode.GRANTED_QOS_2) {
+-                    throw IllegalArgumentException("SUBACK error $firstRC")
++            val (full, hdrLen) = withTimeout(15_000L) { deferred.await() }
++
++            if (version == MQTTProtocolLevel.V5) {
++                val (_, reasonCodes, _) = MQTT5Protocol.parseSubackV5(full, hdrLen)
++                if (reasonCodes.isNotEmpty()) {
++                    val firstRC = reasonCodes[0]
++                    if (firstRC != MQTT5ReasonCode.GRANTED_QOS_0 && firstRC != MQTT5ReasonCode.GRANTED_QOS_1 && firstRC != MQTT5ReasonCode.GRANTED_QOS_2) {
++                        throw IllegalArgumentException("SUBACK error $firstRC")
++                    }
+                 }
++            } else {
++                val (_, rc, _) = MQTTProtocol.parseSuback(full, hdrLen)
++                if (rc > 0x02) throw IllegalArgumentException("SUBACK error $rc")
+             }
+-        } else {
+-            val (_, rc, _) = MQTTProtocol.parseSuback(full, hdrLen)
+-            if (rc > 0x02) throw IllegalArgumentException("SUBACK error $rc")
++        } finally {
++            lock.withLock { pendingSubacks.remove(pid) }
+         }
+     }
+ 
+     suspend fun unsubscribe(topic: String) {
+         if (getState() != State.CONNECTED) throw IllegalStateException("not connected")
+-        val (r, w, version) = lock.withLock {
++        val (w, version) = lock.withLock {
+             subscribedTopics.remove(topic)
+-            Triple(reader, writer, activeProtocolVersion)
++            writer to activeProtocolVersion
+         }
+-        if (r == null || w == null) throw IllegalStateException("no reader/writer")
++        if (w == null) throw IllegalStateException("no writer")
+ 
+         val pid = nextPacketIdUsed()
+-        val data: ByteArray
+-        if (version == MQTTProtocolLevel.V5) {
+-            data = MQTT5Protocol.buildUnsubscribeV5(pid, listOf(topic))
+-        } else {
+-            data = MQTTProtocol.buildUnsubscribe(pid, listOf(topic))
+-        }
+-        w.write(data)
+-        w.drain()
++        val deferred = CompletableDeferred<Unit>()
++        lock.withLock { pendingUnsubacks[pid] = deferred }
++        try {
++            val data: ByteArray
++            if (version == MQTTProtocolLevel.V5) {
++                data = MQTT5Protocol.buildUnsubscribeV5(pid, listOf(topic))
++            } else {
++                data = MQTTProtocol.buildUnsubscribe(pid, listOf(topic))
++            }
++            w.write(data)
++            w.drain()
+ 
+-        val fixed = r.readexactly(2)
+-        val (_, remLen, _) = MQTTProtocol.parseFixedHeader(fixed)
+-        r.readexactly(remLen)
++            withTimeout(15_000L) { deferred.await() }
++        } finally {
++            lock.withLock { pendingUnsubacks.remove(pid) }
++        }
+     }
+ 
+     suspend fun disconnect() {
+@@ -323,6 +447,8 @@
+         job?.cancel()
+         job?.join()
+ 
++        failPendingSubacksUnsubacks(IllegalStateException("Disconnected"))
++
+         val (w, version) = lock.withLock {
+             val wr = writer
+             val v = activeProtocolVersion
+@@ -369,6 +495,15 @@
+         pid
+     }
+ 
++    private suspend fun failPendingSubacksUnsubacks(cause: Throwable) {
++        lock.withLock {
++            pendingSubacks.values.forEach { it.completeExceptionally(cause) }
++            pendingSubacks.clear()
++            pendingUnsubacks.values.forEach { it.completeExceptionally(cause) }
++            pendingUnsubacks.clear()
++        }
++    }
++
+     /** Send PINGREQ at effectiveKeepalive interval so server sees activity and does not close (idle/keepalive). [MQTT-3.1.2-20] */
+     private fun startKeepaliveLoop() {
+         keepaliveJob?.cancel()
+@@ -394,11 +529,24 @@
+             while (isActive) {
+                 val r = lock.withLock { reader } ?: break
+                 try {
+-                    val fixed = r.readexactly(2)
+-                    val (msgType, remLen, _) = MQTTProtocol.parseFixedHeader(fixed)
++                    val (msgType, remLen, fixed) = readFixedHeader(r)
+                     val rest = r.readexactly(remLen)
+                     val type = (msgType.toInt() and 0xF0).toByte()
+                     when (type) {
++                        MQTTMessageType.SUBACK -> {
++                            if (rest.size >= 2) {
++                                val pid = ((rest[0].toInt() and 0xFF) shl 8) or (rest[1].toInt() and 0xFF)
++                                val full = fixed + rest
++                                val hdrLen = fixed.size
++                                lock.withLock { pendingSubacks.remove(pid)?.complete(Pair(full, hdrLen)) }
++                            }
++                        }
++                        MQTTMessageType.UNSUBACK -> {
++                            if (rest.size >= 2) {
++                                val pid = ((rest[0].toInt() and 0xFF) shl 8) or (rest[1].toInt() and 0xFF)
++                                lock.withLock { pendingUnsubacks.remove(pid)?.complete(Unit) }
++                            }
++                        }
+                         MQTTMessageType.DISCONNECT -> {
+                             val reasonCode = if (rest.isNotEmpty()) rest[0].toInt() and 0xFF else 0x00
+                             lock.withLock {
+@@ -412,6 +560,7 @@
+                                 topicAliasMap.clear()
+                                 state = if (reasonCode >= 0x80) State.ERROR else State.DISCONNECTED
+                             }
++                            failPendingSubacksUnsubacks(IllegalStateException("Server sent DISCONNECT"))
+                             break
+                         }
+                         MQTTMessageType.PINGREQ -> {
+@@ -473,6 +622,7 @@
+                             topicAliasMap.clear()
+                             state = State.DISCONNECTED
+                         }
++                        failPendingSubacksUnsubacks(e)
+                     }
+                     break
+                 }
+diff -Naur capacitor-mqtt-quic/android/src/main/kotlin/ai/annadata/mqttquic/mqtt/MQTTProtocol.kt annadata-app/node_modules/@annadata/capacitor-mqtt-quic/android/src/main/kotlin/ai/annadata/mqttquic/mqtt/MQTTProtocol.kt
+--- capacitor-mqtt-quic/android/src/main/kotlin/ai/annadata/mqttquic/mqtt/MQTTProtocol.kt	2026-02-19 13:50:43
++++ annadata-app/node_modules/@annadata/capacitor-mqtt-quic/android/src/main/kotlin/ai/annadata/mqttquic/mqtt/MQTTProtocol.kt	2026-02-19 13:05:52
+@@ -40,10 +40,10 @@
+             val b = data[i].toInt() and 0xFF
+             len += (b and 0x7F) * mul
+             i++
+-            if ((b and 0x80) == 0) return@repeat
++            if ((b and 0x80) == 0) return len to (i - offset)
+             mul *= 128
+         }
+-        return len to (i - offset)
++        throw IllegalArgumentException("Invalid remaining length (max 4 bytes)")
+     }
+ 
+     fun encodeString(s: String): ByteArray {
+@@ -73,6 +73,37 @@
+         val msgType = data[0]
+         val (rem, consumed) = decodeRemainingLength(data, 1)
+         return Triple(msgType, rem, 1 + consumed)
++    }
++
++    /**
++     * Returns total MQTT packet length (fixed header + payload) if buffer has at least a decodable fixed header, else null.
++     * Use when draining stream: accumulate bytes, then call this; when buffer.size >= length, you have a complete packet.
++     */
++    fun getNextPacketLength(buffer: ByteArray): Int? {
++        if (buffer.size < 2) return null
++        // CONNACK (0x20): often single-byte remaining length (e.g. 0x20 = 32 → total 34). Handle that first.
++        if (buffer[0].toInt() and 0xFF == 0x20) {
++            val b1 = buffer[1].toInt() and 0xFF
++            if ((b1 and 0x80) == 0) {
++                val rem = b1
++                val total = 1 + 1 + rem
++                if (total <= buffer.size) return total
++            } else {
++                try {
++                    val (rem, consumed) = decodeRemainingLength(buffer, 1)
++                    val total = 1 + consumed + rem
++                    if (total <= buffer.size) return total
++                } catch (_: IllegalArgumentException) { /* fall through */ }
++            }
++        }
++        for (len in minOf(5, buffer.size) downTo 2) {
++            try {
++                val (_, rem, fixedLen) = parseFixedHeader(buffer.copyOf(len))
++                val total = fixedLen + rem
++                if (total in 1..buffer.size) return total
++            } catch (_: IllegalArgumentException) { /* need more bytes for remaining length */ }
++        }
++        return null
+     }
+ 
+     fun buildConnect(
+diff -Naur capacitor-mqtt-quic/android/src/main/kotlin/ai/annadata/mqttquic/quic/NGTCP2Client.kt annadata-app/node_modules/@annadata/capacitor-mqtt-quic/android/src/main/kotlin/ai/annadata/mqttquic/quic/NGTCP2Client.kt
+--- capacitor-mqtt-quic/android/src/main/kotlin/ai/annadata/mqttquic/quic/NGTCP2Client.kt	2026-02-19 13:50:50
++++ annadata-app/node_modules/@annadata/capacitor-mqtt-quic/android/src/main/kotlin/ai/annadata/mqttquic/quic/NGTCP2Client.kt	2026-02-19 12:10:12
+@@ -40,22 +40,28 @@
+     
+     // Native methods (implemented in ngtcp2_jni.cpp)
+     private external fun nativeCreateConnection(host: String, port: Int): Long
++    private external fun nativeCreateConnectionWithAddress(hostnameForTls: String, connectAddress: String, port: Int): Long
+     private external fun nativeConnect(connHandle: Long): Int
+     private external fun nativeOpenStream(connHandle: Long): Long
+     private external fun nativeWriteStream(connHandle: Long, streamId: Long, data: ByteArray): Int
+     private external fun nativeReadStream(connHandle: Long, streamId: Long): ByteArray?
+     private external fun nativeClose(connHandle: Long)
+     private external fun nativeIsConnected(connHandle: Long): Boolean
+-    internal external fun nativeCloseStream(connHandle: Long, streamId: Long): Int
++    // Public to avoid Kotlin internal-name mangling (nativeCloseStream$module) which breaks JNI lookup
++    external fun nativeCloseStream(connHandle: Long, streamId: Long): Int
+     @JvmName("nativeGetLastError")
+-    internal external fun nativeGetLastError(connHandle: Long): String
+-    
++    external fun nativeGetLastError(connHandle: Long): String
++    private external fun nativeGetLastResolvedAddress(connHandle: Long): String?
++
++    /** Resolved IP used for this connection (set after init_socket in native). Use for reconnect cache when Java DNS fails. */
++    fun getLastResolvedAddress(): String? = if (connHandle != 0L) nativeGetLastResolvedAddress(connHandle) else null
++
+     // Connection state
+     private var connHandle: Long = 0
+     private var isConnected: Boolean = false
+     private val streams = mutableMapOf<Long, NGTCP2Stream>()
+     
+-    override suspend fun connect(host: String, port: Int) {
++    override suspend fun connect(host: String, port: Int, connectAddress: String?) {
+         if (!isAvailable()) {
+             throw IllegalStateException("ngtcp2 native library is not loaded")
+         }
+@@ -63,8 +69,12 @@
+             throw IllegalStateException("Already connected")
+         }
+         
+-        // Create native connection
+-        connHandle = nativeCreateConnection(host, port)
++        // Create native connection (use pre-resolved IP when given to avoid "No address" on reconnect)
++        connHandle = if (!connectAddress.isNullOrBlank()) {
++            nativeCreateConnectionWithAddress(host, connectAddress, port)
++        } else {
++            nativeCreateConnection(host, port)
++        }
+         if (connHandle == 0L) {
+             throw IllegalStateException("Failed to create QUIC connection")
+         }
+@@ -147,19 +157,19 @@
+     
+     private var isClosed: Boolean = false
+     
++    /**
++     * Read up to maxBytes from the stream. Returns immediately with whatever is
++     * currently available (possibly empty). This allows drain()-then-parse logic
++     * to complete: first read returns CONNACK bytes, second read returns empty
++     * so drain() breaks and tryConsumeNextPacket() can run. Never blocks waiting
++     * for more data (native recv_buf is already populated by the event loop).
++     */
+     override suspend fun read(maxBytes: Int): ByteArray {
+         if (isClosed) {
+             throw IllegalStateException("Stream is closed")
+         }
+-
+-        while (!isClosed) {
+-            val data = client.readStreamData(streamId)
+-            if (data != null && data.isNotEmpty()) {
+-                return data
+-            }
+-            delay(5)
+-        }
+-        return ByteArray(0)
++        val data = client.readStreamData(streamId) ?: return ByteArray(0)
++        return data
+     }
+     
+     override suspend fun write(data: ByteArray) {
+diff -Naur capacitor-mqtt-quic/android/src/main/kotlin/ai/annadata/mqttquic/quic/QuicClientStub.kt annadata-app/node_modules/@annadata/capacitor-mqtt-quic/android/src/main/kotlin/ai/annadata/mqttquic/quic/QuicClientStub.kt
+--- capacitor-mqtt-quic/android/src/main/kotlin/ai/annadata/mqttquic/quic/QuicClientStub.kt	2026-02-18 22:28:55
++++ annadata-app/node_modules/@annadata/capacitor-mqtt-quic/android/src/main/kotlin/ai/annadata/mqttquic/quic/QuicClientStub.kt	2026-02-19 10:19:11
+@@ -36,7 +36,7 @@
+     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
+     }
+diff -Naur capacitor-mqtt-quic/android/src/main/kotlin/ai/annadata/mqttquic/quic/QuicTypes.kt annadata-app/node_modules/@annadata/capacitor-mqtt-quic/android/src/main/kotlin/ai/annadata/mqttquic/quic/QuicTypes.kt
+--- capacitor-mqtt-quic/android/src/main/kotlin/ai/annadata/mqttquic/quic/QuicTypes.kt	2026-02-18 22:28:55
++++ annadata-app/node_modules/@annadata/capacitor-mqtt-quic/android/src/main/kotlin/ai/annadata/mqttquic/quic/QuicTypes.kt	2026-02-19 10:16:31
+@@ -15,7 +15,7 @@
+  * 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()
+ }
+diff -Naur capacitor-mqtt-quic/android/src/main/kotlin/ai/annadata/mqttquic/transport/QUICStreamAdapter.kt annadata-app/node_modules/@annadata/capacitor-mqtt-quic/android/src/main/kotlin/ai/annadata/mqttquic/transport/QUICStreamAdapter.kt
+--- capacitor-mqtt-quic/android/src/main/kotlin/ai/annadata/mqttquic/transport/QUICStreamAdapter.kt	2026-02-19 13:50:41
++++ annadata-app/node_modules/@annadata/capacitor-mqtt-quic/android/src/main/kotlin/ai/annadata/mqttquic/transport/QUICStreamAdapter.kt	2026-02-19 12:21:15
+@@ -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()
+     }
+ }
+diff -Naur capacitor-mqtt-quic/android/src/main/kotlin/ai/annadata/mqttquic/transport/StreamTransport.kt annadata-app/node_modules/@annadata/capacitor-mqtt-quic/android/src/main/kotlin/ai/annadata/mqttquic/transport/StreamTransport.kt
+--- capacitor-mqtt-quic/android/src/main/kotlin/ai/annadata/mqttquic/transport/StreamTransport.kt	2026-02-18 22:28:55
++++ annadata-app/node_modules/@annadata/capacitor-mqtt-quic/android/src/main/kotlin/ai/annadata/mqttquic/transport/StreamTransport.kt	2026-02-19 08:09:34
+@@ -7,6 +7,8 @@
+  * 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
+ }
+@@ -49,6 +51,8 @@
+  * Mock reader over MockStreamBuffer.
+  */
+ 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)