create and send offer through peer connection transport

@@ -17,7 +17,7 @@ import javax.inject.Named
 /**
 /**
  * @suppress
  * @suppress
  */
  */
-class PeerConnectionTransport
+internal class PeerConnectionTransport
 @AssistedInject
 @AssistedInject
 constructor(
 constructor(
     @Assisted config: PeerConnection.RTCConfiguration,
     @Assisted config: PeerConnection.RTCConfiguration,
@@ -28,14 +28,14 @@ constructor(
     connectionFactory: PeerConnectionFactory
     connectionFactory: PeerConnectionFactory
 ) {
 ) {
     private val coroutineScope = CoroutineScope(ioDispatcher + SupervisorJob())
     private val coroutineScope = CoroutineScope(ioDispatcher + SupervisorJob())
-    val peerConnection: PeerConnection = connectionFactory.createPeerConnection(
+    internal val peerConnection: PeerConnection = connectionFactory.createPeerConnection(
         config,
         config,
         pcObserver
         pcObserver
     ) ?: throw IllegalStateException("peer connection creation failed?")
     ) ?: throw IllegalStateException("peer connection creation failed?")
-    val pendingCandidates = mutableListOf<IceCandidate>()
-    var restartingIce: Boolean = false
+    private val pendingCandidates = mutableListOf<IceCandidate>()
+    private var restartingIce: Boolean = false
 
 
-    var renegotiate = false
+    private var renegotiate = false
 
 
     interface Listener {
     interface Listener {
         fun onOffer(sd: SessionDescription)
         fun onOffer(sd: SessionDescription)
@@ -97,11 +97,17 @@ constructor(
 
 
         // actually negotiate
         // actually negotiate
         Timber.d { "starting to negotiate" }
         Timber.d { "starting to negotiate" }
-        val offer = peerConnection.createOffer(constraints)
-        if (offer is Either.Left) {
-            peerConnection.setLocalDescription(offer.value)
-            listener?.onOffer(offer.value)
+        val sdpOffer = when (val outcome = peerConnection.createOffer(constraints)) {
+            is Either.Left -> outcome.value
+            is Either.Right -> {
+                Timber.d { "error creating offer: ${outcome.value}" }
+                return
+            }
         }
         }
+
+        Timber.v { "sdp offer = $sdpOffer, description: ${sdpOffer.description}, type: ${sdpOffer.type}" }
+        peerConnection.setLocalDescription(sdpOffer)
+        listener?.onOffer(sdpOffer)
     }
     }
 
 
 
 

@@ -34,7 +34,7 @@ import kotlin.coroutines.suspendCoroutine
 @Singleton
 @Singleton
 class RTCEngine
 class RTCEngine
 @Inject
 @Inject
-constructor(
+internal constructor(
     val client: SignalClient,
     val client: SignalClient,
     private val pctFactory: PeerConnectionTransport.Factory,
     private val pctFactory: PeerConnectionTransport.Factory,
     @Named(InjectionNames.DISPATCHER_IO) ioDispatcher: CoroutineDispatcher,
     @Named(InjectionNames.DISPATCHER_IO) ioDispatcher: CoroutineDispatcher,
@@ -269,7 +269,7 @@ constructor(
             wsRetries = 0
             wsRetries = 0
 
 
             // trigger publisher reconnect
             // trigger publisher reconnect
-            subscriber.restartingIce = true
+            subscriber.prepareForIceRestart()
             // only restart publisher if it's needed
             // only restart publisher if it's needed
             if (hasPublished) {
             if (hasPublished) {
                 publisher.createAndSendOffer(
                 publisher.createAndSendOffer(
@@ -294,24 +294,7 @@ constructor(
             return
             return
         }
         }
         coroutineScope.launch {
         coroutineScope.launch {
-            val sdpOffer =
-                when (val outcome = publisher.peerConnection.createOffer(getPublisherOfferConstraints())) {
-                    is Either.Left -> outcome.value
-                    is Either.Right -> {
-                        Timber.d { "error creating offer: ${outcome.value}" }
-                        return@launch
-                    }
-                }
-
-            Timber.v { "sdp offer = $sdpOffer, description: ${sdpOffer.description}, type: ${sdpOffer.type}" }
-            when (val outcome = publisher.peerConnection.setLocalDescription(sdpOffer)) {
-                is Either.Right -> {
-                    Timber.d { "error setting local description: ${outcome.value}" }
-                    return@launch
-                }
-            }
-
-            client.sendOffer(sdpOffer)
+            publisher.createAndSendOffer(getPublisherOfferConstraints())
         }
         }
     }
     }