Синхронизированы пакеты звонков с desktop/wss

app/src/main/java/com/rosetta/messenger/network/PacketSignalPeer.kt

@@ -11,7 +11,8 @@ enum class SignalType(val value: Int) {
 
     companion object {
         fun fromValue(value: Int): SignalType =
-            entries.firstOrNull { it.value == value } ?: CALL
+            entries.firstOrNull { it.value == value }
+                ?: throw IllegalArgumentException("Unknown SignalType code: $value")
     }
 }
 

app/src/main/java/com/rosetta/messenger/network/PacketWebRTC.kt

@@ -7,7 +7,8 @@ enum class WebRTCSignalType(val value: Int) {
 
     companion object {
         fun fromValue(value: Int): WebRTCSignalType =
-            entries.firstOrNull { it.value == value } ?: OFFER
+            entries.firstOrNull { it.value == value }
+                ?: throw IllegalArgumentException("Unknown WebRTCSignalType code: $value")
     }
 }
 

app/src/main/java/com/rosetta/messenger/network/ProtocolManager.kt

@@ -31,6 +31,9 @@ object ProtocolManager {
     private const val MAX_DEBUG_LOGS = 600
     private const val DEBUG_LOG_FLUSH_DELAY_MS = 60L
     private const val TYPING_INDICATOR_TIMEOUT_MS = 3_000L
+    private const val PACKET_SIGNAL_PEER = 0x1A
+    private const val PACKET_WEB_RTC = 0x1B
+    private const val PACKET_ICE_SERVERS = 0x1C
     
     // Desktop parity: use the same primary WebSocket endpoint as desktop client.
     private const val SERVER_ADDRESS = "wss://wss.rosetta.im"
@@ -1281,6 +1284,94 @@ object ProtocolManager {
     fun sendPacket(packet: Packet) {
         send(packet)
     }
+
+    /**
+     * Send call signaling packet (0x1A).
+     */
+    fun sendCallSignal(
+        signalType: SignalType,
+        src: String = "",
+        dst: String = "",
+        sharedPublic: String = "",
+        roomId: String = ""
+    ) {
+        send(
+            PacketSignalPeer().apply {
+                this.signalType = signalType
+                this.src = src
+                this.dst = dst
+                this.sharedPublic = sharedPublic
+                this.roomId = roomId
+            }
+        )
+    }
+
+    /**
+     * Send WebRTC signaling packet (0x1B).
+     */
+    fun sendWebRtcSignal(signalType: WebRTCSignalType, sdpOrCandidate: String) {
+        send(
+            PacketWebRTC().apply {
+                this.signalType = signalType
+                this.sdpOrCandidate = sdpOrCandidate
+            }
+        )
+    }
+
+    /**
+     * Request ICE servers from server (0x1C).
+     */
+    fun requestIceServers() {
+        send(PacketIceServers())
+    }
+
+    /**
+     * Typed subscribe for call signaling packets (0x1A).
+     * Returns wrapper callback for subsequent unwait.
+     */
+    fun waitCallSignal(callback: (PacketSignalPeer) -> Unit): (Packet) -> Unit {
+        val wrapper: (Packet) -> Unit = { packet ->
+            (packet as? PacketSignalPeer)?.let(callback)
+        }
+        waitPacket(PACKET_SIGNAL_PEER, wrapper)
+        return wrapper
+    }
+
+    fun unwaitCallSignal(callback: (Packet) -> Unit) {
+        unwaitPacket(PACKET_SIGNAL_PEER, callback)
+    }
+
+    /**
+     * Typed subscribe for WebRTC packets (0x1B).
+     * Returns wrapper callback for subsequent unwait.
+     */
+    fun waitWebRtcSignal(callback: (PacketWebRTC) -> Unit): (Packet) -> Unit {
+        val wrapper: (Packet) -> Unit = { packet ->
+            (packet as? PacketWebRTC)?.let(callback)
+        }
+        waitPacket(PACKET_WEB_RTC, wrapper)
+        return wrapper
+    }
+
+    fun unwaitWebRtcSignal(callback: (Packet) -> Unit) {
+        unwaitPacket(PACKET_WEB_RTC, callback)
+    }
+
+    /**
+     * Typed subscribe for ICE servers packet (0x1C).
+     * Returns wrapper callback for subsequent unwait.
+     */
+    fun waitIceServers(callback: (PacketIceServers) -> Unit): (Packet) -> Unit {
+        val wrapper: (Packet) -> Unit = { packet ->
+            (packet as? PacketIceServers)?.let(callback)
+        }
+        waitPacket(PACKET_ICE_SERVERS, wrapper)
+        return wrapper
+    }
+
+    fun unwaitIceServers(callback: (Packet) -> Unit) {
+        unwaitPacket(PACKET_ICE_SERVERS, callback)
+    }
     
     /**
      * Register packet handler