From a9f4cc719acdfac9abed962035aae5d4a1943ad7 Mon Sep 17 00:00:00 2001 From: Sen Chang Date: Tue, 27 Oct 2026 13:30:32 -0700 Subject: [PATCH 01/12] Add SignalUrlBuilder for /rtc/v1 join request URLs Builds the /rtc/v1?join_request= signal URL and its /validate counterpart, matching client-sdk-swift's buildJoinRequestUrl and toValidateUrl. --- .../io/livekit/android/room/SignalClient.kt | 7 +- .../android/room/util/SignalUrlBuilder.kt | 167 ++++++++ .../android/room/util/SignalUrlBuilderTest.kt | 356 ++++++++++++++++++ 3 files changed, 526 insertions(+), 4 deletions(-) create mode 100644 livekit-android-sdk/src/main/java/io/livekit/android/room/util/SignalUrlBuilder.kt create mode 100644 livekit-android-test/src/test/java/io/livekit/android/room/util/SignalUrlBuilderTest.kt diff --git a/livekit-android-sdk/src/main/java/io/livekit/android/room/SignalClient.kt b/livekit-android-sdk/src/main/java/io/livekit/android/room/SignalClient.kt index 0cad99b45..a3d01311d 100644 --- a/livekit-android-sdk/src/main/java/io/livekit/android/room/SignalClient.kt +++ b/livekit-android-sdk/src/main/java/io/livekit/android/room/SignalClient.kt @@ -25,6 +25,7 @@ import io.livekit.android.dagger.InjectionNames import io.livekit.android.room.datatrack.DataTrackSchemaException import io.livekit.android.room.participant.ParticipantTrackPermission import io.livekit.android.room.track.Track +import io.livekit.android.room.util.SignalUrlBuilder import io.livekit.android.stats.NetworkInfo import io.livekit.android.stats.getClientInfo import io.livekit.android.util.CloseableCoroutineScope @@ -32,7 +33,6 @@ import io.livekit.android.util.Either import io.livekit.android.util.LKLog import io.livekit.android.util.TimeoutException import io.livekit.android.util.rethrowIfCancellationSignal -import io.livekit.android.util.toHttpUrl import io.livekit.android.util.toWebsocketUrl import io.livekit.android.util.withDeadline import io.livekit.android.webrtc.toProtoSessionDescription @@ -361,10 +361,9 @@ constructor( var reason: String? = null try { val lastToken = webSocket.request().header("Authorization") - lastUrl?.let { - val validationUrl = it.toHttpUrl().replaceFirst("/rtc?", "/rtc/validate?") + SignalUrlBuilder.toValidateUrl(lastUrl).getOrNull()?.let { val request = Request.Builder() - .url(validationUrl) + .url(it) .apply { if (lastToken != null) { addHeader("Authorization", lastToken) diff --git a/livekit-android-sdk/src/main/java/io/livekit/android/room/util/SignalUrlBuilder.kt b/livekit-android-sdk/src/main/java/io/livekit/android/room/util/SignalUrlBuilder.kt new file mode 100644 index 000000000..135180202 --- /dev/null +++ b/livekit-android-sdk/src/main/java/io/livekit/android/room/util/SignalUrlBuilder.kt @@ -0,0 +1,167 @@ +/* + * Copyright 2026 LiveKit, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package io.livekit.android.room.util + +import com.google.protobuf.ByteString +import io.livekit.android.ConnectOptions +import io.livekit.android.RoomOptions +import io.livekit.android.stats.NetworkType +import io.livekit.android.stats.getClientInfo +import io.livekit.android.util.toHttpUrl +import io.livekit.android.util.toWebsocketUrl +import livekit.LivekitModels.ReconnectReason +import livekit.LivekitRtc.ConnectionSettings +import livekit.LivekitRtc.JoinRequest +import livekit.LivekitRtc.SessionDescription +import livekit.LivekitRtc.WrappedJoinRequest +import livekit.LivekitRtc.WrappedJoinRequest.Compression +import okio.ByteString.Companion.toByteString +import java.io.ByteArrayOutputStream +import java.util.zip.GZIPOutputStream +import okhttp3.HttpUrl.Companion.toHttpUrl as parseHttpUrl + +/** + * Builds signal connection URLs for the `/rtc/v1` endpoint, where all join parameters + * are carried in a single `join_request` query parameter holding a base64url-encoded + * [WrappedJoinRequest]. + */ +internal object SignalUrlBuilder { + + const val QUERY_JOIN_REQUEST = "join_request" + + /** + * Creates the websocket URL `/rtc/v1?join_request=`. + * + * [url] may use an http(s) or ws(s) scheme and may include a path prefix. A trailing + * `rtc` or `validate` path segment is replaced rather than appended to. + * + * The join request is gzipped only when that makes it smaller, and is encoded with the + * URL-safe base64 alphabet, keeping padding. + * + * @param connectOptions also decides whether this is a reconnect, and with which participant. + * @param publisherOffer bundled into the join request so the server can answer it + * in the same exchange. + * @return the websocket URL, or a failure if [url] cannot be parsed. + */ + fun buildJoinRequestUrl( + url: String, + connectOptions: ConnectOptions, + roomOptions: RoomOptions, + networkType: NetworkType? = null, + publisherOffer: SessionDescription? = null, + ): Result = runCatching { + val baseUrl = url.toHttpUrl().parseHttpUrl() + + // An empty last segment means the path ends in '/', which marks it as a directory. + val isDirectory = baseUrl.pathSegments.last().isEmpty() + val segments = baseUrl.encodedPathSegments.filter { it.isNotEmpty() }.toMutableList() + val lastSegment = segments.lastOrNull() + if (!isDirectory && (lastSegment == "rtc" || lastSegment == "validate")) { + segments.removeLastOrNull() + } + segments.add("rtc") + segments.add("v1") + + val rtcUrl = baseUrl.newBuilder() + .encodedPath("/" + segments.joinToString("/")) + .query(null) + .fragment(null) + .build() + + val joinRequest = buildWrappedJoinRequest( + connectOptions = connectOptions, + roomOptions = roomOptions, + networkType = networkType, + publisherOffer = publisherOffer, + ) + + return@runCatching "${rtcUrl.toString().toWebsocketUrl()}?$QUERY_JOIN_REQUEST=$joinRequest" + } + + /** + * Converts a signal websocket URL to its HTTP validation counterpart: + * - `wss://host/rtc?...` → `https://host/rtc/validate?...` + * - `wss://host/rtc/v1?...` → `https://host/rtc/v1/validate?...` + * + * @return the validation URL, or a failure if [wsUrl] is null or cannot be parsed. + */ + fun toValidateUrl(wsUrl: String?): Result { + if (wsUrl == null) { + return Result.failure(IllegalArgumentException("No signal URL to validate")) + } + return runCatching { + // addPathSegment replaces an empty last segment, so a trailing '/' doesn't double up. + wsUrl.toHttpUrl().parseHttpUrl() + .newBuilder() + .addPathSegment("validate") + .build() + .toString() + } + } + + /** + * @return the serialized [WrappedJoinRequest], base64url-encoded with padding. + */ + private fun buildWrappedJoinRequest( + connectOptions: ConnectOptions, + roomOptions: RoomOptions, + networkType: NetworkType?, + publisherOffer: SessionDescription?, + ): String { + val joinRequest = with(JoinRequest.newBuilder()) { + clientInfo = with(getClientInfo(connectOptions.clientProtocol).toBuilder()) { + protocol = connectOptions.protocolVersion.value + networkType?.let { network = it.protoName } + build() + } + connectionSettings = with(ConnectionSettings.newBuilder()) { + autoSubscribe = connectOptions.autoSubscribe + adaptiveStream = roomOptions.adaptiveStream + build() + } + publisherOffer?.let { this.publisherOffer = it } + if (connectOptions.reconnect) { + reconnect = true + reconnectReason = ReconnectReason.RR_SIGNAL_DISCONNECTED + connectOptions.participantSid?.let { participantSid = it } + } + build() + }.toByteArray() + + // gzip framing outweighs the savings on a small request, so keep whichever is smaller. + val gzipped = joinRequest.gzip() + val (payload, compression) = if (gzipped.size < joinRequest.size) { + gzipped to Compression.GZIP + } else { + joinRequest to Compression.NONE + } + + return WrappedJoinRequest.newBuilder() + .setCompression(compression) + .setJoinRequest(ByteString.copyFrom(payload)) + .build() + .toByteArray() + .toByteString() + .base64Url() + } + + private fun ByteArray.gzip(): ByteArray { + val output = ByteArrayOutputStream() + GZIPOutputStream(output).use { it.write(this) } + return output.toByteArray() + } +} diff --git a/livekit-android-test/src/test/java/io/livekit/android/room/util/SignalUrlBuilderTest.kt b/livekit-android-test/src/test/java/io/livekit/android/room/util/SignalUrlBuilderTest.kt new file mode 100644 index 000000000..aa044e869 --- /dev/null +++ b/livekit-android-test/src/test/java/io/livekit/android/room/util/SignalUrlBuilderTest.kt @@ -0,0 +1,356 @@ +/* + * Copyright 2026 LiveKit, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package io.livekit.android.room.util + +import io.livekit.android.ConnectOptions +import io.livekit.android.RoomOptions +import io.livekit.android.stats.NetworkType +import io.livekit.android.stats.getClientInfo +import livekit.LivekitModels +import livekit.LivekitRtc +import okhttp3.HttpUrl +import okhttp3.HttpUrl.Companion.toHttpUrl +import org.junit.Assert.assertEquals +import org.junit.Assert.assertFalse +import org.junit.Assert.assertTrue +import org.junit.Test +import java.util.Base64 +import java.util.zip.GZIPInputStream + +class SignalUrlBuilderTest { + + private fun buildUrl( + url: String = URL, + connectOptions: ConnectOptions = ConnectOptions(), + roomOptions: RoomOptions = RoomOptions(adaptiveStream = true), + networkType: NetworkType? = null, + publisherOffer: LivekitRtc.SessionDescription? = null, + ): String = SignalUrlBuilder.buildJoinRequestUrl( + url = url, + connectOptions = connectOptions, + roomOptions = roomOptions, + networkType = networkType, + publisherOffer = publisherOffer, + ).getOrThrow() + + /** Options as `SignalClient.reconnect` sets them. */ + private fun reconnectOptions(participantSid: String?) = ConnectOptions().apply { + reconnect = true + this.participantSid = participantSid + } + + /** OkHttp's [HttpUrl] only parses http(s), so ws(s) URLs are parsed with the equivalent scheme. */ + private fun parseWs(wsUrl: String): HttpUrl { + assertTrue("expected ws(s) scheme: $wsUrl", wsUrl.startsWith("ws://") || wsUrl.startsWith("wss://")) + return wsUrl.replaceFirst("ws", "http").toHttpUrl() + } + + /** The percent-encoded query is what actually goes on the wire. */ + private fun joinRequestParam(url: String): String { + val query = parseWs(url).encodedQuery!! + return query.split("&") + .first { it.startsWith("${SignalUrlBuilder.QUERY_JOIN_REQUEST}=") } + .removePrefix("${SignalUrlBuilder.QUERY_JOIN_REQUEST}=") + } + + private fun decodeWrapped(url: String): LivekitRtc.WrappedJoinRequest { + val bytes = Base64.getUrlDecoder().decode(joinRequestParam(url)) + return LivekitRtc.WrappedJoinRequest.parseFrom(bytes) + } + + private fun decodeJoinRequest(url: String): LivekitRtc.JoinRequest { + val wrapped = decodeWrapped(url) + val joinRequestBytes = when (wrapped.compression) { + LivekitRtc.WrappedJoinRequest.Compression.GZIP -> + GZIPInputStream(wrapped.joinRequest.newInput()).use { it.readBytes() } + + else -> wrapped.joinRequest.toByteArray() + } + return LivekitRtc.JoinRequest.parseFrom(joinRequestBytes) + } + + // region join_request encoding + + /** + * Standard base64 '+' and '/' are not safe in a query value: a receiver parsing the + * query as form-urlencoded turns '+' into a space. + */ + @Test + fun joinRequestParamIsUrlSafe() { + val param = joinRequestParam(buildUrl(publisherOffer = largeOffer())) + + assertFalse("Standard base64 leaked into the query: $param", param.contains("+")) + assertFalse("Standard base64 leaked into the query: $param", param.contains("/")) + } + + /** Padding is kept, matching client-sdk-js, rust-sdks and client-sdk-swift. */ + @Test + fun joinRequestParamKeepsPadding() { + val param = joinRequestParam(buildUrl()) + + assertEquals("Unpadded base64: $param", 0, param.length % 4) + } + + @Test + fun joinRequestRoundTrips() { + val request = decodeJoinRequest(buildUrl()) + + assertEquals(LivekitModels.ClientInfo.SDK.ANDROID, request.clientInfo.sdk) + assertEquals(getClientInfo().version, request.clientInfo.version) + assertTrue(request.connectionSettings.adaptiveStream) + assertFalse(request.reconnect) + assertEquals("", request.participantSid) + } + + @Test + fun reconnectJoinRequestRoundTrips() { + val request = decodeJoinRequest(buildUrl(connectOptions = reconnectOptions(participantSid = "PA_123"))) + + assertTrue(request.reconnect) + assertEquals(LivekitModels.ReconnectReason.RR_SIGNAL_DISCONNECTED, request.reconnectReason) + assertEquals("PA_123", request.participantSid) + } + + @Test + fun participantSidIsOnlySentOnReconnect() { + val options = ConnectOptions().apply { participantSid = "PA_123" } + val request = decodeJoinRequest(buildUrl(connectOptions = options)) + + assertFalse(request.reconnect) + assertEquals("", request.participantSid) + } + + @Test + fun joinRequestCarriesClientInfo() { + val options = ConnectOptions() + val request = decodeJoinRequest(buildUrl()) + + assertEquals(options.protocolVersion.value, request.clientInfo.protocol) + assertEquals(options.clientProtocol.value, request.clientInfo.clientProtocol) + assertEquals(getClientInfo().os, request.clientInfo.os) + } + + @Test + fun joinRequestCarriesConnectionSettings() { + val request = decodeJoinRequest( + buildUrl( + connectOptions = ConnectOptions(autoSubscribe = false), + roomOptions = RoomOptions(adaptiveStream = false), + ), + ) + + assertFalse(request.connectionSettings.autoSubscribe) + assertFalse(request.connectionSettings.adaptiveStream) + } + + @Test + fun joinRequestCarriesNetworkType() { + val request = decodeJoinRequest(buildUrl(networkType = NetworkType.CELLULAR)) + + assertEquals("cellular", request.clientInfo.network) + } + + @Test + fun networkTypeIsOmittedWhenUnknown() { + val request = decodeJoinRequest(buildUrl(networkType = null)) + + assertEquals("", request.clientInfo.network) + } + + @Test + fun joinRequestBundlesPublisherOffer() { + val offer = LivekitRtc.SessionDescription.newBuilder() + .setType("offer") + .setSdp("v=0\r\n") + .setId(7) + .build() + val request = decodeJoinRequest(buildUrl(publisherOffer = offer)) + + assertEquals(offer, request.publisherOffer) + } + + @Test + fun joinRequestHasNoPublisherOfferByDefault() { + val request = decodeJoinRequest(buildUrl()) + + assertFalse(request.hasPublisherOffer()) + } + + /** + * A minimal join request is small enough that gzip framing outweighs the + * savings, so it must stay uncompressed rather than growing the URL. + */ + @Test + fun smallRequestIsNotCompressed() { + val wrapped = decodeWrapped(buildUrl()) + + assertEquals(LivekitRtc.WrappedJoinRequest.Compression.NONE, wrapped.compression) + } + + @Test + fun largeRequestIsCompressed() { + val offer = largeOffer() + val wrapped = decodeWrapped(buildUrl(publisherOffer = offer)) + + assertEquals(LivekitRtc.WrappedJoinRequest.Compression.GZIP, wrapped.compression) + assertTrue(wrapped.joinRequest.size() < offer.serializedSize) + assertEquals(offer, decodeJoinRequest(buildUrl(publisherOffer = offer)).publisherOffer) + } + + // endregion + + // region URL + + @Test + fun onlyJoinRequestParam() { + val url = buildUrl(connectOptions = reconnectOptions(participantSid = "PA_123"), networkType = NetworkType.WIFI) + + assertEquals(setOf(SignalUrlBuilder.QUERY_JOIN_REQUEST), parseWs(url).queryParameterNames) + } + + @Test + fun httpsBecomesWss() { + val url = buildUrl(url = "https://example.livekit.cloud") + + assertTrue(url, url.startsWith("wss://example.livekit.cloud/rtc/v1?")) + } + + @Test + fun httpBecomesWs() { + val url = buildUrl(url = "http://localhost:7880") + + assertTrue(url, url.startsWith("ws://localhost:7880/rtc/v1?")) + } + + @Test + fun wssIsKept() { + val url = buildUrl(url = "wss://example.livekit.cloud") + + assertTrue(url, url.startsWith("wss://example.livekit.cloud/rtc/v1?")) + } + + @Test + fun trailingSlashIsHandled() { + assertEquals("/rtc/v1", parseWs(buildUrl(url = "wss://example.livekit.cloud/")).encodedPath) + } + + @Test + fun pathPrefixIsKept() { + assertEquals("/livekit/rtc/v1", parseWs(buildUrl(url = "wss://example.com/livekit")).encodedPath) + assertEquals("/livekit/rtc/v1", parseWs(buildUrl(url = "wss://example.com/livekit/")).encodedPath) + } + + @Test + fun trailingRtcSegmentIsReplaced() { + assertEquals("/rtc/v1", parseWs(buildUrl(url = "wss://example.livekit.cloud/rtc")).encodedPath) + assertEquals("/livekit/rtc/v1", parseWs(buildUrl(url = "wss://example.com/livekit/rtc")).encodedPath) + } + + @Test + fun trailingValidateSegmentIsReplaced() { + assertEquals("/rtc/v1", parseWs(buildUrl(url = "wss://example.livekit.cloud/validate")).encodedPath) + } + + @Test + fun hostNamedLikeSignalSegmentIsKept() { + val url = buildUrl(url = "ws://rtc:7880") + + assertTrue(url, url.startsWith("ws://rtc:7880/rtc/v1?")) + } + + @Test + fun baseUrlQueryIsDropped() { + val url = buildUrl(url = "wss://example.livekit.cloud/livekit?foo=bar") + + assertEquals("/livekit/rtc/v1", parseWs(url).encodedPath) + assertEquals(setOf(SignalUrlBuilder.QUERY_JOIN_REQUEST), parseWs(url).queryParameterNames) + } + + @Test + fun invalidUrlFails() { + val result = SignalUrlBuilder.buildJoinRequestUrl( + url = "not a url", + connectOptions = ConnectOptions(), + roomOptions = RoomOptions(), + ) + + assertTrue(result.isFailure) + } + + // endregion + + // region toValidateUrl + + @Test + fun validateUrlForLegacyPath() { + val validate = SignalUrlBuilder.toValidateUrl("wss://example.livekit.cloud/rtc?protocol=13&sdk=android").getOrThrow() + + assertEquals("https://example.livekit.cloud/rtc/validate?protocol=13&sdk=android", validate) + } + + @Test + fun validateUrlForV1Path() { + val url = buildUrl() + val validate = SignalUrlBuilder.toValidateUrl(url).getOrThrow().toHttpUrl() + + assertEquals("https", validate.scheme) + assertEquals("/rtc/v1/validate", validate.encodedPath) + assertEquals(joinRequestParam(url), validate.encodedQuery!!.removePrefix("${SignalUrlBuilder.QUERY_JOIN_REQUEST}=")) + } + + @Test + fun validateUrlWsBecomesHttp() { + val validate = SignalUrlBuilder.toValidateUrl("ws://localhost:7880/rtc/v1?join_request=abc=").getOrThrow() + + assertEquals("http://localhost:7880/rtc/v1/validate?join_request=abc=", validate) + } + + @Test + fun validateUrlHandlesTrailingSlash() { + val validate = SignalUrlBuilder.toValidateUrl("wss://example.livekit.cloud/rtc/").getOrThrow() + + assertEquals("https://example.livekit.cloud/rtc/validate", validate) + } + + @Test + fun validateUrlInvalidUrlFails() { + assertTrue(SignalUrlBuilder.toValidateUrl("not a url").isFailure) + } + + @Test + fun validateUrlNullUrlFails() { + assertTrue(SignalUrlBuilder.toValidateUrl(null).isFailure) + } + + // endregion + + companion object { + private const val URL = "wss://example.livekit.cloud" + + /** An SDP-sized offer: large enough to compress well and to need the full base64 alphabet. */ + private fun largeOffer(): LivekitRtc.SessionDescription { + val sdp = (0 until 40).joinToString("\r\n") { i -> + "a=candidate:$i 1 udp ${2122260223 - i} 192.168.1.${i % 255} ${50000 + i} typ host generation 0 ufrag ~?>+/" + } + return LivekitRtc.SessionDescription.newBuilder() + .setType("offer") + .setSdp(sdp) + .setId(1) + .build() + } + } +} From 30a20ef334ecd9b460d3c28483d4f4a2aba9391b Mon Sep 17 00:00:00 2001 From: Sen Chang Date: Tue, 3 Nov 2026 09:35:03 -0800 Subject: [PATCH 02/12] Add SinglePeerConnectionTransport for /rtc/v1 single PC mode Adds ConnectOptions.singlePeerConnection (default false). When set, the signal client joins through /rtc/v1 with a join_request and RTCEngine builds a SinglePeerConnectionTransport around one publisher peer connection observed by DuplexTransportObserver: - the client makes every offer; the server's media_sections_requirement adds recvonly transceivers, and mid_to_track_id from answers maps received tracks back to their track IDs - subscriber primary is forced off, so the publisher drives connection state and data channels - PublisherTransportObserver is opened up for DuplexTransportObserver to also forward remote tracks and data channels Fallback to dual PC and offer-on-join are not included yet. --- .../detekt-baseline-release.xml | 1 + .../java/io/livekit/android/ConnectOptions.kt | 5 + .../android/room/DuplexTransportObserver.kt | 57 +++ .../room/PublisherTransportObserver.kt | 14 +- .../java/io/livekit/android/room/RTCEngine.kt | 47 +- .../io/livekit/android/room/SignalClient.kt | 7 +- .../room/SinglePeerConnectionTransport.kt | 143 ++++++ .../room/DuplexTransportObserverTest.kt | 220 +++++++++ .../room/SinglePeerConnectionTransportTest.kt | 460 ++++++++++++++++++ 9 files changed, 930 insertions(+), 24 deletions(-) create mode 100644 livekit-android-sdk/src/main/java/io/livekit/android/room/DuplexTransportObserver.kt create mode 100644 livekit-android-sdk/src/main/java/io/livekit/android/room/SinglePeerConnectionTransport.kt create mode 100644 livekit-android-test/src/test/java/io/livekit/android/room/DuplexTransportObserverTest.kt create mode 100644 livekit-android-test/src/test/java/io/livekit/android/room/SinglePeerConnectionTransportTest.kt diff --git a/livekit-android-sdk/detekt-baseline-release.xml b/livekit-android-sdk/detekt-baseline-release.xml index c8efe8b1f..3b35e4f99 100644 --- a/livekit-android-sdk/detekt-baseline-release.xml +++ b/livekit-android-sdk/detekt-baseline-release.xml @@ -24,6 +24,7 @@ CyclomaticComplexMethod:RTCEngine.kt$RTCEngine$@Synchronized @VisibleForTesting(otherwise = VisibleForTesting.PACKAGE_PRIVATE) fun reconnect() CyclomaticComplexMethod:RTCEngine.kt$RTCEngine$fun onMessage(dataChannel: DataChannel, buffer: DataChannel.Buffer?) CyclomaticComplexMethod:RTCEngine.kt$RTCEngine$private fun makeRTCConfig( serverResponse: Either<JoinResponse, ReconnectResponse>, connectOptions: ConnectOptions, ): RTCConfiguration + CyclomaticComplexMethod:RTCEngine.kt$RTCEngine$private suspend fun configure(joinResponse: JoinResponse, connectOptions: ConnectOptions) CyclomaticComplexMethod:Room.kt$Room$@Throws(Exception::class) suspend fun connect(url: String, token: String, options: ConnectOptions = ConnectOptions()) CyclomaticComplexMethod:RoomEvent.kt$fun LivekitModels.DisconnectReason?.convert(): DisconnectReason CyclomaticComplexMethod:SignalClient.kt$SignalClient$override fun onFailure(webSocket: WebSocket, t: Throwable, response: Response?) diff --git a/livekit-android-sdk/src/main/java/io/livekit/android/ConnectOptions.kt b/livekit-android-sdk/src/main/java/io/livekit/android/ConnectOptions.kt index 7a10b9694..f6389ae0a 100644 --- a/livekit-android-sdk/src/main/java/io/livekit/android/ConnectOptions.kt +++ b/livekit-android-sdk/src/main/java/io/livekit/android/ConnectOptions.kt @@ -62,6 +62,11 @@ data class ConnectOptions( * version supported by this SDK build. */ val clientProtocol: ClientProtocolVersion = ClientProtocolVersion.DATA_STREAM_V2, + + /** + * Use a single peer connection instead of one subscriber and one publisher. + */ + val singlePeerConnection: Boolean = false, ) { internal var reconnect: Boolean = false internal var participantSid: String? = null diff --git a/livekit-android-sdk/src/main/java/io/livekit/android/room/DuplexTransportObserver.kt b/livekit-android-sdk/src/main/java/io/livekit/android/room/DuplexTransportObserver.kt new file mode 100644 index 000000000..7e1ee2192 --- /dev/null +++ b/livekit-android-sdk/src/main/java/io/livekit/android/room/DuplexTransportObserver.kt @@ -0,0 +1,57 @@ +/* + * Copyright 2026 LiveKit, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package io.livekit.android.room + +import io.livekit.android.util.LKLog +import io.livekit.android.webrtc.peerconnection.RTCThreadToken +import io.livekit.android.webrtc.peerconnection.executeOnRTCThread +import livekit.org.webrtc.DataChannel +import livekit.org.webrtc.MediaStream +import livekit.org.webrtc.MediaStreamTrack +import livekit.org.webrtc.RtpReceiver +import livekit.org.webrtc.RtpTransceiver + +internal class DuplexTransportObserver(engine: RTCEngine, client: SignalClient, rtcThreadToken: RTCThreadToken) : + PublisherTransportObserver(engine, client, rtcThreadToken) { + var dataChannelListener: ((DataChannel) -> Unit)? = null + + override fun onTrack(transceiver: RtpTransceiver?) { + when (transceiver?.mediaType) { + MediaStreamTrack.MediaType.MEDIA_TYPE_AUDIO -> LKLog.v { "peerconn started receiving audio" } + MediaStreamTrack.MediaType.MEDIA_TYPE_VIDEO -> LKLog.v { "peerconn started receiving video" } + else -> LKLog.d { "peerconn started receiving unknown media type: ${transceiver?.mediaType}" } + } + } + + override fun onDataChannel(dataChannel: DataChannel?) { + executeOnRTCThread(rtcThreadToken) { + dataChannel?.let { + dataChannelListener?.invoke(it) + } + } + } + + override fun onAddTrack(receiver: RtpReceiver?, streams: Array?) { + executeOnRTCThread(rtcThreadToken) { + if (receiver != null && streams != null) { + val track = receiver.track() ?: return@executeOnRTCThread + LKLog.v { "onAddTrack: ${track.kind()}, ${track.id()}, ${streams.fold("") { sum, it -> "$sum, $it" }}" } + engine.listener?.onAddTrack(receiver, track, streams) + } + } + } +} diff --git a/livekit-android-sdk/src/main/java/io/livekit/android/room/PublisherTransportObserver.kt b/livekit-android-sdk/src/main/java/io/livekit/android/room/PublisherTransportObserver.kt index 2dea63532..ed513703f 100644 --- a/livekit-android-sdk/src/main/java/io/livekit/android/room/PublisherTransportObserver.kt +++ b/livekit-android-sdk/src/main/java/io/livekit/android/room/PublisherTransportObserver.kt @@ -1,5 +1,5 @@ /* - * Copyright 2023-2025 LiveKit, Inc. + * Copyright 2023-2026 LiveKit, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -32,10 +32,10 @@ import livekit.org.webrtc.RtpReceiver import livekit.org.webrtc.RtpTransceiver import livekit.org.webrtc.SessionDescription -internal class PublisherTransportObserver( - private val engine: RTCEngine, - private val client: SignalClient, - private val rtcThreadToken: RTCThreadToken, +internal open class PublisherTransportObserver( + protected val engine: RTCEngine, + protected val client: SignalClient, + protected val rtcThreadToken: RTCThreadToken, ) : PeerConnection.Observer, PeerConnectionTransport.Listener, PeerConnectionStateObservable { var connectionChangeListener: PeerConnectionStateListener? = null @@ -43,7 +43,7 @@ internal class PublisherTransportObserver( @FlowObservable @get:FlowObservable override var connectionState by flowDelegate(PeerConnection.PeerConnectionState.NEW) - private set + protected set override fun onIceCandidate(iceCandidate: IceCandidate?) { executeOnRTCThread(rtcThreadToken) { @@ -107,6 +107,6 @@ internal class PublisherTransportObserver( override fun onTrack(transceiver: RtpTransceiver?) { } - override fun onAddTrack(p0: RtpReceiver?, p1: Array?) { + override fun onAddTrack(receiver: RtpReceiver?, streams: Array?) { } } diff --git a/livekit-android-sdk/src/main/java/io/livekit/android/room/RTCEngine.kt b/livekit-android-sdk/src/main/java/io/livekit/android/room/RTCEngine.kt index a2e9eb042..cac668faf 100644 --- a/livekit-android-sdk/src/main/java/io/livekit/android/room/RTCEngine.kt +++ b/livekit-android-sdk/src/main/java/io/livekit/android/room/RTCEngine.kt @@ -205,7 +205,7 @@ internal constructor( internal val serverInfo: ServerInfo? get() = client.serverInfo - private val publisherObserver = PublisherTransportObserver(this, client, rtcThreadToken) + private var publisherObserver: PublisherTransportObserver? = null private val subscriberObserver = SubscriberTransportObserver(this, client, rtcThreadToken) internal var transport: Transport? = null @@ -318,7 +318,7 @@ internal constructor( isClosed = false listener?.onSignalConnected(false) - isSubscriberPrimary = joinResponse.subscriberPrimary + isSubscriberPrimary = !options.singlePeerConnection && joinResponse.subscriberPrimary configure(joinResponse, options) // The publisher created above needs the attempt's start time before its first offer, in @@ -347,6 +347,13 @@ internal constructor( } }, ) { + val publisherObserver = if (connectOptions.singlePeerConnection) { + DuplexTransportObserver(this@RTCEngine, client, rtcThreadToken) + } else { + PublisherTransportObserver(this@RTCEngine, client, rtcThreadToken) + } + this@RTCEngine.publisherObserver = publisherObserver + participantSid = if (joinResponse.hasParticipant()) { joinResponse.participant.sid } else { @@ -360,9 +367,6 @@ internal constructor( publisherObserver, publisherObserver, ) - val subscriber = runCatching { pctFactory.create(rtcConfig, subscriberObserver, null) } - .onFailure { publisher.close() } - .getOrThrow() val connectionStateListener: PeerConnectionStateListener = { newState -> LKLog.v { "onIceConnection new state: $newState" } @@ -373,7 +377,7 @@ internal constructor( } } - if (joinResponse.subscriberPrimary) { + if (this@RTCEngine.isSubscriberPrimary) { // in subscriber primary mode, server side opens sub data channels. subscriberObserver.dataChannelListener = onDataChannel@{ dataChannel: DataChannel -> when (dataChannel.label()) { @@ -396,14 +400,25 @@ internal constructor( publisherObserver.connectionChangeListener = connectionStateListener } - transport = DualPeerConnectionTransport( - publisher, - subscriber, - publisherObserver, - subscriberObserver, - joinResponse.subscriberPrimary, - joinResponse.fastPublish, - ) + if (connectOptions.singlePeerConnection) { + transport = SinglePeerConnectionTransport( + publisher, + publisherObserver, + ) + } else { + val subscriber = runCatching { pctFactory.create(rtcConfig, subscriberObserver, null) } + .onFailure { publisher.close() } + .getOrThrow() + + transport = DualPeerConnectionTransport( + publisher, + subscriber, + publisherObserver, + subscriberObserver, + joinResponse.subscriberPrimary, + joinResponse.fastPublish, + ) + } ensureActive() // data channels @@ -551,7 +566,7 @@ internal constructor( executeBlockingOnRTCThread(rtcThreadToken) { runBlocking { configurationLock.withLock { - publisherObserver.connectionChangeListener = null + publisherObserver?.connectionChangeListener = null subscriberObserver.connectionChangeListener = null transport?.close() transport = null @@ -969,7 +984,7 @@ internal constructor( } throw RoomException.ConnectException( - "could not establish publisher connection: publisher state: ${publisherObserver.connectionState}, channel state: ${channelManager.state}", + "could not establish publisher connection: publisher state: ${publisherObserver?.connectionState}, channel state: ${channelManager.state}", ) } diff --git a/livekit-android-sdk/src/main/java/io/livekit/android/room/SignalClient.kt b/livekit-android-sdk/src/main/java/io/livekit/android/room/SignalClient.kt index a3d01311d..0ab830aa0 100644 --- a/livekit-android-sdk/src/main/java/io/livekit/android/room/SignalClient.kt +++ b/livekit-android-sdk/src/main/java/io/livekit/android/room/SignalClient.kt @@ -192,9 +192,14 @@ constructor( // Clean up any pre-existing connection. close(reason = "Starting new connection", shouldClearQueuedRequests = false) - val wsUrlString = "${url.toWebsocketUrl()}/rtc${createConnectionParams(getClientInfo(options.clientProtocol), options, roomOptions)}" + var wsUrlString = "${url.toWebsocketUrl()}/rtc${createConnectionParams(getClientInfo(options.clientProtocol), options, roomOptions)}" isReconnecting = options.reconnect + if (options.singlePeerConnection) { + wsUrlString = SignalUrlBuilder.buildJoinRequestUrl(wsUrlString, options, roomOptions, networkInfo.getNetworkType()) + .getOrElse { wsUrlString } + } + LKLog.i { "connecting to $wsUrlString" } coroutineScope = CloseableCoroutineScope(SupervisorJob() + ioDispatcher) diff --git a/livekit-android-sdk/src/main/java/io/livekit/android/room/SinglePeerConnectionTransport.kt b/livekit-android-sdk/src/main/java/io/livekit/android/room/SinglePeerConnectionTransport.kt new file mode 100644 index 000000000..5426a2047 --- /dev/null +++ b/livekit-android-sdk/src/main/java/io/livekit/android/room/SinglePeerConnectionTransport.kt @@ -0,0 +1,143 @@ +/* + * Copyright 2026 LiveKit, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package io.livekit.android.room + +import io.livekit.android.room.util.PeerConnectionStateObservable +import io.livekit.android.room.util.waitUntilConnected +import io.livekit.android.util.Either +import io.livekit.android.util.LKLog +import io.livekit.android.webrtc.toProtoSessionDescription +import kotlinx.coroutines.runBlocking +import livekit.LivekitRtc +import livekit.org.webrtc.IceCandidate +import livekit.org.webrtc.MediaConstraints +import livekit.org.webrtc.MediaStreamTrack +import livekit.org.webrtc.PeerConnection +import livekit.org.webrtc.RtpReceiver +import livekit.org.webrtc.RtpTransceiver +import livekit.org.webrtc.SessionDescription +import java.util.concurrent.ConcurrentHashMap + +/** + * A [Transport] with one peer connection that both publishes and receives. The client makes + * every offer on [publisher], and the server opens receiving media sections on it through + * [handleMediaSectionsRequirement]. + * + * @param publisherState connection state of [publisher], as reported by its observer. + */ +@Suppress("TooManyFunctions") +internal class SinglePeerConnectionTransport( + override val publisher: PeerConnectionTransport, + private val publisherState: PeerConnectionStateObservable, +) : Transport { + private val midToTrackId: MutableMap = ConcurrentHashMap() + override val subscriber: PeerConnectionTransport + get() = publisher + override val publisherConnectsOnDemand: Boolean + get() = false + override val publisherOfferConstraints: List + get() = emptyList() + + override fun shouldNegotiatePublisherOnJoin(hasPublished: Boolean): Boolean { + return true + } + + override fun addIceCandidate(candidate: IceCandidate, target: LivekitRtc.SignalTarget): Boolean { + if (target == LivekitRtc.SignalTarget.SUBSCRIBER || target == LivekitRtc.SignalTarget.PUBLISHER) { + publisher.addIceCandidate(candidate) + return true + } + LKLog.i { "unknown ice candidate target: $target" } + return false + } + + override suspend fun answerServerOffer( + offer: SessionDescription, + offerId: Int, + ): Either { + return Either.Right("Received offer but not in dual PC mode, ignoring") + } + + override suspend fun applyServerAnswer( + answer: SessionDescription, + offerId: Int, + midToTrackId: Map, + ): Either { + for (k in midToTrackId) { + this.midToTrackId[k.key] = k.value + } + val res = publisher.setRemoteDescription(answer, offerId) + return res + } + + override fun trackIdForReceiver(receiver: RtpReceiver): String? { + val receiverId = receiver.id() + val mid = runBlocking { + publisher.withPeerConnection { + transceivers.firstOrNull { it.receiver.id() == receiverId }?.mid + } + } ?: return null + return midToTrackId[mid] + } + + override suspend fun handleMediaSectionsRequirement(requirement: LivekitRtc.MediaSectionsRequirement) { + if (publisher.isClosed()) { + return + } + val transceiverInit = RtpTransceiver.RtpTransceiverInit(RtpTransceiver.RtpTransceiverDirection.RECV_ONLY) + publisher.withPeerConnection { + for (i in 0..() + private val receiver = mock { on { track() } doReturn track } + private val streams = arrayOf(mock()) + + @Before + fun setup() { + engineListener = mock() + engine = mock() + whenever(engine.listener).thenReturn(engineListener) + client = mock() + observer = DuplexTransportObserver(engine, client, MockRTCThreadToken()) + } + + /** + * Callbacks run asynchronously on the single RTC thread; a blocking no-op queued + * behind them returns once they have all run. + */ + private fun flushRTCThread() { + executeBlockingOnRTCThread(MockRTCThreadToken()) {} + } + + // region onAddTrack + + @Test + fun addedTrackIsForwardedToEngine() { + observer.onAddTrack(receiver, streams) + flushRTCThread() + + verify(engineListener).onAddTrack(receiver, track, streams) + } + + @Test + fun addedTrackWithoutMediaTrackIsIgnored() { + val emptyReceiver = mock { on { track() } doReturn null } + + observer.onAddTrack(emptyReceiver, streams) + flushRTCThread() + + verify(engineListener, never()).onAddTrack(any(), any(), any()) + } + + @Test + fun addedTrackWithoutReceiverIsIgnored() { + observer.onAddTrack(null, streams) + flushRTCThread() + + verify(engineListener, never()).onAddTrack(any(), any(), any()) + } + + @Test + fun addedTrackWithoutStreamsIsIgnored() { + observer.onAddTrack(receiver, null) + flushRTCThread() + + verify(engineListener, never()).onAddTrack(any(), any(), any()) + } + + @Test + fun addedTrackWithoutEngineListenerIsDropped() { + whenever(engine.listener).thenReturn(null) + + observer.onAddTrack(receiver, streams) + flushRTCThread() + } + + @Test + fun addedTrackAfterDisposeIsDropped() { + val disposedObserver = DuplexTransportObserver(engine, client, disposedToken) + + disposedObserver.onAddTrack(receiver, streams) + flushRTCThread() + + verify(engineListener, never()).onAddTrack(any(), any(), any()) + } + + // endregion + + // region onDataChannel + + @Test + fun dataChannelIsForwardedToListener() { + val channel = mock() + val received = mutableListOf() + observer.dataChannelListener = { received.add(it) } + + observer.onDataChannel(channel) + flushRTCThread() + + assertEquals(listOf(channel), received) + } + + @Test + fun nullDataChannelIsIgnored() { + val received = mutableListOf() + observer.dataChannelListener = { received.add(it) } + + observer.onDataChannel(null) + flushRTCThread() + + assertEquals(emptyList(), received) + } + + @Test + fun dataChannelWithoutListenerIsDropped() { + observer.onDataChannel(mock()) + flushRTCThread() + } + + // endregion + + // region onTrack + + @Test + fun trackOfAnyMediaTypeIsAccepted() { + val audio = mock { on { mediaType } doReturn MediaStreamTrack.MediaType.MEDIA_TYPE_AUDIO } + val video = mock { on { mediaType } doReturn MediaStreamTrack.MediaType.MEDIA_TYPE_VIDEO } + + observer.onTrack(audio) + observer.onTrack(video) + observer.onTrack(null) + } + + // endregion + + // region publisher behavior + + @Test + fun localCandidateIsSentForPublisher() { + val candidate = IceCandidate("0", 0, "candidate:1 1 udp 2122260223 192.168.1.2 50000 typ host") + + observer.onIceCandidate(candidate) + flushRTCThread() + + verify(client).sendCandidate(candidate, SignalTarget.PUBLISHER) + } + + @Test + fun offerIsSentToServer() { + val offer = SessionDescription(SessionDescription.Type.OFFER, "local_offer") + + observer.onOffer(offer, offerId = 3) + flushRTCThread() + + verify(client).sendOffer(offer, 3) + } + + @Test + fun renegotiationNeededNegotiates() { + observer.onRenegotiationNeeded() + flushRTCThread() + + verify(engine).negotiatePublisher() + } + + @Test + fun connectionChangeUpdatesState() { + val states = mutableListOf() + observer.connectionChangeListener = { states.add(it) } + + observer.onConnectionChange(PeerConnectionState.CONNECTED) + flushRTCThread() + + assertSame(PeerConnectionState.CONNECTED, observer.connectionState) + assertEquals(listOf(PeerConnectionState.CONNECTED), states) + } + + // endregion +} diff --git a/livekit-android-test/src/test/java/io/livekit/android/room/SinglePeerConnectionTransportTest.kt b/livekit-android-test/src/test/java/io/livekit/android/room/SinglePeerConnectionTransportTest.kt new file mode 100644 index 000000000..bb05fb2c9 --- /dev/null +++ b/livekit-android-test/src/test/java/io/livekit/android/room/SinglePeerConnectionTransportTest.kt @@ -0,0 +1,460 @@ +/* + * Copyright 2026 LiveKit, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package io.livekit.android.room + +import android.javax.sdp.SdpFactory +import io.livekit.android.room.util.PeerConnectionStateObservable +import io.livekit.android.test.mock.MockPeerConnection +import io.livekit.android.test.mock.MockRTCThreadToken +import io.livekit.android.test.mock.MockRtpReceiver +import io.livekit.android.util.Either +import io.livekit.android.util.FlowObservable +import io.livekit.android.util.flowDelegate +import io.livekit.android.webrtc.toProtoSessionDescription +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.ExperimentalCoroutinesApi +import kotlinx.coroutines.launch +import kotlinx.coroutines.test.runCurrent +import kotlinx.coroutines.test.runTest +import livekit.LivekitRtc.MediaSectionsRequirement +import livekit.LivekitRtc.SignalTarget +import livekit.org.webrtc.IceCandidate +import livekit.org.webrtc.MediaStreamTrack.MediaType +import livekit.org.webrtc.MockPeerConnectionFactory +import livekit.org.webrtc.PeerConnection +import livekit.org.webrtc.PeerConnection.IceConnectionState +import livekit.org.webrtc.PeerConnection.PeerConnectionState +import livekit.org.webrtc.PeerConnection.RTCConfiguration +import livekit.org.webrtc.RtpReceiver +import livekit.org.webrtc.RtpTransceiver.RtpTransceiverDirection +import livekit.org.webrtc.RtpTransceiver.RtpTransceiverInit +import livekit.org.webrtc.SessionDescription +import livekit.org.webrtc.WebRTCInitializer +import org.junit.Assert.assertEquals +import org.junit.Assert.assertFalse +import org.junit.Assert.assertNull +import org.junit.Assert.assertSame +import org.junit.Assert.assertTrue +import org.junit.Before +import org.junit.Test +import org.mockito.kotlin.any +import org.mockito.kotlin.mock +import org.mockito.kotlin.never +import org.mockito.kotlin.spy +import org.mockito.kotlin.verify +import org.mockito.kotlin.verifyBlocking +import org.mockito.kotlin.whenever + +@ExperimentalCoroutinesApi +class SinglePeerConnectionTransportTest { + + private class FakeConnectionState : PeerConnectionStateObservable { + @FlowObservable + @get:FlowObservable + override var connectionState by flowDelegate(PeerConnectionState.NEW) + } + + private lateinit var publisher: PeerConnectionTransport + private val publisherState = FakeConnectionState() + + private val publisherPc: MockPeerConnection + get() = publisher.peerConnection as MockPeerConnection + + private val candidate = IceCandidate("0", 0, "candidate:1 1 udp 2122260223 192.168.1.2 50000 typ host") + + @Before + fun setup() { + WebRTCInitializer.initialize() + publisher = spy( + PeerConnectionTransport( + config = RTCConfiguration(emptyList()), + pcObserver = mock(), + listener = null, + ioDispatcher = Dispatchers.Unconfined, + connectionFactory = MockPeerConnectionFactory(), + sdpFactory = SdpFactory.getInstance(), + rtcThreadToken = MockRTCThreadToken(), + ), + ) + } + + private fun transport() = SinglePeerConnectionTransport( + publisher = publisher, + publisherState = publisherState, + ) + + private fun answer(sdp: String = "remote_answer") = SessionDescription(SessionDescription.Type.ANSWER, sdp) + + // region roles + + @Test + fun publisherIsThePeerConnection() { + assertSame(publisher, transport().publisher) + } + + @Test + fun subscriberIsThePublisher() { + assertSame(publisher, transport().subscriber) + } + + @Test + fun publisherConnectsOnJoin() { + assertFalse(transport().publisherConnectsOnDemand) + } + + @Test + fun publisherOffersHaveNoConstraints() { + assertTrue(transport().publisherOfferConstraints.isEmpty()) + } + + @Test + fun publisherIsNegotiatedOnJoin() { + assertTrue(transport().shouldNegotiatePublisherOnJoin(hasPublished = false)) + assertTrue(transport().shouldNegotiatePublisherOnJoin(hasPublished = true)) + } + + // endregion + + // region addIceCandidate + + @Test + fun publisherCandidateGoesToPublisher() { + assertTrue(transport().addIceCandidate(candidate, SignalTarget.PUBLISHER)) + + verify(publisher).addIceCandidate(candidate) + } + + @Test + fun subscriberCandidateGoesToPublisher() { + assertTrue(transport().addIceCandidate(candidate, SignalTarget.SUBSCRIBER)) + + verify(publisher).addIceCandidate(candidate) + } + + @Test + fun unrecognizedTargetCandidateIsRejected() { + assertFalse(transport().addIceCandidate(candidate, SignalTarget.UNRECOGNIZED)) + + verify(publisher, never()).addIceCandidate(any()) + } + + // endregion + + // region answerServerOffer + + @Test + fun answerServerOfferIsRejected() = runTest { + val offer = SessionDescription(SessionDescription.Type.OFFER, "remote_offer") + + val result = transport().answerServerOffer(offer, offerId = 7) + + assertTrue("$result", result is Either.Right) + } + + @Test + fun answerServerOfferLeavesPublisherAlone() = runTest { + val offer = SessionDescription(SessionDescription.Type.OFFER, "remote_offer") + + transport().answerServerOffer(offer, offerId = 7) + + verifyBlocking(publisher, never()) { setRemoteDescription(any(), any()) } + assertNull(publisherPc.remoteDesc) + assertNull(publisherPc.localDesc) + } + + // endregion + + // region applyServerAnswer + + @Test + fun applyServerAnswerAppliesToPublisher() = runTest { + val answer = answer() + + val result = transport().applyServerAnswer(answer, offerId = 7, midToTrackId = emptyMap()) + + assertTrue("$result", result is Either.Left) + assertSame(answer, publisherPc.remoteDesc) + } + + @Test + fun applyServerAnswerPassesOfferId() = runTest { + val answer = answer() + + transport().applyServerAnswer(answer, offerId = 7, midToTrackId = emptyMap()) + + verifyBlocking(publisher) { setRemoteDescription(answer, 7) } + } + + @Test + fun applyServerAnswerFailsWhenClosed() = runTest { + publisher.close() + + val result = transport().applyServerAnswer(answer(), offerId = 7, midToTrackId = emptyMap()) + + assertTrue("$result", result is Either.Right) + } + + // endregion + + // region trackIdForReceiver + + /** + * Adds a receiving media section with [mid] to the publisher. + * + * @return the receiver of the media section. + */ + private fun receiverForMid(mid: String?, mediaType: MediaType = MediaType.MEDIA_TYPE_AUDIO): RtpReceiver { + val transceiver = publisherPc.addTransceiver( + mediaType, + RtpTransceiverInit(RtpTransceiverDirection.RECV_ONLY), + ) + whenever(transceiver.mid).thenReturn(mid) + return transceiver.receiver + } + + @Test + fun trackIdForReceiverIsNullBeforeAnswer() { + val receiver = receiverForMid("0") + + assertNull(transport().trackIdForReceiver(receiver)) + } + + @Test + fun trackIdForReceiverComesFromAnswer() = runTest { + val transport = transport() + val audioReceiver = receiverForMid("0") + val videoReceiver = receiverForMid("1", MediaType.MEDIA_TYPE_VIDEO) + + transport.applyServerAnswer(answer(), offerId = 7, midToTrackId = mapOf("0" to "TR_a", "1" to "TR_b")) + + assertEquals("TR_a", transport.trackIdForReceiver(audioReceiver)) + assertEquals("TR_b", transport.trackIdForReceiver(videoReceiver)) + } + + @Test + fun trackIdForReceiverIsNullForUnmappedMid() = runTest { + val transport = transport() + val receiver = receiverForMid("2") + + transport.applyServerAnswer(answer(), offerId = 7, midToTrackId = mapOf("0" to "TR_a")) + + assertNull(transport.trackIdForReceiver(receiver)) + } + + @Test + fun trackIdForReceiverIsNullWithoutMid() = runTest { + val transport = transport() + val receiver = receiverForMid(null) + + transport.applyServerAnswer(answer(), offerId = 7, midToTrackId = mapOf("0" to "TR_a")) + + assertNull(transport.trackIdForReceiver(receiver)) + } + + @Test + fun trackIdForReceiverIsNullForUnknownReceiver() = runTest { + val transport = transport() + receiverForMid("0") + + transport.applyServerAnswer(answer(), offerId = 7, midToTrackId = mapOf("0" to "TR_a")) + + assertNull(transport.trackIdForReceiver(MockRtpReceiver.create(id = "unknown"))) + } + + @Test + fun trackIdForReceiverIsNullWhenClosed() = runTest { + val transport = transport() + val receiver = receiverForMid("0") + transport.applyServerAnswer(answer(), offerId = 7, midToTrackId = mapOf("0" to "TR_a")) + + publisher.close() + + assertNull(transport.trackIdForReceiver(receiver)) + } + + @Test + fun trackIdForReceiverKeepsMappingAcrossAnswerWithoutOne() = runTest { + val transport = transport() + val receiver = receiverForMid("0") + + transport.applyServerAnswer(answer("first"), offerId = 7, midToTrackId = mapOf("0" to "TR_a")) + transport.applyServerAnswer(answer("second"), offerId = 8, midToTrackId = emptyMap()) + + assertEquals("TR_a", transport.trackIdForReceiver(receiver)) + } + + @Test + fun trackIdForReceiverTakesLatestAnswerMapping() = runTest { + val transport = transport() + val receiver = receiverForMid("0") + + transport.applyServerAnswer(answer("first"), offerId = 7, midToTrackId = mapOf("0" to "TR_a")) + transport.applyServerAnswer(answer("second"), offerId = 8, midToTrackId = mapOf("0" to "TR_b")) + + assertEquals("TR_b", transport.trackIdForReceiver(receiver)) + } + + // endregion + + // region handleMediaSectionsRequirement + + private fun requirement(audios: Int, videos: Int) = MediaSectionsRequirement.newBuilder() + .setNumAudios(audios) + .setNumVideos(videos) + .build() + + @Test + fun handleMediaSectionsRequirementAddsRequiredSections() = runTest { + transport().handleMediaSectionsRequirement(requirement(audios = 2, videos = 3)) + + val mediaTypes = publisherPc.transceivers.map { it.mediaType } + assertEquals(2, mediaTypes.count { it == MediaType.MEDIA_TYPE_AUDIO }) + assertEquals(3, mediaTypes.count { it == MediaType.MEDIA_TYPE_VIDEO }) + } + + @Test + fun handleMediaSectionsRequirementAddsReceiveOnlySections() = runTest { + transport().handleMediaSectionsRequirement(requirement(audios = 2, videos = 3)) + + assertTrue(publisherPc.transceivers.isNotEmpty()) + publisherPc.transceivers.forEach { transceiver -> + assertEquals(RtpTransceiverDirection.RECV_ONLY, transceiver.direction) + } + } + + @Test + fun handleMediaSectionsRequirementWithNoSectionsAddsNothing() = runTest { + transport().handleMediaSectionsRequirement(requirement(audios = 0, videos = 0)) + + assertTrue(publisherPc.transceivers.isEmpty()) + } + + @Test + fun handleMediaSectionsRequirementWhenClosedAddsNothing() = runTest { + publisher.close() + + transport().handleMediaSectionsRequirement(requirement(audios = 2, videos = 3)) + + assertTrue(publisherPc.transceivers.isEmpty()) + } + + // endregion + + // region resume + + @Test + fun prepareForIceRestartLeavesPublisherAlone() { + transport().prepareForIceRestart() + + verify(publisher, never()).prepareForIceRestart() + } + + @Test + fun updateRTCConfigAppliesToPublisher() { + val config = RTCConfiguration(emptyList()) + + transport().updateRTCConfig(config) + + assertSame(config, publisherPc.rtcConfig) + } + + @Test + fun isConnectedRequiresPublisher() = runTest { + assertFalse(transport().isConnected(includePublisher = false)) + assertFalse(transport().isConnected(includePublisher = true)) + } + + @Test + fun isConnectedWhenPublisherConnected() = runTest { + publisherPc.moveToIceConnectionState(IceConnectionState.CONNECTED) + + assertTrue(transport().isConnected(includePublisher = false)) + assertTrue(transport().isConnected(includePublisher = true)) + } + + @Test + fun waitUntilConnectedWaitsForPublisher() = runTest { + val transport = transport() + val job = launch { transport.waitUntilConnected(includePublisher = true) } + + runCurrent() + assertTrue(job.isActive) + + publisherState.connectionState = PeerConnectionState.CONNECTED + runCurrent() + assertTrue(job.isCompleted) + } + + @Test + fun waitUntilConnectedWaitsForPublisherWhenNotIncluded() = runTest { + val transport = transport() + val job = launch { transport.waitUntilConnected(includePublisher = false) } + + runCurrent() + assertTrue(job.isActive) + + publisherState.connectionState = PeerConnectionState.CONNECTED + runCurrent() + assertTrue(job.isCompleted) + } + + @Test + fun syncStateDescriptionsComeFromPublisher() = runTest { + val offer = SessionDescription(SessionDescription.Type.OFFER, "publisher_local") + val answer = SessionDescription(SessionDescription.Type.ANSWER, "publisher_remote") + publisherPc.localDesc = offer + publisherPc.remoteDesc = answer + + val descriptions = transport().syncStateDescriptions() + + assertEquals(answer.toProtoSessionDescription(), descriptions.answer) + assertEquals(offer.toProtoSessionDescription(), descriptions.offer) + } + + @Test + fun syncStateDescriptionsWhenPublisherClosed() = runTest { + publisherPc.localDesc = SessionDescription(SessionDescription.Type.OFFER, "publisher_local") + publisherPc.remoteDesc = SessionDescription(SessionDescription.Type.ANSWER, "publisher_remote") + publisher.close() + + val descriptions = transport().syncStateDescriptions() + + assertNull(descriptions.answer) + assertNull(descriptions.offer) + } + + @Test + fun syncStateDescriptionsBeforeNegotiation() = runTest { + val descriptions = transport().syncStateDescriptions() + + assertNull(descriptions.answer) + assertNull(descriptions.offer) + } + + // endregion + + // region close + + @Test + fun closeClosesPublisher() = runTest { + transport().close() + + assertTrue(publisher.isClosed()) + } + + // endregion +} From 9d1e43f5f6e2610e48bdb3cd45c89e607eb6de71 Mon Sep 17 00:00:00 2001 From: Sen Chang Date: Tue, 3 Nov 2026 11:08:26 -0800 Subject: [PATCH 03/12] Fall back to the legacy signal path when the server has no /rtc/v1 Servers older than v1.9.10 answer the /rtc/v1 handshake with 404. When a join requested a single peer connection and fails that way, RTCEngine retries once on /rtc with dual peer connections and keeps the fallback options for later reconnects. Any other join failure is rethrown. SignalClient now reports a handshake failure only through the join continuation, taking the status from /rtc/v1/validate when it answered with an error, so the engine can retry without the app seeing a FailedToConnect for the probe. The engine reports the failure itself once it decides not to retry, which keeps one event per failed attempt as before. ConnectException gains a documented statusCode. --- .../java/io/livekit/android/room/RTCEngine.kt | 24 ++- .../main/java/io/livekit/android/room/Room.kt | 7 +- .../io/livekit/android/room/SignalClient.kt | 28 ++-- .../io/livekit/android/test/MockE2ETest.kt | 12 ++ .../android/room/RTCEngineMockE2ETest.kt | 26 ++++ .../livekit/android/room/SignalClientTest.kt | 7 +- ...SinglePeerConnectionFallbackMockE2ETest.kt | 138 ++++++++++++++++++ 7 files changed, 220 insertions(+), 22 deletions(-) create mode 100644 livekit-android-test/src/test/java/io/livekit/android/room/SinglePeerConnectionFallbackMockE2ETest.kt diff --git a/livekit-android-sdk/src/main/java/io/livekit/android/room/RTCEngine.kt b/livekit-android-sdk/src/main/java/io/livekit/android/room/RTCEngine.kt index cac668faf..2f20e73b8 100644 --- a/livekit-android-sdk/src/main/java/io/livekit/android/room/RTCEngine.kt +++ b/livekit-android-sdk/src/main/java/io/livekit/android/room/RTCEngine.kt @@ -298,7 +298,25 @@ internal constructor( if (connectionState == ConnectionState.DISCONNECTED) { connectionState = ConnectionState.CONNECTING } - val joinResponse = client.join(url, token, options, roomOptions) + var effectiveOptions = options + val joinResponse = try { + client.join(url, token, options, roomOptions) + } catch (e: RoomException.ConnectException) { + // A server that predates /rtc/v1 answers that handshake with 404. + if (!options.singlePeerConnection || e.statusCode != 404) { + onError(e) + throw e + } + LKLog.w { "server has no /rtc/v1 path, retrying on the legacy path with dual peer connections" } + effectiveOptions = options.copy(singlePeerConnection = false) + connectOptions = effectiveOptions + try { + client.join(url, token, effectiveOptions, roomOptions) + } catch (e: RoomException.ConnectException) { + onError(e) + throw e + } + } ensureActive() if (joinResponse.hasParticipant()) { @@ -318,9 +336,9 @@ internal constructor( isClosed = false listener?.onSignalConnected(false) - isSubscriberPrimary = !options.singlePeerConnection && joinResponse.subscriberPrimary + isSubscriberPrimary = !effectiveOptions.singlePeerConnection && joinResponse.subscriberPrimary - configure(joinResponse, options) + configure(joinResponse, effectiveOptions) // The publisher created above needs the attempt's start time before its first offer, in // case video is published before the primary transport connects. transport?.publisher?.setConnectStartedAt(startedAtMs) diff --git a/livekit-android-sdk/src/main/java/io/livekit/android/room/Room.kt b/livekit-android-sdk/src/main/java/io/livekit/android/room/Room.kt index b4642f829..95615d023 100644 --- a/livekit-android-sdk/src/main/java/io/livekit/android/room/Room.kt +++ b/livekit-android-sdk/src/main/java/io/livekit/android/room/Room.kt @@ -1731,7 +1731,12 @@ constructor( sealed class RoomException(message: String? = null, cause: Throwable? = null) : Exception(message, cause) { - class ConnectException(message: String? = null, cause: Throwable? = null) : + /** + * @param statusCode HTTP status of the rejected signal connection: the validate endpoint's + * status when it reported an error, otherwise the websocket handshake's. Null when the + * failure did not come with an HTTP response, such as a network error. + */ + class ConnectException(message: String? = null, cause: Throwable? = null, val statusCode: Int? = null) : RoomException(message, cause) } diff --git a/livekit-android-sdk/src/main/java/io/livekit/android/room/SignalClient.kt b/livekit-android-sdk/src/main/java/io/livekit/android/room/SignalClient.kt index 0ab830aa0..5129596f4 100644 --- a/livekit-android-sdk/src/main/java/io/livekit/android/room/SignalClient.kt +++ b/livekit-android-sdk/src/main/java/io/livekit/android/room/SignalClient.kt @@ -364,6 +364,9 @@ constructor( return } var reason: String? = null + // The validate endpoint explains a rejected handshake; its status wins over the + // handshake's when it answers with an error. + var statusCode: Int? = response?.code try { val lastToken = webSocket.request().header("Authorization") SignalUrlBuilder.toValidateUrl(lastUrl).getOrNull()?.let { @@ -380,6 +383,7 @@ constructor( val body = resp.body if (!resp.isSuccessful) { reason = body?.string() + statusCode = resp.code } body?.close() } @@ -397,22 +401,16 @@ constructor( if (reason != null) { LKLog.e(t) { "websocket failure: $reason" } - val error = if (joinCont != null) { - RoomException.ConnectException(reason, t) - } else { - Exception(reason) - } - listener?.onError(error) - joinCont?.resumeWithException(error) } else { LKLog.e(t) { "websocket failure: $response" } - val error = if (joinCont != null) { - RoomException.ConnectException(t.localizedMessage, t) - } else { - t - } - listener?.onError(error) - joinCont?.resumeWithException(error) + } + + if (joinCont != null) { + // The caller of join/reconnect receives the error through the continuation and decides + // whether to retry or report it, so the listener is not notified here. + joinCont.resumeWithException(RoomException.ConnectException(reason ?: t.localizedMessage, t, statusCode)) + } else { + listener?.onError(if (reason != null) Exception(reason) else t) } if (wasConnected || wasReconnectHandshake) { @@ -420,7 +418,7 @@ constructor( // Handle websocket closure here. // Also handle failure during a soft reconnect handshake (reconnect query): isConnected is // still false but the upper layer should be notified like a close. Initial join handshake - // failures do not call onClose so RTCEngine can surface them via onError / onFailToConnect. + // failures do not call onClose; the join caller surfaces them. handleWebSocketClose( reason = reason ?: response?.toString() ?: t.localizedMessage ?: "websocket failure", code = response?.code ?: CLOSE_REASON_WEBSOCKET_FAILURE, diff --git a/livekit-android-test/src/main/java/io/livekit/android/test/MockE2ETest.kt b/livekit-android-test/src/main/java/io/livekit/android/test/MockE2ETest.kt index 48fff3c17..d8a7234d4 100644 --- a/livekit-android-test/src/main/java/io/livekit/android/test/MockE2ETest.kt +++ b/livekit-android-test/src/main/java/io/livekit/android/test/MockE2ETest.kt @@ -137,6 +137,18 @@ abstract class MockE2ETest : BaseTest() { .build() } + /** + * The HTTP response of a websocket handshake the server rejected with [code]. + */ + fun createFailedHandshakeResponse(request: Request, code: Int): Response { + return Response.Builder() + .request(request) + .code(code) + .protocol(Protocol.HTTP_1_1) + .message("") + .build() + } + /** * Simulates receiving [message] from the server */ diff --git a/livekit-android-test/src/test/java/io/livekit/android/room/RTCEngineMockE2ETest.kt b/livekit-android-test/src/test/java/io/livekit/android/room/RTCEngineMockE2ETest.kt index b160a89d8..4a0bebb61 100644 --- a/livekit-android-test/src/test/java/io/livekit/android/room/RTCEngineMockE2ETest.kt +++ b/livekit-android-test/src/test/java/io/livekit/android/room/RTCEngineMockE2ETest.kt @@ -18,10 +18,12 @@ package io.livekit.android.room import com.google.protobuf.ByteString import io.livekit.android.ConnectOptions +import io.livekit.android.events.RoomEvent import io.livekit.android.room.track.TrackException import io.livekit.android.room.util.MediaConstraintKeys import io.livekit.android.room.util.findConstraint import io.livekit.android.test.MockE2ETest +import io.livekit.android.test.events.EventCollector import io.livekit.android.test.events.FlowCollector import io.livekit.android.test.mock.MockDataChannel import io.livekit.android.test.mock.MockPeerConnection @@ -54,6 +56,7 @@ import org.junit.Before import org.junit.Test import org.junit.runner.RunWith import org.robolectric.RobolectricTestRunner +import java.io.IOException @ExperimentalCoroutinesApi @RunWith(RobolectricTestRunner::class) @@ -170,6 +173,29 @@ class RTCEngineMockE2ETest : MockE2ETest() { ) } + @Test + fun joinFailureWithoutFallbackReportsFailedToConnectOnce() = runTest { + val collector = EventCollector(room.events, coroutineRule.scope) + val connectJob = async { + runCatching { room.connect(url = TestData.EXAMPLE_URL, token = "token") } + } + room::state.flow + .takeWhile { it != Room.State.CONNECTING } + .collect() + runCurrent() + + val firstRequest = wsFactory.request + wsFactory.listener.onFailure(wsFactory.ws, IOException("500"), createFailedHandshakeResponse(firstRequest, 500)) + advanceUntilIdle() + + val error = connectJob.await().exceptionOrNull() + assertTrue("expected ConnectException, got $error", error is RoomException.ConnectException) + assertEquals(500, (error as RoomException.ConnectException).statusCode) + assertTrue("no retry expected", wsFactory.request === firstRequest) + val events = collector.stopCollecting() + assertEquals(1, events.count { it is RoomEvent.FailedToConnect }) + } + @Test fun iceSubscriberConnect() = runTest { connect() diff --git a/livekit-android-test/src/test/java/io/livekit/android/room/SignalClientTest.kt b/livekit-android-test/src/test/java/io/livekit/android/room/SignalClientTest.kt index 905a51c81..e2ad2a4df 100644 --- a/livekit-android-test/src/test/java/io/livekit/android/room/SignalClientTest.kt +++ b/livekit-android-test/src/test/java/io/livekit/android/room/SignalClientTest.kt @@ -235,8 +235,9 @@ class SignalClientTest : BaseTest() { /** * Cold [join] handshake failure: [isConnected] is still false and this is not a reconnect attempt, - * so the listener must not get [SignalClient.Listener.onClose] (RTCEngine uses [onError] while - * CONNECTING). OkHttp does not call [WebSocketListener.onClosed] after [WebSocketListener.onFailure]. + * so the listener gets neither [SignalClient.Listener.onClose] nor [SignalClient.Listener.onError]; + * the error reaches the [join] caller, which decides whether to retry or report it. OkHttp does + * not call [WebSocketListener.onClosed] after [WebSocketListener.onFailure]. */ @Test fun onCloseNotInvokedWhenJoinHandshakeFailsBeforeJoinMessage() = runTest { @@ -252,7 +253,7 @@ class SignalClientTest : BaseTest() { } Mockito.verify(listener, never()).onClose(any(), any()) - Mockito.verify(listener, times(1)).onError(any()) + Mockito.verify(listener, never()).onError(any()) } /** diff --git a/livekit-android-test/src/test/java/io/livekit/android/room/SinglePeerConnectionFallbackMockE2ETest.kt b/livekit-android-test/src/test/java/io/livekit/android/room/SinglePeerConnectionFallbackMockE2ETest.kt new file mode 100644 index 000000000..c139b0fa1 --- /dev/null +++ b/livekit-android-test/src/test/java/io/livekit/android/room/SinglePeerConnectionFallbackMockE2ETest.kt @@ -0,0 +1,138 @@ +/* + * Copyright 2026 LiveKit, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package io.livekit.android.room + +import io.livekit.android.ConnectOptions +import io.livekit.android.events.RoomEvent +import io.livekit.android.test.MockE2ETest +import io.livekit.android.test.events.EventCollector +import io.livekit.android.test.mock.TestData +import io.livekit.android.util.flow +import kotlinx.coroutines.ExperimentalCoroutinesApi +import kotlinx.coroutines.flow.collect +import kotlinx.coroutines.flow.takeWhile +import kotlinx.coroutines.launch +import kotlinx.coroutines.test.TestScope +import kotlinx.coroutines.test.advanceTimeBy +import kotlinx.coroutines.test.advanceUntilIdle +import kotlinx.coroutines.test.runCurrent +import org.junit.Assert.assertEquals +import org.junit.Assert.assertNull +import org.junit.Assert.assertTrue +import org.junit.Test +import org.junit.runner.RunWith +import org.robolectric.RobolectricTestRunner +import java.io.IOException + +/** + * Connecting with [ConnectOptions.singlePeerConnection] to a server that has no `/rtc/v1` path: + * the join retries on the legacy path with dual peer connections, and later reconnects stay there. + */ +@ExperimentalCoroutinesApi +@RunWith(RobolectricTestRunner::class) +class SinglePeerConnectionFallbackMockE2ETest : MockE2ETest() { + + /** + * Connects with single peer connection requested, answers the `/rtc/v1` handshake with 404, + * and completes the legacy join that follows. + */ + private suspend fun TestScope.connectWithFallback() { + val connectJob = coroutineRule.scope.launch { + room.connect( + url = TestData.EXAMPLE_URL, + token = "token", + options = ConnectOptions(singlePeerConnection = true), + ) + } + room::state.flow + .takeWhile { it != Room.State.CONNECTING } + .collect() + runCurrent() + + val v1Request = wsFactory.request + assertEquals("/rtc/v1", v1Request.url.encodedPath) + wsFactory.listener.onFailure(wsFactory.ws, IOException("404"), createFailedHandshakeResponse(v1Request, 404)) + // runCurrent rather than advanceUntilIdle: advancing virtual time would expire the + // legacy handshake's deadline before the join response below is delivered. + runCurrent() + + val legacyRequest = wsFactory.request + assertTrue("expected a second websocket on the legacy path", legacyRequest !== v1Request) + assertEquals("/rtc", legacyRequest.url.encodedPath) + wsFactory.listener.onOpen(wsFactory.ws, createOpenResponse(legacyRequest)) + simulateMessageFromServer(TestData.JOIN) + connectJob.join() + connectPeerConnection() + } + + @Test + fun fallsBackToLegacySignalPathWhenV1NotFound() = runTest { + val collector = EventCollector(room.events, coroutineRule.scope) + + connectWithFallback() + + val events = collector.stopCollecting() + assertTrue("fallback must not report a failure", events.none { it is RoomEvent.FailedToConnect }) + assertEquals(Room.State.CONNECTED, room.state) + } + + @Test + fun fullReconnectAfterFallbackStaysOnLegacyPath() = runTest { + room.setReconnectionType(ReconnectType.FORCE_FULL_RECONNECT) + connectWithFallback() + val fallbackRequest = wsFactory.request + + disconnectPeerConnection() + // Wait so that the reconnect job properly starts first. + testScheduler.advanceTimeBy(1000) + + val reconnectRequest = wsFactory.request + assertTrue("expected a new websocket for the reconnect", reconnectRequest !== fallbackRequest) + assertEquals("/rtc", reconnectRequest.url.encodedPath) + assertNull(reconnectRequest.url.queryParameter(SignalClient.CONNECT_QUERY_RECONNECT)) + + wsFactory.listener.onOpen(wsFactory.ws, createOpenResponse(reconnectRequest)) + simulateMessageFromServer(TestData.JOIN) + connectPeerConnection() + testScheduler.advanceUntilIdle() + + assertEquals(Room.State.CONNECTED, room.state) + } + + @Test + fun softReconnectAfterFallbackStaysOnLegacyPath() = runTest { + room.setReconnectionType(ReconnectType.FORCE_SOFT_RECONNECT) + connectWithFallback() + val fallbackRequest = wsFactory.request + + disconnectPeerConnection() + // Wait so that the reconnect job properly starts first. + testScheduler.advanceTimeBy(1000) + + val reconnectRequest = wsFactory.request + assertTrue("expected a new websocket for the reconnect", reconnectRequest !== fallbackRequest) + assertEquals("/rtc", reconnectRequest.url.encodedPath) + assertEquals("1", reconnectRequest.url.queryParameter(SignalClient.CONNECT_QUERY_RECONNECT)) + + wsFactory.listener.onOpen(wsFactory.ws, createOpenResponse(reconnectRequest)) + simulateMessageFromServer(TestData.RECONNECT) + connectPeerConnection() + testScheduler.advanceUntilIdle() + + assertEquals(Room.State.CONNECTED, room.state) + } +} From 4adedf6c3258805461a104961bd914af92f69048 Mon Sep 17 00:00:00 2001 From: Sen Chang Date: Mon, 9 Nov 2026 13:13:06 -0800 Subject: [PATCH 04/12] Add changeset for single peer connection mode --- .changeset/single-peer-connection.md | 5 +++++ 1 file changed, 5 insertions(+) create mode 100644 .changeset/single-peer-connection.md diff --git a/.changeset/single-peer-connection.md b/.changeset/single-peer-connection.md new file mode 100644 index 000000000..0f030623a --- /dev/null +++ b/.changeset/single-peer-connection.md @@ -0,0 +1,5 @@ +--- +"client-sdk-android": minor +--- + +Add `ConnectOptions.singlePeerConnection`, which joins through the `/rtc/v1` signal path and publishes and receives on one peer connection instead of a publisher and a subscriber. The client makes every offer; the server's media sections requirement adds receive-only transceivers, and the answer's mid-to-track mapping resolves received tracks. A server without `/rtc/v1` answers that handshake with 404, in which case the join retries on the legacy path with dual peer connections and later reconnects stay there. The option is off by default. From 06e2d8f983c655647d4d1fa00205509680bd4856 Mon Sep 17 00:00:00 2001 From: Sen Chang Date: Mon, 9 Nov 2026 13:37:16 -0800 Subject: [PATCH 05/12] Return plain URLs from SignalUrlBuilder Both builder functions wrapped their result in a Result whose only failure was OkHttp rejecting the URL. SignalClient already hands the same string to OkHttp's request builder, which throws on that input, so the failure was never recoverable and the join-request call site's fallback to the legacy URL could never run. The functions now return the URL and let the parse exception propagate; the validate call site is inside the try that already covers the validate request. --- .../io/livekit/android/room/SignalClient.kt | 3 +- .../android/room/util/SignalUrlBuilder.kt | 29 +++++++------- .../android/room/util/SignalUrlBuilderTest.kt | 38 +++++++++---------- 3 files changed, 32 insertions(+), 38 deletions(-) diff --git a/livekit-android-sdk/src/main/java/io/livekit/android/room/SignalClient.kt b/livekit-android-sdk/src/main/java/io/livekit/android/room/SignalClient.kt index 5129596f4..57792d864 100644 --- a/livekit-android-sdk/src/main/java/io/livekit/android/room/SignalClient.kt +++ b/livekit-android-sdk/src/main/java/io/livekit/android/room/SignalClient.kt @@ -197,7 +197,6 @@ constructor( if (options.singlePeerConnection) { wsUrlString = SignalUrlBuilder.buildJoinRequestUrl(wsUrlString, options, roomOptions, networkInfo.getNetworkType()) - .getOrElse { wsUrlString } } LKLog.i { "connecting to $wsUrlString" } @@ -369,7 +368,7 @@ constructor( var statusCode: Int? = response?.code try { val lastToken = webSocket.request().header("Authorization") - SignalUrlBuilder.toValidateUrl(lastUrl).getOrNull()?.let { + lastUrl?.let { SignalUrlBuilder.toValidateUrl(it) }?.let { val request = Request.Builder() .url(it) .apply { diff --git a/livekit-android-sdk/src/main/java/io/livekit/android/room/util/SignalUrlBuilder.kt b/livekit-android-sdk/src/main/java/io/livekit/android/room/util/SignalUrlBuilder.kt index 135180202..74d65753c 100644 --- a/livekit-android-sdk/src/main/java/io/livekit/android/room/util/SignalUrlBuilder.kt +++ b/livekit-android-sdk/src/main/java/io/livekit/android/room/util/SignalUrlBuilder.kt @@ -55,7 +55,8 @@ internal object SignalUrlBuilder { * @param connectOptions also decides whether this is a reconnect, and with which participant. * @param publisherOffer bundled into the join request so the server can answer it * in the same exchange. - * @return the websocket URL, or a failure if [url] cannot be parsed. + * @return the websocket URL. + * @throws IllegalArgumentException if [url] cannot be parsed. */ fun buildJoinRequestUrl( url: String, @@ -63,7 +64,7 @@ internal object SignalUrlBuilder { roomOptions: RoomOptions, networkType: NetworkType? = null, publisherOffer: SessionDescription? = null, - ): Result = runCatching { + ): String { val baseUrl = url.toHttpUrl().parseHttpUrl() // An empty last segment means the path ends in '/', which marks it as a directory. @@ -89,7 +90,7 @@ internal object SignalUrlBuilder { publisherOffer = publisherOffer, ) - return@runCatching "${rtcUrl.toString().toWebsocketUrl()}?$QUERY_JOIN_REQUEST=$joinRequest" + return "${rtcUrl.toString().toWebsocketUrl()}?$QUERY_JOIN_REQUEST=$joinRequest" } /** @@ -97,20 +98,16 @@ internal object SignalUrlBuilder { * - `wss://host/rtc?...` → `https://host/rtc/validate?...` * - `wss://host/rtc/v1?...` → `https://host/rtc/v1/validate?...` * - * @return the validation URL, or a failure if [wsUrl] is null or cannot be parsed. + * @return the validation URL. + * @throws IllegalArgumentException if [wsUrl] cannot be parsed. */ - fun toValidateUrl(wsUrl: String?): Result { - if (wsUrl == null) { - return Result.failure(IllegalArgumentException("No signal URL to validate")) - } - return runCatching { - // addPathSegment replaces an empty last segment, so a trailing '/' doesn't double up. - wsUrl.toHttpUrl().parseHttpUrl() - .newBuilder() - .addPathSegment("validate") - .build() - .toString() - } + fun toValidateUrl(wsUrl: String): String { + // addPathSegment replaces an empty last segment, so a trailing '/' doesn't double up. + return wsUrl.toHttpUrl().parseHttpUrl() + .newBuilder() + .addPathSegment("validate") + .build() + .toString() } /** diff --git a/livekit-android-test/src/test/java/io/livekit/android/room/util/SignalUrlBuilderTest.kt b/livekit-android-test/src/test/java/io/livekit/android/room/util/SignalUrlBuilderTest.kt index aa044e869..f01d764d9 100644 --- a/livekit-android-test/src/test/java/io/livekit/android/room/util/SignalUrlBuilderTest.kt +++ b/livekit-android-test/src/test/java/io/livekit/android/room/util/SignalUrlBuilderTest.kt @@ -26,6 +26,7 @@ import okhttp3.HttpUrl import okhttp3.HttpUrl.Companion.toHttpUrl import org.junit.Assert.assertEquals import org.junit.Assert.assertFalse +import org.junit.Assert.assertThrows import org.junit.Assert.assertTrue import org.junit.Test import java.util.Base64 @@ -45,7 +46,7 @@ class SignalUrlBuilderTest { roomOptions = roomOptions, networkType = networkType, publisherOffer = publisherOffer, - ).getOrThrow() + ) /** Options as `SignalClient.reconnect` sets them. */ private fun reconnectOptions(participantSid: String?) = ConnectOptions().apply { @@ -281,14 +282,14 @@ class SignalUrlBuilderTest { } @Test - fun invalidUrlFails() { - val result = SignalUrlBuilder.buildJoinRequestUrl( - url = "not a url", - connectOptions = ConnectOptions(), - roomOptions = RoomOptions(), - ) - - assertTrue(result.isFailure) + fun invalidUrlThrows() { + assertThrows(IllegalArgumentException::class.java) { + SignalUrlBuilder.buildJoinRequestUrl( + url = "not a url", + connectOptions = ConnectOptions(), + roomOptions = RoomOptions(), + ) + } } // endregion @@ -297,7 +298,7 @@ class SignalUrlBuilderTest { @Test fun validateUrlForLegacyPath() { - val validate = SignalUrlBuilder.toValidateUrl("wss://example.livekit.cloud/rtc?protocol=13&sdk=android").getOrThrow() + val validate = SignalUrlBuilder.toValidateUrl("wss://example.livekit.cloud/rtc?protocol=13&sdk=android") assertEquals("https://example.livekit.cloud/rtc/validate?protocol=13&sdk=android", validate) } @@ -305,7 +306,7 @@ class SignalUrlBuilderTest { @Test fun validateUrlForV1Path() { val url = buildUrl() - val validate = SignalUrlBuilder.toValidateUrl(url).getOrThrow().toHttpUrl() + val validate = SignalUrlBuilder.toValidateUrl(url).toHttpUrl() assertEquals("https", validate.scheme) assertEquals("/rtc/v1/validate", validate.encodedPath) @@ -314,26 +315,23 @@ class SignalUrlBuilderTest { @Test fun validateUrlWsBecomesHttp() { - val validate = SignalUrlBuilder.toValidateUrl("ws://localhost:7880/rtc/v1?join_request=abc=").getOrThrow() + val validate = SignalUrlBuilder.toValidateUrl("ws://localhost:7880/rtc/v1?join_request=abc=") assertEquals("http://localhost:7880/rtc/v1/validate?join_request=abc=", validate) } @Test fun validateUrlHandlesTrailingSlash() { - val validate = SignalUrlBuilder.toValidateUrl("wss://example.livekit.cloud/rtc/").getOrThrow() + val validate = SignalUrlBuilder.toValidateUrl("wss://example.livekit.cloud/rtc/") assertEquals("https://example.livekit.cloud/rtc/validate", validate) } @Test - fun validateUrlInvalidUrlFails() { - assertTrue(SignalUrlBuilder.toValidateUrl("not a url").isFailure) - } - - @Test - fun validateUrlNullUrlFails() { - assertTrue(SignalUrlBuilder.toValidateUrl(null).isFailure) + fun validateUrlInvalidUrlThrows() { + assertThrows(IllegalArgumentException::class.java) { + SignalUrlBuilder.toValidateUrl("not a url") + } } // endregion From b1b013c192538bef3c7e059dab5e789cb5b63969 Mon Sep 17 00:00:00 2001 From: Sen Chang Date: Mon, 9 Nov 2026 13:45:53 -0800 Subject: [PATCH 06/12] Drop the data channel hook from DuplexTransportObserver Nothing set its listener: RTCEngine only forwards server-opened data channels in subscriber-primary mode, which single peer connection mode forces off, and the client creates its own channels on the one peer connection. --- .../android/room/DuplexTransportObserver.kt | 10 ------ .../room/DuplexTransportObserverTest.kt | 34 ------------------- 2 files changed, 44 deletions(-) diff --git a/livekit-android-sdk/src/main/java/io/livekit/android/room/DuplexTransportObserver.kt b/livekit-android-sdk/src/main/java/io/livekit/android/room/DuplexTransportObserver.kt index 7e1ee2192..60ce457c8 100644 --- a/livekit-android-sdk/src/main/java/io/livekit/android/room/DuplexTransportObserver.kt +++ b/livekit-android-sdk/src/main/java/io/livekit/android/room/DuplexTransportObserver.kt @@ -19,7 +19,6 @@ package io.livekit.android.room import io.livekit.android.util.LKLog import io.livekit.android.webrtc.peerconnection.RTCThreadToken import io.livekit.android.webrtc.peerconnection.executeOnRTCThread -import livekit.org.webrtc.DataChannel import livekit.org.webrtc.MediaStream import livekit.org.webrtc.MediaStreamTrack import livekit.org.webrtc.RtpReceiver @@ -27,7 +26,6 @@ import livekit.org.webrtc.RtpTransceiver internal class DuplexTransportObserver(engine: RTCEngine, client: SignalClient, rtcThreadToken: RTCThreadToken) : PublisherTransportObserver(engine, client, rtcThreadToken) { - var dataChannelListener: ((DataChannel) -> Unit)? = null override fun onTrack(transceiver: RtpTransceiver?) { when (transceiver?.mediaType) { @@ -37,14 +35,6 @@ internal class DuplexTransportObserver(engine: RTCEngine, client: SignalClient, } } - override fun onDataChannel(dataChannel: DataChannel?) { - executeOnRTCThread(rtcThreadToken) { - dataChannel?.let { - dataChannelListener?.invoke(it) - } - } - } - override fun onAddTrack(receiver: RtpReceiver?, streams: Array?) { executeOnRTCThread(rtcThreadToken) { if (receiver != null && streams != null) { diff --git a/livekit-android-test/src/test/java/io/livekit/android/room/DuplexTransportObserverTest.kt b/livekit-android-test/src/test/java/io/livekit/android/room/DuplexTransportObserverTest.kt index 1f3ef7bb3..2b554d2be 100644 --- a/livekit-android-test/src/test/java/io/livekit/android/room/DuplexTransportObserverTest.kt +++ b/livekit-android-test/src/test/java/io/livekit/android/room/DuplexTransportObserverTest.kt @@ -20,7 +20,6 @@ import io.livekit.android.test.mock.MockRTCThreadToken import io.livekit.android.webrtc.peerconnection.RTCThreadToken import io.livekit.android.webrtc.peerconnection.executeBlockingOnRTCThread import livekit.LivekitRtc.SignalTarget -import livekit.org.webrtc.DataChannel import livekit.org.webrtc.IceCandidate import livekit.org.webrtc.MediaStream import livekit.org.webrtc.MediaStreamTrack @@ -127,39 +126,6 @@ class DuplexTransportObserverTest { // endregion - // region onDataChannel - - @Test - fun dataChannelIsForwardedToListener() { - val channel = mock() - val received = mutableListOf() - observer.dataChannelListener = { received.add(it) } - - observer.onDataChannel(channel) - flushRTCThread() - - assertEquals(listOf(channel), received) - } - - @Test - fun nullDataChannelIsIgnored() { - val received = mutableListOf() - observer.dataChannelListener = { received.add(it) } - - observer.onDataChannel(null) - flushRTCThread() - - assertEquals(emptyList(), received) - } - - @Test - fun dataChannelWithoutListenerIsDropped() { - observer.onDataChannel(mock()) - flushRTCThread() - } - - // endregion - // region onTrack @Test From b46205a7124a7659661a71cab09eef89d7881f6f Mon Sep 17 00:00:00 2001 From: Sen Chang Date: Mon, 9 Nov 2026 13:45:53 -0800 Subject: [PATCH 07/12] Show how to connect with a single peer connection --- .../src/main/java/io/livekit/android/ConnectOptions.kt | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/livekit-android-sdk/src/main/java/io/livekit/android/ConnectOptions.kt b/livekit-android-sdk/src/main/java/io/livekit/android/ConnectOptions.kt index f6389ae0a..1821bae09 100644 --- a/livekit-android-sdk/src/main/java/io/livekit/android/ConnectOptions.kt +++ b/livekit-android-sdk/src/main/java/io/livekit/android/ConnectOptions.kt @@ -65,6 +65,10 @@ data class ConnectOptions( /** * Use a single peer connection instead of one subscriber and one publisher. + * + * ``` + * room.connect(url, token, ConnectOptions(singlePeerConnection = true)) + * ``` */ val singlePeerConnection: Boolean = false, ) { From eec86396fadd3785ec0df3b4e55ebd94ffff09b6 Mon Sep 17 00:00:00 2001 From: Sen Chang Date: Mon, 9 Nov 2026 13:45:53 -0800 Subject: [PATCH 08/12] Test a single peer connection join end to end Connects with ConnectOptions.singlePeerConnection against a mock server that serves /rtc/v1: the join goes out on that path with a join_request, the engine builds a SinglePeerConnectionTransport whose publisher and subscriber are the same peer connection, the publisher offers on join without offering to receive, a MediaSectionsRequirement adds the receiving sections, the answer's mid_to_track_id resolves a received track to its publication, and a server offer is ignored. --- .../room/SinglePeerConnectionMockE2ETest.kt | 212 ++++++++++++++++++ 1 file changed, 212 insertions(+) create mode 100644 livekit-android-test/src/test/java/io/livekit/android/room/SinglePeerConnectionMockE2ETest.kt diff --git a/livekit-android-test/src/test/java/io/livekit/android/room/SinglePeerConnectionMockE2ETest.kt b/livekit-android-test/src/test/java/io/livekit/android/room/SinglePeerConnectionMockE2ETest.kt new file mode 100644 index 000000000..589a04a2e --- /dev/null +++ b/livekit-android-test/src/test/java/io/livekit/android/room/SinglePeerConnectionMockE2ETest.kt @@ -0,0 +1,212 @@ +/* + * Copyright 2026 LiveKit, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package io.livekit.android.room + +import io.livekit.android.ConnectOptions +import io.livekit.android.events.RoomEvent +import io.livekit.android.room.participant.RemoteParticipant +import io.livekit.android.room.track.Track +import io.livekit.android.room.util.SignalUrlBuilder +import io.livekit.android.test.MockE2ETest +import io.livekit.android.test.events.EventCollector +import io.livekit.android.test.mock.MockAudioStreamTrack +import io.livekit.android.test.mock.MockMediaStream +import io.livekit.android.test.mock.TestData +import io.livekit.android.test.mock.createMediaStreamId +import io.livekit.android.test.util.toPBByteString +import kotlinx.coroutines.ExperimentalCoroutinesApi +import kotlinx.coroutines.launch +import kotlinx.coroutines.test.TestScope +import kotlinx.coroutines.test.advanceUntilIdle +import kotlinx.coroutines.test.runCurrent +import livekit.LivekitRtc +import livekit.org.webrtc.MediaStreamTrack +import livekit.org.webrtc.PeerConnection +import livekit.org.webrtc.RtpTransceiver +import org.junit.Assert.assertEquals +import org.junit.Assert.assertNotNull +import org.junit.Assert.assertSame +import org.junit.Assert.assertTrue +import org.junit.Test +import org.junit.runner.RunWith +import org.mockito.kotlin.whenever +import org.robolectric.RobolectricTestRunner + +/** + * Connecting with [ConnectOptions.singlePeerConnection] to a server that serves `/rtc/v1`: + * one peer connection carries the join-time offer, the server's media sections, and the + * received tracks. + */ +@ExperimentalCoroutinesApi +@RunWith(RobolectricTestRunner::class) +class SinglePeerConnectionMockE2ETest : MockE2ETest() { + + private fun publisherPeerConnection() = getPublisherPeerConnection() + + /** + * @return the most recent offer the client sent to the server. + */ + private fun lastSentOffer(): LivekitRtc.SessionDescription { + return wsFactory.ws.sentRequests + .map { LivekitRtc.SignalRequest.newBuilder().mergeFrom(it.toPBByteString()).build() } + .last { it.hasOffer() } + .offer + } + + /** + * Answers the client's most recent offer, with [midToTrackId] as the answer's mapping of + * receiving media sections to track IDs. + */ + private fun TestScope.answerLastOffer(midToTrackId: Map = emptyMap()) { + val offer = lastSentOffer() + val answer = with(LivekitRtc.SignalResponse.newBuilder()) { + setAnswer( + with(LivekitRtc.SessionDescription.newBuilder()) { + type = "answer" + sdp = "remote_answer" + id = offer.id + putAllMidToTrackId(midToTrackId) + build() + }, + ) + build() + } + simulateMessageFromServer(answer) + advanceUntilIdle() + } + + /** + * Joins through `/rtc/v1`, answers the offer the join triggers, and connects the peer + * connection. + */ + private suspend fun TestScope.connectSinglePeerConnection() { + val connectJob = coroutineRule.scope.launch { + room.connect( + url = TestData.EXAMPLE_URL, + token = "token", + options = ConnectOptions(singlePeerConnection = true), + ) + } + prepareSignal() + connectJob.join() + advanceUntilIdle() + + answerLastOffer() + publisherPeerConnection().moveToIceConnectionState(PeerConnection.IceConnectionState.CONNECTED) + runCurrent() + } + + /** + * Has the server require [audios] receiving audio sections and [videos] video ones, and + * answers the renegotiation that follows with [midToTrackId]. + */ + private fun TestScope.requireMediaSections(audios: Int, videos: Int, midToTrackId: Map = emptyMap()) { + val requirement = with(LivekitRtc.SignalResponse.newBuilder()) { + setMediaSectionsRequirement( + with(LivekitRtc.MediaSectionsRequirement.newBuilder()) { + numAudios = audios + numVideos = videos + build() + }, + ) + build() + } + simulateMessageFromServer(requirement) + advanceUntilIdle() + // The mock peer connection does not ask for renegotiation on its own. + publisherPeerConnection().observer?.onRenegotiationNeeded() + advanceUntilIdle() + answerLastOffer(midToTrackId) + } + + @Test + fun joinsThroughV1WithOnePeerConnection() = runTest { + val collector = EventCollector(room.events, coroutineRule.scope) + + connectSinglePeerConnection() + + val request = wsFactory.request + assertEquals("/rtc/v1", request.url.encodedPath) + assertNotNull(request.url.queryParameter(SignalUrlBuilder.QUERY_JOIN_REQUEST)) + assertTrue(component.rtcEngine().transport is SinglePeerConnectionTransport) + assertSame(getPublisherPeerConnection(), getSubscriberPeerConnection()) + assertEquals(Room.State.CONNECTED, room.state) + val events = collector.stopCollecting() + assertTrue(events.none { it is RoomEvent.FailedToConnect }) + } + + @Test + fun publisherOffersOnJoinWithoutOfferingToReceive() = runTest { + connectSinglePeerConnection() + + val constraints = publisherPeerConnection().lastOfferConstraints + assertNotNull(constraints) + assertTrue(constraints!!.mandatory.isEmpty()) + } + + @Test + fun mediaSectionsRequirementAddsReceivingSections() = runTest { + connectSinglePeerConnection() + + requireMediaSections(audios = 1, videos = 2) + + val transceivers = publisherPeerConnection().transceivers + assertEquals(3, transceivers.size) + assertTrue(transceivers.all { it.direction == RtpTransceiver.RtpTransceiverDirection.RECV_ONLY }) + assertEquals(1, transceivers.count { it.mediaType == MediaStreamTrack.MediaType.MEDIA_TYPE_AUDIO }) + assertEquals(2, transceivers.count { it.mediaType == MediaStreamTrack.MediaType.MEDIA_TYPE_VIDEO }) + } + + @Test + fun remoteTrackResolvesThroughAnswerMapping() = runTest { + connectSinglePeerConnection() + simulateMessageFromServer(TestData.PARTICIPANT_JOIN) + val remoteParticipant = room.getParticipantBySid(TestData.REMOTE_PARTICIPANT.sid) as RemoteParticipant + + requireMediaSections(audios = 1, videos = 0) + val transceiver = publisherPeerConnection().transceivers.single() + whenever(transceiver.mid).thenReturn("0") + answerLastOffer(midToTrackId = mapOf("0" to TestData.REMOTE_AUDIO_TRACK.sid)) + val receiver = transceiver.receiver + whenever(receiver.track()).thenReturn(MockAudioStreamTrack()) + + // The stream ID carries no track SID, so only the answer's mapping can resolve the track. + publisherPeerConnection().observer?.onAddTrack( + receiver, + arrayOf(MockMediaStream(id = createMediaStreamId(TestData.REMOTE_PARTICIPANT.sid, "stream"))), + ) + advanceUntilIdle() + + val micPub = remoteParticipant.getTrackPublication(Track.Source.MICROPHONE) + assertNotNull(micPub?.track) + } + + @Test + fun serverOfferIsIgnored() = runTest { + connectSinglePeerConnection() + val sentBefore = wsFactory.ws.sentRequests.size + + simulateMessageFromServer(TestData.OFFER) + advanceUntilIdle() + + val answers = wsFactory.ws.sentRequests.drop(sentBefore) + .map { LivekitRtc.SignalRequest.newBuilder().mergeFrom(it.toPBByteString()).build() } + .count { it.hasAnswer() } + assertEquals(0, answers) + assertEquals(Room.State.CONNECTED, room.state) + } +} From 63fac99dc9fe885c476444fff58113ba73c66538 Mon Sep 17 00:00:00 2001 From: Sen Chang Date: Mon, 9 Nov 2026 14:38:00 -0800 Subject: [PATCH 09/12] Redact the join request from the connection log The /rtc/v1 URL carries the whole encoded join request, including the client metadata, so the connection log now shows the path with the join_request value replaced. The legacy URL is logged as before. --- .../src/main/java/io/livekit/android/room/SignalClient.kt | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/livekit-android-sdk/src/main/java/io/livekit/android/room/SignalClient.kt b/livekit-android-sdk/src/main/java/io/livekit/android/room/SignalClient.kt index 57792d864..875b52051 100644 --- a/livekit-android-sdk/src/main/java/io/livekit/android/room/SignalClient.kt +++ b/livekit-android-sdk/src/main/java/io/livekit/android/room/SignalClient.kt @@ -197,10 +197,12 @@ constructor( if (options.singlePeerConnection) { wsUrlString = SignalUrlBuilder.buildJoinRequestUrl(wsUrlString, options, roomOptions, networkInfo.getNetworkType()) + // The join request carries client metadata, so only the path is logged. + LKLog.i { "connecting to ${wsUrlString.substringBefore('?')}?${SignalUrlBuilder.QUERY_JOIN_REQUEST}=" } + } else { + LKLog.i { "connecting to $wsUrlString" } } - LKLog.i { "connecting to $wsUrlString" } - coroutineScope = CloseableCoroutineScope(SupervisorJob() + ioDispatcher) lastUrl = wsUrlString lastOptions = options From f8bb5978a24ca9204b7e7a656dc40980fb44372c Mon Sep 17 00:00:00 2001 From: Sen Chang Date: Thu, 12 Nov 2026 13:03:34 -0800 Subject: [PATCH 10/12] Attach tracks the server binds without a track callback libwebrtc reports a received track only when its media section starts receiving. When the server binds another publication to a section that is already receiving, the answer's mid_to_track_id changes and nothing else happens, so that subscription stayed pending. After each accepted answer, SinglePeerConnectionTransport now walks the transceivers and offers every receiver whose section is mapped to a track ID it is not attached as. Room finds the publication's owner by track SID, since a receiver found this way has no stream to name its participant, and attaches through the same helper the track callback uses. A receiver whose publication is not known yet is offered again after the next answer. A stale answer is now rejected before its mapping is recorded. The mapping is still recorded before the answer is applied, because track callbacks fire while it is being applied and read it. --- .../android/room/PeerConnectionTransport.kt | 13 ++- .../java/io/livekit/android/room/RTCEngine.kt | 12 +- .../main/java/io/livekit/android/room/Room.kt | 25 +++- .../room/SinglePeerConnectionTransport.kt | 44 ++++++- .../room/SinglePeerConnectionMockE2ETest.kt | 50 +++++--- .../room/SinglePeerConnectionTransportTest.kt | 108 ++++++++++++++++++ 6 files changed, 227 insertions(+), 25 deletions(-) diff --git a/livekit-android-sdk/src/main/java/io/livekit/android/room/PeerConnectionTransport.kt b/livekit-android-sdk/src/main/java/io/livekit/android/room/PeerConnectionTransport.kt index 9a4c9c6f9..e7ff05ed9 100644 --- a/livekit-android-sdk/src/main/java/io/livekit/android/room/PeerConnectionTransport.kt +++ b/livekit-android-sdk/src/main/java/io/livekit/android/room/PeerConnectionTransport.kt @@ -135,11 +135,18 @@ constructor( } } + /** + * @return whether an answer for [offerId] answers an offer older than the latest one sent. + */ + fun isStaleAnswer(offerId: Int): Boolean { + val currentOfferId = latestOfferId.get() + return currentOfferId > 0 && offerId > 0 && currentOfferId > offerId + } + suspend fun setRemoteDescription(sd: SessionDescription, offerId: Int): Either { val result = launchRTCIfNotClosed { - val currentOfferId = latestOfferId.get() - if (sd.type == SessionDescription.Type.ANSWER && currentOfferId > 0 && offerId > 0 && currentOfferId > offerId) { - return@launchRTCIfNotClosed Either.Right("Old offer, ignoring. Expected: $currentOfferId, actual: $offerId") + if (sd.type == SessionDescription.Type.ANSWER && isStaleAnswer(offerId)) { + return@launchRTCIfNotClosed Either.Right("Old offer, ignoring. Expected: ${latestOfferId.get()}, actual: $offerId") } val result = peerConnection.setRemoteDescription(sd) if (result is Either.Left) { diff --git a/livekit-android-sdk/src/main/java/io/livekit/android/room/RTCEngine.kt b/livekit-android-sdk/src/main/java/io/livekit/android/room/RTCEngine.kt index 2f20e73b8..4720ef735 100644 --- a/livekit-android-sdk/src/main/java/io/livekit/android/room/RTCEngine.kt +++ b/livekit-android-sdk/src/main/java/io/livekit/android/room/RTCEngine.kt @@ -422,7 +422,9 @@ internal constructor( transport = SinglePeerConnectionTransport( publisher, publisherObserver, - ) + ) { receiver, track, trackSid -> + listener?.onTrackBound(receiver, track, trackSid) == true + } } else { val subscriber = runCatching { pctFactory.create(rtcConfig, subscriberObserver, null) } .onFailure { publisher.close() } @@ -1182,6 +1184,14 @@ internal constructor( fun onJoinResponse(response: JoinResponse) fun reattachRemoteDataTracks() {} fun onAddTrack(receiver: RtpReceiver, track: MediaStreamTrack, streams: Array) + + /** + * The server bound [receiver] to the publication [trackSid] without the peer connection + * reporting a new track. + * + * @return whether [track] is attached to that publication. + */ + fun onTrackBound(receiver: RtpReceiver, track: MediaStreamTrack, trackSid: String): Boolean = false fun onUpdateParticipants(updates: List) fun onActiveSpeakersUpdate(speakers: List) fun onRemoteMuteChanged(trackSid: String, muted: Boolean) diff --git a/livekit-android-sdk/src/main/java/io/livekit/android/room/Room.kt b/livekit-android-sdk/src/main/java/io/livekit/android/room/Room.kt index 95615d023..560942a19 100644 --- a/livekit-android-sdk/src/main/java/io/livekit/android/room/Room.kt +++ b/livekit-android-sdk/src/main/java/io/livekit/android/room/Room.kt @@ -1305,12 +1305,31 @@ constructor( return } - val statsGetter = engine.createStatsGetter(receiver) + attachTrack(participant, receiver, track, trackSid!!) + } + + /** + * @suppress + */ + override fun onTrackBound(receiver: RtpReceiver, track: MediaStreamTrack, trackSid: String): Boolean { + val participant = remoteParticipants.values.firstOrNull { it.getTrackPublication(trackSid) != null } + if (participant == null) { + LKLog.d { "no publication yet for bound track $trackSid" } + return false + } + attachTrack(participant, receiver, track, trackSid) + return true + } + + private fun attachTrack(participant: RemoteParticipant, receiver: RtpReceiver, track: MediaStreamTrack, trackSid: String) { + if (participant.getTrackPublication(trackSid)?.track?.rtcTrack === track) { + return + } participant.addSubscribedMediaTrack( track, - trackSid!!, + trackSid, autoManageVideo = adaptiveStream, - statsGetter = statsGetter, + statsGetter = engine.createStatsGetter(receiver), receiver = receiver, ) } diff --git a/livekit-android-sdk/src/main/java/io/livekit/android/room/SinglePeerConnectionTransport.kt b/livekit-android-sdk/src/main/java/io/livekit/android/room/SinglePeerConnectionTransport.kt index 5426a2047..71dda6f64 100644 --- a/livekit-android-sdk/src/main/java/io/livekit/android/room/SinglePeerConnectionTransport.kt +++ b/livekit-android-sdk/src/main/java/io/livekit/android/room/SinglePeerConnectionTransport.kt @@ -20,6 +20,7 @@ import io.livekit.android.room.util.PeerConnectionStateObservable import io.livekit.android.room.util.waitUntilConnected import io.livekit.android.util.Either import io.livekit.android.util.LKLog +import io.livekit.android.util.isLeft import io.livekit.android.webrtc.toProtoSessionDescription import kotlinx.coroutines.runBlocking import livekit.LivekitRtc @@ -38,13 +39,20 @@ import java.util.concurrent.ConcurrentHashMap * [handleMediaSectionsRequirement]. * * @param publisherState connection state of [publisher], as reported by its observer. + * @param onTrackBound called after an answer for each receiver the server has bound to a track + * ID that has not been attached yet. Returns whether the track was attached; a receiver that + * was not is offered again after the next answer. */ @Suppress("TooManyFunctions") internal class SinglePeerConnectionTransport( override val publisher: PeerConnectionTransport, private val publisherState: PeerConnectionStateObservable, + private val onTrackBound: (receiver: RtpReceiver, track: MediaStreamTrack, trackId: String) -> Boolean, ) : Transport { private val midToTrackId: MutableMap = ConcurrentHashMap() + + // Receiver ID to the track ID it was last attached as. + private val attachedTrackIds: MutableMap = ConcurrentHashMap() override val subscriber: PeerConnectionTransport get() = publisher override val publisherConnectsOnDemand: Boolean @@ -77,11 +85,39 @@ internal class SinglePeerConnectionTransport( offerId: Int, midToTrackId: Map, ): Either { - for (k in midToTrackId) { - this.midToTrackId[k.key] = k.value + if (publisher.isStaleAnswer(offerId)) { + return Either.Right("Old offer, ignoring: $offerId") + } + // libwebrtc reports new tracks while it applies the description, and those lookups + // read this mapping. + this.midToTrackId.putAll(midToTrackId) + + val result = publisher.setRemoteDescription(answer, offerId) + if (result.isLeft()) { + attachBoundTracks() + } + return result + } + + /** + * Offers [onTrackBound] every receiver whose media section is mapped to a track ID it is + * not attached as. libwebrtc reports a track only when its section starts receiving, not + * when the server binds another track to a section that already is. + */ + private suspend fun attachBoundTracks() { + publisher.withPeerConnection { + for (transceiver in transceivers) { + val trackId = transceiver.mid?.let { midToTrackId[it] } ?: continue + val receiver = transceiver.receiver ?: continue + val track = receiver.track() ?: continue + if (attachedTrackIds[receiver.id()] == trackId) { + continue + } + if (onTrackBound(receiver, track, trackId)) { + attachedTrackIds[receiver.id()] = trackId + } + } } - val res = publisher.setRemoteDescription(answer, offerId) - return res } override fun trackIdForReceiver(receiver: RtpReceiver): String? { diff --git a/livekit-android-test/src/test/java/io/livekit/android/room/SinglePeerConnectionMockE2ETest.kt b/livekit-android-test/src/test/java/io/livekit/android/room/SinglePeerConnectionMockE2ETest.kt index 589a04a2e..7630c2bea 100644 --- a/livekit-android-test/src/test/java/io/livekit/android/room/SinglePeerConnectionMockE2ETest.kt +++ b/livekit-android-test/src/test/java/io/livekit/android/room/SinglePeerConnectionMockE2ETest.kt @@ -111,10 +111,10 @@ class SinglePeerConnectionMockE2ETest : MockE2ETest() { } /** - * Has the server require [audios] receiving audio sections and [videos] video ones, and - * answers the renegotiation that follows with [midToTrackId]. + * Has the server require [audios] receiving audio sections and [videos] video ones, which + * leaves the renegotiation offer that follows unanswered. */ - private fun TestScope.requireMediaSections(audios: Int, videos: Int, midToTrackId: Map = emptyMap()) { + private fun TestScope.requireMediaSections(audios: Int, videos: Int) { val requirement = with(LivekitRtc.SignalResponse.newBuilder()) { setMediaSectionsRequirement( with(LivekitRtc.MediaSectionsRequirement.newBuilder()) { @@ -130,7 +130,6 @@ class SinglePeerConnectionMockE2ETest : MockE2ETest() { // The mock peer connection does not ask for renegotiation on its own. publisherPeerConnection().observer?.onRenegotiationNeeded() advanceUntilIdle() - answerLastOffer(midToTrackId) } @Test @@ -163,6 +162,7 @@ class SinglePeerConnectionMockE2ETest : MockE2ETest() { connectSinglePeerConnection() requireMediaSections(audios = 1, videos = 2) + answerLastOffer() val transceivers = publisherPeerConnection().transceivers assertEquals(3, transceivers.size) @@ -171,28 +171,50 @@ class SinglePeerConnectionMockE2ETest : MockE2ETest() { assertEquals(2, transceivers.count { it.mediaType == MediaStreamTrack.MediaType.MEDIA_TYPE_VIDEO }) } + /** + * Adds one receiving audio section with mid "0" and a track on its receiver, and leaves + * the renegotiation offer unanswered. + */ + private fun TestScope.addReceivingAudioSection(): RtpTransceiver { + requireMediaSections(audios = 1, videos = 0) + val transceiver = publisherPeerConnection().transceivers.single() + whenever(transceiver.mid).thenReturn("0") + whenever(transceiver.receiver.track()).thenReturn(MockAudioStreamTrack()) + return transceiver + } + @Test - fun remoteTrackResolvesThroughAnswerMapping() = runTest { + fun boundTrackAttachesWithoutTrackCallback() = runTest { connectSinglePeerConnection() simulateMessageFromServer(TestData.PARTICIPANT_JOIN) val remoteParticipant = room.getParticipantBySid(TestData.REMOTE_PARTICIPANT.sid) as RemoteParticipant + addReceivingAudioSection() + val collector = EventCollector(room.events, coroutineRule.scope) - requireMediaSections(audios = 1, videos = 0) - val transceiver = publisherPeerConnection().transceivers.single() - whenever(transceiver.mid).thenReturn("0") answerLastOffer(midToTrackId = mapOf("0" to TestData.REMOTE_AUDIO_TRACK.sid)) - val receiver = transceiver.receiver - whenever(receiver.track()).thenReturn(MockAudioStreamTrack()) - // The stream ID carries no track SID, so only the answer's mapping can resolve the track. + val events = collector.stopCollecting() + assertEquals(1, events.count { it is RoomEvent.TrackSubscribed }) + val micPub = remoteParticipant.getTrackPublication(Track.Source.MICROPHONE) + assertNotNull(micPub?.track) + } + + @Test + fun trackCallbackAfterBoundTrackDoesNotAttachTwice() = runTest { + connectSinglePeerConnection() + simulateMessageFromServer(TestData.PARTICIPANT_JOIN) + val transceiver = addReceivingAudioSection() + val collector = EventCollector(room.events, coroutineRule.scope) + answerLastOffer(midToTrackId = mapOf("0" to TestData.REMOTE_AUDIO_TRACK.sid)) + publisherPeerConnection().observer?.onAddTrack( - receiver, + transceiver.receiver, arrayOf(MockMediaStream(id = createMediaStreamId(TestData.REMOTE_PARTICIPANT.sid, "stream"))), ) advanceUntilIdle() - val micPub = remoteParticipant.getTrackPublication(Track.Source.MICROPHONE) - assertNotNull(micPub?.track) + val events = collector.stopCollecting() + assertEquals(1, events.count { it is RoomEvent.TrackSubscribed }) } @Test diff --git a/livekit-android-test/src/test/java/io/livekit/android/room/SinglePeerConnectionTransportTest.kt b/livekit-android-test/src/test/java/io/livekit/android/room/SinglePeerConnectionTransportTest.kt index bb05fb2c9..ea5741b98 100644 --- a/livekit-android-test/src/test/java/io/livekit/android/room/SinglePeerConnectionTransportTest.kt +++ b/livekit-android-test/src/test/java/io/livekit/android/room/SinglePeerConnectionTransportTest.kt @@ -33,6 +33,7 @@ import kotlinx.coroutines.test.runTest import livekit.LivekitRtc.MediaSectionsRequirement import livekit.LivekitRtc.SignalTarget import livekit.org.webrtc.IceCandidate +import livekit.org.webrtc.MediaStreamTrack import livekit.org.webrtc.MediaStreamTrack.MediaType import livekit.org.webrtc.MockPeerConnectionFactory import livekit.org.webrtc.PeerConnection @@ -52,6 +53,8 @@ import org.junit.Assert.assertTrue import org.junit.Before import org.junit.Test import org.mockito.kotlin.any +import org.mockito.kotlin.doReturn +import org.mockito.kotlin.eq import org.mockito.kotlin.mock import org.mockito.kotlin.never import org.mockito.kotlin.spy @@ -92,9 +95,16 @@ class SinglePeerConnectionTransportTest { ) } + private val boundTracks = mutableListOf>() + private var attachBoundTracks = true + private fun transport() = SinglePeerConnectionTransport( publisher = publisher, publisherState = publisherState, + onTrackBound = { receiver, _, trackId -> + boundTracks.add(receiver to trackId) + attachBoundTracks + }, ) private fun answer(sdp: String = "remote_answer") = SessionDescription(SessionDescription.Type.ANSWER, sdp) @@ -226,6 +236,15 @@ class SinglePeerConnectionTransportTest { return transceiver.receiver } + /** + * Like [receiverForMid], with a track on the receiver as a negotiated section has. + */ + private fun boundReceiverForMid(mid: String): RtpReceiver { + val receiver = receiverForMid(mid) + whenever(receiver.track()).thenReturn(mock()) + return receiver + } + @Test fun trackIdForReceiverIsNullBeforeAnswer() { val receiver = receiverForMid("0") @@ -308,6 +327,95 @@ class SinglePeerConnectionTransportTest { assertEquals("TR_b", transport.trackIdForReceiver(receiver)) } + @Test + fun staleAnswerLeavesMappingUntouched() = runTest { + val transport = transport() + val receiver = receiverForMid("0") + transport.applyServerAnswer(answer("current"), offerId = 7, midToTrackId = mapOf("0" to "TR_a")) + doReturn(true).whenever(publisher).isStaleAnswer(6) + + val result = transport.applyServerAnswer(answer("stale"), offerId = 6, midToTrackId = mapOf("0" to "TR_b")) + + assertTrue("$result", result is Either.Right) + assertEquals("TR_a", transport.trackIdForReceiver(receiver)) + verifyBlocking(publisher, never()) { setRemoteDescription(any(), eq(6)) } + } + + // endregion + + // region bound tracks + + @Test + fun boundReceiverIsOfferedAfterAnswer() = runTest { + val receiver = boundReceiverForMid("0") + + transport().applyServerAnswer(answer(), offerId = 7, midToTrackId = mapOf("0" to "TR_a")) + + assertEquals(listOf(receiver to "TR_a"), boundTracks) + } + + @Test + fun attachedBindingIsNotOfferedAgain() = runTest { + val transport = transport() + boundReceiverForMid("0") + + transport.applyServerAnswer(answer("first"), offerId = 7, midToTrackId = mapOf("0" to "TR_a")) + transport.applyServerAnswer(answer("second"), offerId = 8, midToTrackId = mapOf("0" to "TR_a")) + + assertEquals(1, boundTracks.size) + } + + @Test + fun reboundReceiverIsOfferedAgain() = runTest { + val transport = transport() + val receiver = boundReceiverForMid("0") + + transport.applyServerAnswer(answer("first"), offerId = 7, midToTrackId = mapOf("0" to "TR_a")) + transport.applyServerAnswer(answer("second"), offerId = 8, midToTrackId = mapOf("0" to "TR_b")) + + assertEquals(listOf(receiver to "TR_a", receiver to "TR_b"), boundTracks) + } + + @Test + fun unattachedBindingIsOfferedAfterNextAnswer() = runTest { + val transport = transport() + val receiver = boundReceiverForMid("0") + attachBoundTracks = false + + transport.applyServerAnswer(answer("first"), offerId = 7, midToTrackId = mapOf("0" to "TR_a")) + transport.applyServerAnswer(answer("second"), offerId = 8, midToTrackId = emptyMap()) + + assertEquals(listOf(receiver to "TR_a", receiver to "TR_a"), boundTracks) + } + + @Test + fun receiverWithoutTrackIsNotOffered() = runTest { + receiverForMid("0") + + transport().applyServerAnswer(answer(), offerId = 7, midToTrackId = mapOf("0" to "TR_a")) + + assertTrue(boundTracks.isEmpty()) + } + + @Test + fun unmappedReceiverIsNotOffered() = runTest { + boundReceiverForMid("1") + + transport().applyServerAnswer(answer(), offerId = 7, midToTrackId = mapOf("0" to "TR_a")) + + assertTrue(boundTracks.isEmpty()) + } + + @Test + fun failedAnswerOffersNothing() = runTest { + boundReceiverForMid("0") + + val result = transport().applyServerAnswer(answer(sdp = ""), offerId = 7, midToTrackId = mapOf("0" to "TR_a")) + + assertTrue("$result", result is Either.Right) + assertTrue(boundTracks.isEmpty()) + } + // endregion // region handleMediaSectionsRequirement From 1ae2b47b6c4bb213f33aa85f25c65e943fa18558 Mon Sep 17 00:00:00 2001 From: Sen Chang Date: Thu, 12 Nov 2026 13:03:34 -0800 Subject: [PATCH 11/12] Negotiate on every media sections requirement In single peer connection mode the server cannot offer, so it sends a MediaSectionsRequirement whenever it needs the client to. The counts only cover sections that do not exist yet: removing a track, or binding a new one to an idle section, sends the requirement with both at zero. Negotiation used to follow only from adding a transceiver, so a zero-count requirement produced no offer and the server's change never arrived. RTCEngine now requests a publisher negotiation after handling the requirement. The server only sends this message when it has no subscriber transport, so dual peer connection mode is unaffected. --- .../java/io/livekit/android/room/RTCEngine.kt | 2 ++ .../room/SinglePeerConnectionTransport.kt | 2 -- .../room/SinglePeerConnectionMockE2ETest.kt | 24 ++++++++++++------- 3 files changed, 18 insertions(+), 10 deletions(-) diff --git a/livekit-android-sdk/src/main/java/io/livekit/android/room/RTCEngine.kt b/livekit-android-sdk/src/main/java/io/livekit/android/room/RTCEngine.kt index 4720ef735..80a019edc 100644 --- a/livekit-android-sdk/src/main/java/io/livekit/android/room/RTCEngine.kt +++ b/livekit-android-sdk/src/main/java/io/livekit/android/room/RTCEngine.kt @@ -1444,6 +1444,8 @@ internal constructor( override fun onMediaSectionsRequirement(requirement: LivekitRtc.MediaSectionsRequirement) { coroutineScope.launch { transport?.handleMediaSectionsRequirement(requirement) + // The server asks for an offer this way, including when it needs no new section. + negotiatePublisher() } } diff --git a/livekit-android-sdk/src/main/java/io/livekit/android/room/SinglePeerConnectionTransport.kt b/livekit-android-sdk/src/main/java/io/livekit/android/room/SinglePeerConnectionTransport.kt index 71dda6f64..906942a93 100644 --- a/livekit-android-sdk/src/main/java/io/livekit/android/room/SinglePeerConnectionTransport.kt +++ b/livekit-android-sdk/src/main/java/io/livekit/android/room/SinglePeerConnectionTransport.kt @@ -143,8 +143,6 @@ internal class SinglePeerConnectionTransport( addTransceiver(MediaStreamTrack.MediaType.MEDIA_TYPE_VIDEO, transceiverInit) } } - - // Adding transceiver triggers the onRenegotiationNeeded event and triggers negotiation. } override fun prepareForIceRestart() { diff --git a/livekit-android-test/src/test/java/io/livekit/android/room/SinglePeerConnectionMockE2ETest.kt b/livekit-android-test/src/test/java/io/livekit/android/room/SinglePeerConnectionMockE2ETest.kt index 7630c2bea..e6755d004 100644 --- a/livekit-android-test/src/test/java/io/livekit/android/room/SinglePeerConnectionMockE2ETest.kt +++ b/livekit-android-test/src/test/java/io/livekit/android/room/SinglePeerConnectionMockE2ETest.kt @@ -58,13 +58,13 @@ class SinglePeerConnectionMockE2ETest : MockE2ETest() { private fun publisherPeerConnection() = getPublisherPeerConnection() /** - * @return the most recent offer the client sent to the server. + * @return the offers the client has sent to the server, oldest first. */ - private fun lastSentOffer(): LivekitRtc.SessionDescription { + private fun sentOffers(): List { return wsFactory.ws.sentRequests .map { LivekitRtc.SignalRequest.newBuilder().mergeFrom(it.toPBByteString()).build() } - .last { it.hasOffer() } - .offer + .filter { it.hasOffer() } + .map { it.offer } } /** @@ -72,7 +72,7 @@ class SinglePeerConnectionMockE2ETest : MockE2ETest() { * receiving media sections to track IDs. */ private fun TestScope.answerLastOffer(midToTrackId: Map = emptyMap()) { - val offer = lastSentOffer() + val offer = sentOffers().last() val answer = with(LivekitRtc.SignalResponse.newBuilder()) { setAnswer( with(LivekitRtc.SessionDescription.newBuilder()) { @@ -127,9 +127,6 @@ class SinglePeerConnectionMockE2ETest : MockE2ETest() { } simulateMessageFromServer(requirement) advanceUntilIdle() - // The mock peer connection does not ask for renegotiation on its own. - publisherPeerConnection().observer?.onRenegotiationNeeded() - advanceUntilIdle() } @Test @@ -217,6 +214,17 @@ class SinglePeerConnectionMockE2ETest : MockE2ETest() { assertEquals(1, events.count { it is RoomEvent.TrackSubscribed }) } + @Test + fun zeroCountRequirementSendsOffer() = runTest { + connectSinglePeerConnection() + val offersBefore = sentOffers().size + + requireMediaSections(audios = 0, videos = 0) + + assertEquals(offersBefore + 1, sentOffers().size) + assertTrue(publisherPeerConnection().transceivers.isEmpty()) + } + @Test fun serverOfferIsIgnored() = runTest { connectSinglePeerConnection() From e2ba16aad60800d33474c499860a2d485414ed10 Mon Sep 17 00:00:00 2001 From: Sen Chang Date: Thu, 12 Nov 2026 14:45:14 -0800 Subject: [PATCH 12/12] Attach bound tracks once their publication arrives A track the server binds without a track callback is attached by finding the participant that owns the publication. When the answer carrying the binding arrives before the participant update announcing that publication, there is no owner to find, and the binding was only tried again after the next answer. With no further answer the track stayed unsubscribed. Room now asks the engine to attach bound tracks after every participant update, which runs the same transceiver walk as an accepted answer. Bindings that are already attached are skipped, and dual peer connection mode has nothing to attach. --- .../room/DualPeerConnectionTransport.kt | 4 ++++ .../java/io/livekit/android/room/RTCEngine.kt | 9 ++++++++ .../main/java/io/livekit/android/room/Room.kt | 2 ++ .../room/SinglePeerConnectionTransport.kt | 2 +- .../java/io/livekit/android/room/Transport.kt | 6 +++++ .../room/SinglePeerConnectionMockE2ETest.kt | 16 +++++++++++++ .../room/SinglePeerConnectionTransportTest.kt | 23 +++++++++++++++++++ 7 files changed, 61 insertions(+), 1 deletion(-) diff --git a/livekit-android-sdk/src/main/java/io/livekit/android/room/DualPeerConnectionTransport.kt b/livekit-android-sdk/src/main/java/io/livekit/android/room/DualPeerConnectionTransport.kt index 187a605fc..909a37c3b 100644 --- a/livekit-android-sdk/src/main/java/io/livekit/android/room/DualPeerConnectionTransport.kt +++ b/livekit-android-sdk/src/main/java/io/livekit/android/room/DualPeerConnectionTransport.kt @@ -111,6 +111,10 @@ internal class DualPeerConnectionTransport( return null } + override suspend fun attachBoundTracks() { + // Not needed for dual transport. + } + override suspend fun handleMediaSectionsRequirement(requirement: LivekitRtc.MediaSectionsRequirement) { // Not needed for dual transport. } diff --git a/livekit-android-sdk/src/main/java/io/livekit/android/room/RTCEngine.kt b/livekit-android-sdk/src/main/java/io/livekit/android/room/RTCEngine.kt index 80a019edc..c8d95b402 100644 --- a/livekit-android-sdk/src/main/java/io/livekit/android/room/RTCEngine.kt +++ b/livekit-android-sdk/src/main/java/io/livekit/android/room/RTCEngine.kt @@ -1682,6 +1682,15 @@ internal constructor( return transport?.trackIdForReceiver(receiver) } + /** + * Attaches the tracks the server has bound to publications that have since arrived. + */ + internal fun attachBoundTracks() { + coroutineScope.launch { + transport?.attachBoundTracks() + } + } + fun createStatsGetter(receiver: RtpReceiver): RTCStatsGetter { val p = transport?.subscriber return { statsCallback: RTCStatsCollectorCallback -> diff --git a/livekit-android-sdk/src/main/java/io/livekit/android/room/Room.kt b/livekit-android-sdk/src/main/java/io/livekit/android/room/Room.kt index 560942a19..b0b449035 100644 --- a/livekit-android-sdk/src/main/java/io/livekit/android/room/Room.kt +++ b/livekit-android-sdk/src/main/java/io/livekit/android/room/Room.kt @@ -1372,6 +1372,8 @@ constructor( } } } + // A track can be bound before the update that announces its publication. + engine.attachBoundTracks() } /** diff --git a/livekit-android-sdk/src/main/java/io/livekit/android/room/SinglePeerConnectionTransport.kt b/livekit-android-sdk/src/main/java/io/livekit/android/room/SinglePeerConnectionTransport.kt index 906942a93..03373b1ec 100644 --- a/livekit-android-sdk/src/main/java/io/livekit/android/room/SinglePeerConnectionTransport.kt +++ b/livekit-android-sdk/src/main/java/io/livekit/android/room/SinglePeerConnectionTransport.kt @@ -104,7 +104,7 @@ internal class SinglePeerConnectionTransport( * not attached as. libwebrtc reports a track only when its section starts receiving, not * when the server binds another track to a section that already is. */ - private suspend fun attachBoundTracks() { + override suspend fun attachBoundTracks() { publisher.withPeerConnection { for (transceiver in transceivers) { val trackId = transceiver.mid?.let { midToTrackId[it] } ?: continue diff --git a/livekit-android-sdk/src/main/java/io/livekit/android/room/Transport.kt b/livekit-android-sdk/src/main/java/io/livekit/android/room/Transport.kt index 4c280038d..645dbc952 100644 --- a/livekit-android-sdk/src/main/java/io/livekit/android/room/Transport.kt +++ b/livekit-android-sdk/src/main/java/io/livekit/android/room/Transport.kt @@ -98,6 +98,12 @@ internal interface Transport { */ fun trackIdForReceiver(receiver: RtpReceiver): String? + /** + * Attaches the received tracks the server has bound to a track ID and that are not attached + * as it yet, such as those whose publication had not arrived when the binding did. + */ + suspend fun attachBoundTracks() + /** * Ensures there are at least as many receive-only media sections as the server requires * to deliver remote tracks. diff --git a/livekit-android-test/src/test/java/io/livekit/android/room/SinglePeerConnectionMockE2ETest.kt b/livekit-android-test/src/test/java/io/livekit/android/room/SinglePeerConnectionMockE2ETest.kt index e6755d004..1debb049d 100644 --- a/livekit-android-test/src/test/java/io/livekit/android/room/SinglePeerConnectionMockE2ETest.kt +++ b/livekit-android-test/src/test/java/io/livekit/android/room/SinglePeerConnectionMockE2ETest.kt @@ -196,6 +196,22 @@ class SinglePeerConnectionMockE2ETest : MockE2ETest() { assertNotNull(micPub?.track) } + @Test + fun boundTrackAttachesOncePublicationArrives() = runTest { + connectSinglePeerConnection() + addReceivingAudioSection() + val collector = EventCollector(room.events, coroutineRule.scope) + answerLastOffer(midToTrackId = mapOf("0" to TestData.REMOTE_AUDIO_TRACK.sid)) + + simulateMessageFromServer(TestData.PARTICIPANT_JOIN) + advanceUntilIdle() + + val events = collector.stopCollecting() + assertEquals(1, events.count { it is RoomEvent.TrackSubscribed }) + val remoteParticipant = room.getParticipantBySid(TestData.REMOTE_PARTICIPANT.sid) as RemoteParticipant + assertNotNull(remoteParticipant.getTrackPublication(Track.Source.MICROPHONE)?.track) + } + @Test fun trackCallbackAfterBoundTrackDoesNotAttachTwice() = runTest { connectSinglePeerConnection() diff --git a/livekit-android-test/src/test/java/io/livekit/android/room/SinglePeerConnectionTransportTest.kt b/livekit-android-test/src/test/java/io/livekit/android/room/SinglePeerConnectionTransportTest.kt index ea5741b98..e38be5953 100644 --- a/livekit-android-test/src/test/java/io/livekit/android/room/SinglePeerConnectionTransportTest.kt +++ b/livekit-android-test/src/test/java/io/livekit/android/room/SinglePeerConnectionTransportTest.kt @@ -388,6 +388,29 @@ class SinglePeerConnectionTransportTest { assertEquals(listOf(receiver to "TR_a", receiver to "TR_a"), boundTracks) } + @Test + fun unattachedBindingIsOfferedOnRequest() = runTest { + val transport = transport() + val receiver = boundReceiverForMid("0") + attachBoundTracks = false + transport.applyServerAnswer(answer(), offerId = 7, midToTrackId = mapOf("0" to "TR_a")) + + transport.attachBoundTracks() + + assertEquals(listOf(receiver to "TR_a", receiver to "TR_a"), boundTracks) + } + + @Test + fun attachedBindingIsNotOfferedOnRequest() = runTest { + val transport = transport() + boundReceiverForMid("0") + transport.applyServerAnswer(answer(), offerId = 7, midToTrackId = mapOf("0" to "TR_a")) + + transport.attachBoundTracks() + + assertEquals(1, boundTracks.size) + } + @Test fun receiverWithoutTrackIsNotOffered() = runTest { receiverForMid("0")