fix: resume joinContinuation when LEAVE received during reconnect handshake

When the server sends a LEAVE as the initial response to a soft reconnect
(e.g. STATE_MISMATCH), handleSignalResponse processed it without resuming
joinContinuation, leaving client.reconnect() suspended forever. This
prevented the reconnect loop from advancing to a full reconnect.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: YashJainSC

livekit-android-sdk/src/main/java/io/livekit/android/room/SignalClient.kt

@@ -691,6 +691,11 @@ constructor(
             } else if (response.hasLeave()) {
                 // Some reconnects may immediately send leave back without a join response first.
                 handleSignalResponseImpl(ws, response)
+                val cont = joinContinuation
+                joinContinuation = null
+                cont?.resumeWithException(
+                    RoomException.ConnectException("Received leave during reconnect: ${response.leave.reason}"),
+                )
             } else if (isReconnecting) {
                 // When reconnecting, any message received means signal reconnected.
                 // Newer servers will send a reconnect response first

livekit-android-test/src/test/java/io/livekit/android/room/SignalClientTest.kt

@@ -33,6 +33,7 @@ import kotlinx.coroutines.async
 import kotlinx.coroutines.supervisorScope
 import kotlinx.coroutines.yield
 import kotlinx.serialization.json.Json
+import livekit.LivekitModels
 import livekit.LivekitRtc
 import livekit.org.webrtc.SessionDescription
 import okhttp3.OkHttpClient
@@ -429,6 +430,77 @@ class SignalClientTest : BaseTest() {
         assertTrue(originalWs.isClosed)
     }
 
+    /**
+     * Reconnect fails cleanly when server sends LEAVE as the initial response and closes WS cleanly.
+     */
+    @Test
+    fun reconnectDoesNotHangOnLeaveStateMismatchWithCleanClose() = runTest {
+        val joinJob = async { client.join(EXAMPLE_URL, "") }
+        connectWebsocketAndJoin()
+        joinJob.await()
+
+        wsFactory.ws.cancel()
+
+        supervisorScope {
+            val reconnectJob = async {
+                client.reconnect(EXAMPLE_URL, "", "participant_sid")
+            }
+            yield()
+
+            client.onOpen(wsFactory.ws, createOpenResponse(wsFactory.request))
+            val leaveResponse = with(LivekitRtc.SignalResponse.newBuilder()) {
+                leave = with(LivekitRtc.LeaveRequest.newBuilder()) {
+                    reason = LivekitModels.DisconnectReason.STATE_MISMATCH
+                    action = LivekitRtc.LeaveRequest.Action.RECONNECT
+                    build()
+                }
+                build()
+            }
+            wsFactory.receiveMessage(leaveResponse)
+
+            wsFactory.ws.close(1000, "normal")
+
+            val result = runCatching { reconnectJob.await() }
+            assertTrue("reconnect should have failed", result.isFailure)
+        }
+    }
+
+    /**
+     * Reconnect fails cleanly when server sends LEAVE as the initial response and drops the connection.
+     */
+    @Test
+    fun reconnectDoesNotHangOnLeaveStateMismatchWithFailure() = runTest {
+        val joinJob = async { client.join(EXAMPLE_URL, "") }
+        connectWebsocketAndJoin()
+        joinJob.await()
+
+        wsFactory.ws.cancel()
+
+        supervisorScope {
+            val reconnectJob = async {
+                client.reconnect(EXAMPLE_URL, "", "participant_sid")
+            }
+            yield()
+
+            client.onOpen(wsFactory.ws, createOpenResponse(wsFactory.request))
+            val leaveResponse = with(LivekitRtc.SignalResponse.newBuilder()) {
+                leave = with(LivekitRtc.LeaveRequest.newBuilder()) {
+                    reason = LivekitModels.DisconnectReason.STATE_MISMATCH
+                    action = LivekitRtc.LeaveRequest.Action.RECONNECT
+                    build()
+                }
+                build()
+            }
+            wsFactory.receiveMessage(leaveResponse)
+
+            // 5. Server drops connection (unclean close)
+            wsFactory.ws.cancel()
+
+            val result = runCatching { reconnectJob.await() }
+            assertTrue("reconnect should have failed", result.isFailure)
+        }
+    }
+
     // mock data
     companion object
 }