@annadata/capacitor-mqtt-quic 0.1.0

package/android/src/main/kotlin/ai/annadata/mqttquic/mqtt/MQTT5Properties.kt

@@ -0,0 +1,250 @@
+package ai.annadata.mqttquic.mqtt
+
+import java.nio.charset.StandardCharsets
+
+/**
+ * MQTT 5.0 Property Types. Matches MQTTD mqttd/properties.py.
+ */
+object MQTT5PropertyType {
+    const val PAYLOAD_FORMAT_INDICATOR: Byte = 0x01
+    const val MESSAGE_EXPIRY_INTERVAL: Byte = 0x02
+    const val CONTENT_TYPE: Byte = 0x03
+    const val RESPONSE_TOPIC: Byte = 0x08
+    const val CORRELATION_DATA: Byte = 0x09
+    const val SUBSCRIPTION_IDENTIFIER: Byte = 0x0B
+    const val SESSION_EXPIRY_INTERVAL: Byte = 0x11
+    const val ASSIGNED_CLIENT_IDENTIFIER: Byte = 0x12
+    const val SERVER_KEEP_ALIVE: Byte = 0x13
+    const val AUTHENTICATION_METHOD: Byte = 0x15
+    const val AUTHENTICATION_DATA: Byte = 0x16
+    const val REQUEST_PROBLEM_INFORMATION: Byte = 0x17
+    const val WILL_DELAY_INTERVAL: Byte = 0x18
+    const val REQUEST_RESPONSE_INFORMATION: Byte = 0x19
+    const val RESPONSE_INFORMATION: Byte = 0x1A
+    const val SERVER_REFERENCE: Byte = 0x1C
+    const val REASON_STRING: Byte = 0x1F
+    const val RECEIVE_MAXIMUM: Byte = 0x21
+    const val TOPIC_ALIAS_MAXIMUM: Byte = 0x22
+    const val TOPIC_ALIAS: Byte = 0x23
+    const val MAXIMUM_QOS: Byte = 0x24
+    const val RETAIN_AVAILABLE: Byte = 0x25
+    const val USER_PROPERTY: Byte = 0x26
+    const val MAXIMUM_PACKET_SIZE: Byte = 0x27
+    const val WILDCARD_SUBSCRIPTION_AVAILABLE: Byte = 0x28
+    const val SUBSCRIPTION_IDENTIFIER_AVAILABLE: Byte = 0x29
+    const val SHARED_SUBSCRIPTION_AVAILABLE: Byte = 0x2A
+}
+
+/**
+ * MQTT 5.0 Properties encoder/decoder. Matches MQTTD mqttd/properties.py.
+ */
+object MQTT5PropertyEncoder {
+    
+    fun encodeProperties(props: Map<Int, Any>): ByteArray {
+        val result = mutableListOf<Byte>()
+        val sorted = props.toList().sortedBy { it.first }
+        
+        for ((propId, value) in sorted) {
+            // Handle subscription identifier list
+            if (propId == MQTT5PropertyType.SUBSCRIPTION_IDENTIFIER.toInt() && value is List<*>) {
+                for (subId in value) {
+                    result.add(propId.toByte())
+                    result.addAll(encodeVariableByteInteger((subId as? Int) ?: 0).toList())
+                }
+                continue
+            }
+            
+            result.add(propId.toByte())
+            
+            when (propId) {
+                MQTT5PropertyType.PAYLOAD_FORMAT_INDICATOR.toInt() -> {
+                    result.add(((value as? Int) ?: 0).toByte())
+                }
+                MQTT5PropertyType.MESSAGE_EXPIRY_INTERVAL.toInt(),
+                MQTT5PropertyType.SESSION_EXPIRY_INTERVAL.toInt(),
+                MQTT5PropertyType.WILL_DELAY_INTERVAL.toInt(),
+                MQTT5PropertyType.MAXIMUM_PACKET_SIZE.toInt() -> {
+                    val v = ((value as? Long) ?: 0L).toInt()
+                    result.add((v shr 24).toByte())
+                    result.add((v shr 16).toByte())
+                    result.add((v shr 8).toByte())
+                    result.add(v.toByte())
+                }
+                MQTT5PropertyType.CONTENT_TYPE.toInt(),
+                MQTT5PropertyType.RESPONSE_TOPIC.toInt(),
+                MQTT5PropertyType.ASSIGNED_CLIENT_IDENTIFIER.toInt(),
+                MQTT5PropertyType.AUTHENTICATION_METHOD.toInt(),
+                MQTT5PropertyType.RESPONSE_INFORMATION.toInt(),
+                MQTT5PropertyType.SERVER_REFERENCE.toInt(),
+                MQTT5PropertyType.REASON_STRING.toInt() -> {
+                    result.addAll(encodeString((value as? String) ?: "").toList())
+                }
+                MQTT5PropertyType.CORRELATION_DATA.toInt(),
+                MQTT5PropertyType.AUTHENTICATION_DATA.toInt() -> {
+                    val data = (value as? ByteArray) ?: ByteArray(0)
+                    result.add((data.size shr 8).toByte())
+                    result.add((data.size and 0xFF).toByte())
+                    result.addAll(data.toList())
+                }
+                MQTT5PropertyType.SUBSCRIPTION_IDENTIFIER.toInt() -> {
+                    result.addAll(encodeVariableByteInteger((value as? Int) ?: 0).toList())
+                }
+                MQTT5PropertyType.SERVER_KEEP_ALIVE.toInt(),
+                MQTT5PropertyType.RECEIVE_MAXIMUM.toInt(),
+                MQTT5PropertyType.TOPIC_ALIAS_MAXIMUM.toInt(),
+                MQTT5PropertyType.TOPIC_ALIAS.toInt() -> {
+                    val v = ((value as? Int) ?: 0).toInt()
+                    result.add((v shr 8).toByte())
+                    result.add((v and 0xFF).toByte())
+                }
+                MQTT5PropertyType.MAXIMUM_QOS.toInt(),
+                MQTT5PropertyType.RETAIN_AVAILABLE.toInt(),
+                MQTT5PropertyType.REQUEST_PROBLEM_INFORMATION.toInt(),
+                MQTT5PropertyType.REQUEST_RESPONSE_INFORMATION.toInt(),
+                MQTT5PropertyType.WILDCARD_SUBSCRIPTION_AVAILABLE.toInt(),
+                MQTT5PropertyType.SUBSCRIPTION_IDENTIFIER_AVAILABLE.toInt(),
+                MQTT5PropertyType.SHARED_SUBSCRIPTION_AVAILABLE.toInt() -> {
+                    result.add(((value as? Int) ?: 0).toByte())
+                }
+                MQTT5PropertyType.USER_PROPERTY.toInt() -> {
+                    if (value is Pair<*, *>) {
+                        result.addAll(encodeString((value.first as? String) ?: "").toList())
+                        result.addAll(encodeString((value.second as? String) ?: "").toList())
+                    } else {
+                        throw IllegalArgumentException("USER_PROPERTY must be Pair<String, String>")
+                    }
+                }
+                else -> throw IllegalArgumentException("Unknown property type: $propId")
+            }
+        }
+        
+        return result.toByteArray()
+    }
+    
+    fun decodeProperties(data: ByteArray, offset: Int = 0): Pair<Map<Int, Any>, Int> {
+        val props = mutableMapOf<Int, Any>()
+        var pos = offset
+        
+        while (pos < data.size) {
+            val propId = data[pos].toInt() and 0xFF
+            pos++
+            
+            when (propId) {
+                MQTT5PropertyType.PAYLOAD_FORMAT_INDICATOR.toInt() -> {
+                    props[propId] = data[pos].toInt() and 0xFF
+                    pos++
+                }
+                MQTT5PropertyType.MESSAGE_EXPIRY_INTERVAL.toInt(),
+                MQTT5PropertyType.SESSION_EXPIRY_INTERVAL.toInt(),
+                MQTT5PropertyType.WILL_DELAY_INTERVAL.toInt(),
+                MQTT5PropertyType.MAXIMUM_PACKET_SIZE.toInt() -> {
+                    val v = ((data[pos].toInt() and 0xFF) shl 24) or
+                            ((data[pos + 1].toInt() and 0xFF) shl 16) or
+                            ((data[pos + 2].toInt() and 0xFF) shl 8) or
+                            (data[pos + 3].toInt() and 0xFF)
+                    props[propId] = v
+                    pos += 4
+                }
+                MQTT5PropertyType.CONTENT_TYPE.toInt(),
+                MQTT5PropertyType.RESPONSE_TOPIC.toInt(),
+                MQTT5PropertyType.ASSIGNED_CLIENT_IDENTIFIER.toInt(),
+                MQTT5PropertyType.AUTHENTICATION_METHOD.toInt(),
+                MQTT5PropertyType.RESPONSE_INFORMATION.toInt(),
+                MQTT5PropertyType.SERVER_REFERENCE.toInt(),
+                MQTT5PropertyType.REASON_STRING.toInt() -> {
+                    val (s, next) = decodeString(data, pos)
+                    props[propId] = s
+                    pos = next
+                }
+                MQTT5PropertyType.CORRELATION_DATA.toInt(),
+                MQTT5PropertyType.AUTHENTICATION_DATA.toInt() -> {
+                    val len = ((data[pos].toInt() and 0xFF) shl 8) or (data[pos + 1].toInt() and 0xFF)
+                    pos += 2
+                    props[propId] = data.copyOfRange(pos, pos + len)
+                    pos += len
+                }
+                MQTT5PropertyType.SUBSCRIPTION_IDENTIFIER.toInt() -> {
+                    val (v, consumed) = decodeVariableByteInteger(data, pos)
+                    val list = (props[propId] as? MutableList<Int>) ?: mutableListOf()
+                    list.add(v)
+                    props[propId] = list
+                    pos += consumed
+                }
+                MQTT5PropertyType.SERVER_KEEP_ALIVE.toInt(),
+                MQTT5PropertyType.RECEIVE_MAXIMUM.toInt(),
+                MQTT5PropertyType.TOPIC_ALIAS_MAXIMUM.toInt(),
+                MQTT5PropertyType.TOPIC_ALIAS.toInt() -> {
+                    val v = ((data[pos].toInt() and 0xFF) shl 8) or (data[pos + 1].toInt() and 0xFF)
+                    props[propId] = v
+                    pos += 2
+                }
+                MQTT5PropertyType.MAXIMUM_QOS.toInt(),
+                MQTT5PropertyType.RETAIN_AVAILABLE.toInt(),
+                MQTT5PropertyType.REQUEST_PROBLEM_INFORMATION.toInt(),
+                MQTT5PropertyType.REQUEST_RESPONSE_INFORMATION.toInt(),
+                MQTT5PropertyType.WILDCARD_SUBSCRIPTION_AVAILABLE.toInt(),
+                MQTT5PropertyType.SUBSCRIPTION_IDENTIFIER_AVAILABLE.toInt(),
+                MQTT5PropertyType.SHARED_SUBSCRIPTION_AVAILABLE.toInt() -> {
+                    props[propId] = data[pos].toInt() and 0xFF
+                    pos++
+                }
+                MQTT5PropertyType.USER_PROPERTY.toInt() -> {
+                    val (name, next1) = decodeString(data, pos)
+                    pos = next1
+                    val (value, next2) = decodeString(data, pos)
+                    pos = next2
+                    val list = (props[propId] as? MutableList<Pair<String, String>>) ?: mutableListOf()
+                    list.add(name to value)
+                    props[propId] = list
+                }
+                else -> break // Unknown property - skip
+            }
+        }
+        
+        return props to (pos - offset)
+    }
+    
+    private fun encodeString(s: String): ByteArray {
+        val utf8 = s.toByteArray(StandardCharsets.UTF_8)
+        if (utf8.size > 0xFFFF) throw IllegalArgumentException("String too long")
+        return byteArrayOf((utf8.size shr 8).toByte(), (utf8.size and 0xFF).toByte()) + utf8
+    }
+    
+    private fun decodeString(data: ByteArray, offset: Int): Pair<String, Int> {
+        if (offset + 2 > data.size) throw IllegalArgumentException("Insufficient data for string length")
+        val len = ((data[offset].toInt() and 0xFF) shl 8) or (data[offset + 1].toInt() and 0xFF)
+        val start = offset + 2
+        if (start + len > data.size) throw IllegalArgumentException("Insufficient data for string content")
+        val sub = data.copyOfRange(start, start + len)
+        val s = String(sub, StandardCharsets.UTF_8)
+        return s to (start + len)
+    }
+    
+    private fun encodeVariableByteInteger(value: Int): ByteArray {
+        if (value < 0 || value > 268_435_455) throw IllegalArgumentException("Invalid variable byte integer: $value")
+        val enc = mutableListOf<Byte>()
+        var n = value
+        do {
+            var b = (n % 128).toByte()
+            n /= 128
+            if (n > 0) b = (b.toInt() or 0x80).toByte()
+            enc.add(b)
+        } while (n > 0)
+        return enc.toByteArray()
+    }
+    
+    private fun decodeVariableByteInteger(data: ByteArray, offset: Int): Pair<Int, Int> {
+        var mul = 1
+        var value = 0
+        var i = offset
+        repeat(4) {
+            if (i >= data.size) throw IllegalArgumentException("Insufficient data for variable byte integer")
+            val b = data[i].toInt() and 0xFF
+            value += (b and 0x7F) * mul
+            i++
+            if ((b and 0x80) == 0) return@repeat
+            mul *= 128
+        }
+        return value to (i - offset)
+    }
+}

package/android/src/main/kotlin/ai/annadata/mqttquic/mqtt/MQTT5Protocol.kt

@@ -0,0 +1,281 @@
+package ai.annadata.mqttquic.mqtt
+
+/**
+ * MQTT 5.0 Protocol implementation. Matches MQTTD mqttd/protocol_v5.py.
+ */
+object MQTT5Protocol {
+    
+    fun buildConnectV5(
+        clientId: String,
+        username: String? = null,
+        password: String? = null,
+        keepalive: Int = 60,
+        cleanStart: Boolean = true,
+        sessionExpiryInterval: Int? = null,
+        receiveMaximum: Int? = null,
+        maximumPacketSize: Int? = null,
+        topicAliasMaximum: Int? = null,
+        requestResponseInformation: Int? = null,
+        requestProblemInformation: Int? = null,
+        authenticationMethod: String? = null,
+        authenticationData: ByteArray? = null,
+        properties: Map<Int, Any>? = null
+    ): ByteArray {
+        val variableHeader = mutableListOf<Byte>()
+        variableHeader.addAll(MQTTProtocol.encodeString("MQTT").toList())
+        variableHeader.add(MQTTProtocolLevel.V5)
+        
+        var flags = 0
+        if (cleanStart) flags = flags or 0x02
+        if (username != null) flags = flags or MQTTConnectFlags.USERNAME
+        if (password != null) flags = flags or MQTTConnectFlags.PASSWORD
+        variableHeader.add(flags.toByte())
+        variableHeader.add((keepalive shr 8).toByte())
+        variableHeader.add((keepalive and 0xFF).toByte())
+        
+        val connectProps = mutableMapOf<Int, Any>()
+        sessionExpiryInterval?.let { connectProps[MQTT5PropertyType.SESSION_EXPIRY_INTERVAL.toInt()] = it }
+        receiveMaximum?.let { connectProps[MQTT5PropertyType.RECEIVE_MAXIMUM.toInt()] = it }
+        maximumPacketSize?.let { connectProps[MQTT5PropertyType.MAXIMUM_PACKET_SIZE.toInt()] = it }
+        topicAliasMaximum?.let { connectProps[MQTT5PropertyType.TOPIC_ALIAS_MAXIMUM.toInt()] = it }
+        requestResponseInformation?.let { connectProps[MQTT5PropertyType.REQUEST_RESPONSE_INFORMATION.toInt()] = it }
+        requestProblemInformation?.let { connectProps[MQTT5PropertyType.REQUEST_PROBLEM_INFORMATION.toInt()] = it }
+        authenticationMethod?.let { connectProps[MQTT5PropertyType.AUTHENTICATION_METHOD.toInt()] = it }
+        authenticationData?.let { connectProps[MQTT5PropertyType.AUTHENTICATION_DATA.toInt()] = it }
+        properties?.let { connectProps.putAll(it) }
+        
+        val propsBytes = MQTT5PropertyEncoder.encodeProperties(connectProps)
+        val propsLen = MQTTProtocol.encodeRemainingLength(propsBytes.size)
+        variableHeader.addAll(propsLen.toList())
+        variableHeader.addAll(propsBytes.toList())
+        
+        val payload = mutableListOf<Byte>()
+        payload.addAll(MQTTProtocol.encodeString(clientId).toList())
+        payload.add(0x00) // Will Properties length = 0
+        username?.let { payload.addAll(MQTTProtocol.encodeString(it).toList()) }
+        password?.let { payload.addAll(MQTTProtocol.encodeString(it).toList()) }
+        
+        val remLen = variableHeader.size + payload.size
+        val fixed = mutableListOf<Byte>()
+        fixed.add(MQTTMessageType.CONNECT)
+        fixed.addAll(MQTTProtocol.encodeRemainingLength(remLen).toList())
+        
+        return (fixed + variableHeader + payload).toByteArray()
+    }
+    
+    fun buildConnackV5(
+        reasonCode: Int = MQTT5ReasonCode.SUCCESS,
+        sessionPresent: Boolean = false,
+        properties: Map<Int, Any>? = null
+    ): ByteArray {
+        val variableHeader = mutableListOf<Byte>()
+        variableHeader.add(if (sessionPresent) 0x01 else 0x00)
+        variableHeader.add(reasonCode.toByte())
+        
+        val props = properties ?: emptyMap()
+        val propsBytes = MQTT5PropertyEncoder.encodeProperties(props)
+        val propsLen = MQTTProtocol.encodeRemainingLength(propsBytes.size)
+        variableHeader.addAll(propsLen.toList())
+        variableHeader.addAll(propsBytes.toList())
+        
+        val remLen = variableHeader.size
+        val fixed = mutableListOf<Byte>()
+        fixed.add(MQTTMessageType.CONNACK)
+        fixed.addAll(MQTTProtocol.encodeRemainingLength(remLen).toList())
+        
+        return (fixed + variableHeader).toByteArray()
+    }
+    
+    fun parseConnackV5(data: ByteArray, offset: Int = 0): Triple<Boolean, Int, Map<Int, Any>> {
+        if (offset + 2 > data.size) throw IllegalArgumentException("Insufficient data for CONNACK")
+        val sessionPresent = (data[offset].toInt() and 0x01) != 0
+        val reasonCode = data[offset + 1].toInt() and 0xFF
+        var pos = offset + 2
+        
+        val (propLen, propLenBytes) = MQTTProtocol.decodeRemainingLength(data, pos)
+        pos += propLenBytes
+        val (props, _) = MQTT5PropertyEncoder.decodeProperties(data.copyOfRange(pos, pos + propLen), 0)
+        pos += propLen
+        
+        return Triple(sessionPresent, reasonCode, props)
+    }
+    
+    fun buildPublishV5(
+        topic: String,
+        payload: ByteArray,
+        packetId: Int? = null,
+        qos: Int = 0,
+        retain: Boolean = false,
+        properties: Map<Int, Any>? = null
+    ): ByteArray {
+        var msgType = MQTTMessageType.PUBLISH.toInt()
+        if (qos > 0) msgType = msgType or (qos shl 1)
+        if (retain) msgType = msgType or 0x01
+        
+        val vh = mutableListOf<Byte>()
+        vh.addAll(MQTTProtocol.encodeString(topic).toList())
+        if (qos > 0 && packetId != null) {
+            vh.add((packetId shr 8).toByte())
+            vh.add((packetId and 0xFF).toByte())
+        }
+        
+        val props = properties ?: emptyMap()
+        val propsBytes = MQTT5PropertyEncoder.encodeProperties(props)
+        val propsLen = MQTTProtocol.encodeRemainingLength(propsBytes.size)
+        vh.addAll(propsLen.toList())
+        vh.addAll(propsBytes.toList())
+        
+        val pl = (vh + payload.toList()).toByteArray()
+        val remLen = pl.size
+        return byteArrayOf(
+            msgType.toByte(),
+            *MQTTProtocol.encodeRemainingLength(remLen),
+            *pl
+        )
+    }
+    
+    fun buildSubscribeV5(
+        packetId: Int,
+        topic: String,
+        qos: Int = 0,
+        subscriptionIdentifier: Int? = null,
+        properties: Map<Int, Any>? = null
+    ): ByteArray {
+        val vh = mutableListOf<Byte>()
+        vh.add((packetId shr 8).toByte())
+        vh.add((packetId and 0xFF).toByte())
+        
+        val props = mutableMapOf<Int, Any>()
+        subscriptionIdentifier?.let { props[MQTT5PropertyType.SUBSCRIPTION_IDENTIFIER.toInt()] = it }
+        properties?.let { props.putAll(it) }
+        val propsBytes = MQTT5PropertyEncoder.encodeProperties(props)
+        val propsLen = MQTTProtocol.encodeRemainingLength(propsBytes.size)
+        vh.addAll(propsLen.toList())
+        vh.addAll(propsBytes.toList())
+        
+        val pl = MQTTProtocol.encodeString(topic) + byteArrayOf((qos and 0x03).toByte())
+        val rem = vh.size + pl.size
+        return byteArrayOf(
+            (MQTTMessageType.SUBSCRIBE.toInt() or 0x02).toByte(),
+            *MQTTProtocol.encodeRemainingLength(rem),
+            *vh.toByteArray(),
+            *pl
+        )
+    }
+    
+    fun buildSubackV5(
+        packetId: Int,
+        reasonCodes: List<Int>,
+        properties: Map<Int, Any>? = null
+    ): ByteArray {
+        val vh = mutableListOf<Byte>()
+        vh.add((packetId shr 8).toByte())
+        vh.add((packetId and 0xFF).toByte())
+        
+        val props = properties ?: emptyMap()
+        val propsBytes = MQTT5PropertyEncoder.encodeProperties(props)
+        val propsLen = MQTTProtocol.encodeRemainingLength(propsBytes.size)
+        vh.addAll(propsLen.toList())
+        vh.addAll(propsBytes.toList())
+        
+        val pl = reasonCodes.map { it.toByte() }.toByteArray()
+        val rem = vh.size + pl.size
+        return byteArrayOf(
+            MQTTMessageType.SUBACK,
+            *MQTTProtocol.encodeRemainingLength(rem),
+            *vh.toByteArray(),
+            *pl
+        )
+    }
+    
+    fun parseSubackV5(data: ByteArray, offset: Int = 0): Triple<Int, List<Int>, Map<Int, Any>> {
+        if (offset + 2 > data.size) throw IllegalArgumentException("Insufficient data for SUBACK packet ID")
+        val pid = ((data[offset].toInt() and 0xFF) shl 8) or (data[offset + 1].toInt() and 0xFF)
+        var pos = offset + 2
+        
+        val (propLen, propLenBytes) = MQTTProtocol.decodeRemainingLength(data, pos)
+        pos += propLenBytes
+        val (props, _) = MQTT5PropertyEncoder.decodeProperties(data.copyOfRange(pos, pos + propLen), 0)
+        pos += propLen
+        
+        val reasonCodes = mutableListOf<Int>()
+        while (pos < data.size) {
+            reasonCodes.add(data[pos].toInt() and 0xFF)
+            pos++
+        }
+        
+        return Triple(pid, reasonCodes, props)
+    }
+    
+    fun buildUnsubscribeV5(
+        packetId: Int,
+        topics: List<String>,
+        properties: Map<Int, Any>? = null
+    ): ByteArray {
+        val vh = mutableListOf<Byte>()
+        vh.add((packetId shr 8).toByte())
+        vh.add((packetId and 0xFF).toByte())
+        
+        val props = properties ?: emptyMap()
+        val propsBytes = MQTT5PropertyEncoder.encodeProperties(props)
+        val propsLen = MQTTProtocol.encodeRemainingLength(propsBytes.size)
+        vh.addAll(propsLen.toList())
+        vh.addAll(propsBytes.toList())
+        
+        val plList = topics.flatMap { MQTTProtocol.encodeString(it).toList() }
+        val pl = ByteArray(plList.size) { plList[it] }
+        val rem = vh.size + pl.size
+        return byteArrayOf(
+            (MQTTMessageType.UNSUBSCRIBE.toInt() or 0x02).toByte(),
+            *MQTTProtocol.encodeRemainingLength(rem),
+            *vh.toByteArray(),
+            *pl
+        )
+    }
+    
+    fun buildUnsubackV5(
+        packetId: Int,
+        reasonCodes: List<Int>? = null,
+        properties: Map<Int, Any>? = null
+    ): ByteArray {
+        val vh = mutableListOf<Byte>()
+        vh.add((packetId shr 8).toByte())
+        vh.add((packetId and 0xFF).toByte())
+        
+        val props = properties ?: emptyMap()
+        val propsBytes = MQTT5PropertyEncoder.encodeProperties(props)
+        val propsLen = MQTTProtocol.encodeRemainingLength(propsBytes.size)
+        vh.addAll(propsLen.toList())
+        vh.addAll(propsBytes.toList())
+        
+        val pl = reasonCodes?.map { it.toByte() }?.toByteArray() ?: ByteArray(0)
+        val rem = vh.size + pl.size
+        return byteArrayOf(
+            MQTTMessageType.UNSUBACK,
+            *MQTTProtocol.encodeRemainingLength(rem),
+            *vh.toByteArray(),
+            *pl
+        )
+    }
+    
+    fun buildDisconnectV5(
+        reasonCode: Int = MQTT5ReasonCode.NORMAL_DISCONNECTION_DISC,
+        properties: Map<Int, Any>? = null
+    ): ByteArray {
+        val vh = mutableListOf<Byte>()
+        vh.add(reasonCode.toByte())
+        
+        val props = properties ?: emptyMap()
+        val propsBytes = MQTT5PropertyEncoder.encodeProperties(props)
+        val propsLen = MQTTProtocol.encodeRemainingLength(propsBytes.size)
+        vh.addAll(propsLen.toList())
+        vh.addAll(propsBytes.toList())
+        
+        val remLen = vh.size
+        val fixed = mutableListOf<Byte>()
+        fixed.add(MQTTMessageType.DISCONNECT)
+        fixed.addAll(MQTTProtocol.encodeRemainingLength(remLen).toList())
+        
+        return (fixed + vh).toByteArray()
+    }
+}

package/android/src/main/kotlin/ai/annadata/mqttquic/mqtt/MQTT5ReasonCodes.kt

@@ -0,0 +1,109 @@
+package ai.annadata.mqttquic.mqtt
+
+/**
+ * MQTT 5.0 Reason Codes. Matches MQTTD mqttd/reason_codes.py.
+ */
+object MQTT5ReasonCode {
+    // Success
+    const val SUCCESS: Int = 0x00
+    const val NORMAL_DISCONNECTION: Int = 0x00
+    const val DISCONNECT_WITH_WILL_MESSAGE: Int = 0x04
+    
+    // CONNACK Reason Codes
+    const val UNSPECIFIED_ERROR: Int = 0x80
+    const val MALFORMED_PACKET: Int = 0x81
+    const val PROTOCOL_ERROR: Int = 0x82
+    const val IMPLEMENTATION_SPECIFIC_ERROR: Int = 0x83
+    const val UNSUPPORTED_PROTOCOL_VERSION: Int = 0x84
+    const val CLIENT_IDENTIFIER_NOT_VALID: Int = 0x85
+    const val BAD_USER_NAME_OR_PASSWORD: Int = 0x86
+    const val NOT_AUTHORIZED: Int = 0x87
+    const val SERVER_UNAVAILABLE: Int = 0x88
+    const val SERVER_BUSY: Int = 0x89
+    const val BANNED: Int = 0x8A
+    const val BAD_AUTHENTICATION_METHOD: Int = 0x8C
+    const val TOPIC_NAME_INVALID: Int = 0x90
+    const val PACKET_TOO_LARGE: Int = 0x95
+    const val QUOTA_EXCEEDED: Int = 0x97
+    const val PAYLOAD_FORMAT_INVALID: Int = 0x99
+    const val RETAIN_NOT_SUPPORTED: Int = 0x9A
+    const val QOS_NOT_SUPPORTED: Int = 0x9B
+    const val USE_ANOTHER_SERVER: Int = 0x9C
+    const val SERVER_MOVED: Int = 0x9D
+    const val CONNECTION_RATE_EXCEEDED: Int = 0x9F
+    
+    // PUBACK, PUBREC, PUBREL, PUBCOMP Reason Codes
+    const val NO_MATCHING_SUBSCRIBERS: Int = 0x10
+    const val UNSPECIFIED_ERROR_PUB: Int = 0x80
+    const val IMPLEMENTATION_SPECIFIC_ERROR_PUB: Int = 0x83
+    const val NOT_AUTHORIZED_PUB: Int = 0x87
+    const val TOPIC_NAME_INVALID_PUB: Int = 0x90
+    const val PACKET_IDENTIFIER_IN_USE: Int = 0x91
+    const val QUOTA_EXCEEDED_PUB: Int = 0x97
+    const val PAYLOAD_FORMAT_INVALID_PUB: Int = 0x99
+    
+    // SUBACK Reason Codes
+    const val GRANTED_QOS_0: Int = 0x00
+    const val GRANTED_QOS_1: Int = 0x01
+    const val GRANTED_QOS_2: Int = 0x02
+    const val UNSPECIFIED_ERROR_SUB: Int = 0x80
+    const val IMPLEMENTATION_SPECIFIC_ERROR_SUB: Int = 0x83
+    const val NOT_AUTHORIZED_SUB: Int = 0x87
+    const val TOPIC_FILTER_INVALID: Int = 0x8F
+    const val PACKET_IDENTIFIER_IN_USE_SUB: Int = 0x91
+    const val QUOTA_EXCEEDED_SUB: Int = 0x97
+    const val SHARED_SUBSCRIPTIONS_NOT_SUPPORTED: Int = 0x9E
+    const val SUBSCRIPTION_IDENTIFIERS_NOT_SUPPORTED: Int = 0xA1
+    const val WILDCARD_SUBSCRIPTIONS_NOT_SUPPORTED: Int = 0xA2
+    
+    // UNSUBACK Reason Codes
+    const val SUCCESS_UNSUB: Int = 0x00
+    const val NO_SUBSCRIPTION_EXISTED: Int = 0x11
+    const val UNSPECIFIED_ERROR_UNSUB: Int = 0x80
+    const val IMPLEMENTATION_SPECIFIC_ERROR_UNSUB: Int = 0x83
+    const val NOT_AUTHORIZED_UNSUB: Int = 0x87
+    const val TOPIC_FILTER_INVALID_UNSUB: Int = 0x8F
+    const val PACKET_IDENTIFIER_IN_USE_UNSUB: Int = 0x91
+    
+    // DISCONNECT Reason Codes
+    const val NORMAL_DISCONNECTION_DISC: Int = 0x00
+    const val DISCONNECT_WITH_WILL_MESSAGE_DISC: Int = 0x04
+    const val UNSPECIFIED_ERROR_DISC: Int = 0x80
+    const val MALFORMED_PACKET_DISC: Int = 0x81
+    const val PROTOCOL_ERROR_DISC: Int = 0x82
+    const val IMPLEMENTATION_SPECIFIC_ERROR_DISC: Int = 0x83
+    const val NOT_AUTHORIZED_DISC: Int = 0x87
+    const val SERVER_BUSY_DISC: Int = 0x89
+    const val SERVER_SHUTTING_DOWN: Int = 0x8B
+    const val BAD_AUTHENTICATION_METHOD_DISC: Int = 0x8C
+    const val KEEP_ALIVE_TIMEOUT: Int = 0x8D
+    const val SESSION_TAKEN_OVER: Int = 0x8E
+    const val TOPIC_FILTER_INVALID_DISC: Int = 0x8F
+    const val TOPIC_NAME_INVALID_DISC: Int = 0x90
+    const val RECEIVE_MAXIMUM_EXCEEDED: Int = 0x93
+    const val TOPIC_ALIAS_INVALID: Int = 0x94
+    const val PACKET_TOO_LARGE_DISC: Int = 0x95
+    const val MESSAGE_RATE_TOO_HIGH: Int = 0x96
+    const val QUOTA_EXCEEDED_DISC: Int = 0x97
+    const val ADMINISTRATIVE_ACTION: Int = 0x98
+    const val PAYLOAD_FORMAT_INVALID_DISC: Int = 0x99
+    const val RETAIN_NOT_SUPPORTED_DISC: Int = 0x9A
+    const val QOS_NOT_SUPPORTED_DISC: Int = 0x9B
+    const val USE_ANOTHER_SERVER_DISC: Int = 0x9C
+    const val SERVER_MOVED_DISC: Int = 0x9D
+    const val SHARED_SUBSCRIPTIONS_NOT_SUPPORTED_DISC: Int = 0x9E
+    const val CONNECTION_RATE_EXCEEDED_DISC: Int = 0x9F
+    const val MAXIMUM_CONNECT_TIME: Int = 0xA0
+    const val SUBSCRIPTION_IDENTIFIERS_NOT_SUPPORTED_DISC: Int = 0xA1
+    const val WILDCARD_SUBSCRIPTIONS_NOT_SUPPORTED_DISC: Int = 0xA2
+}
+
+// Compatibility mapping for MQTT 3.1.1 return codes
+val MQTT3_TO_MQTT5_REASON_CODE = mapOf(
+    0x00 to MQTT5ReasonCode.SUCCESS,
+    0x01 to MQTT5ReasonCode.UNSUPPORTED_PROTOCOL_VERSION,
+    0x02 to MQTT5ReasonCode.CLIENT_IDENTIFIER_NOT_VALID,
+    0x03 to MQTT5ReasonCode.SERVER_UNAVAILABLE,
+    0x04 to MQTT5ReasonCode.BAD_USER_NAME_OR_PASSWORD,
+    0x05 to MQTT5ReasonCode.NOT_AUTHORIZED,
+)