Data channel check (#38)

@@ -312,38 +312,45 @@ internal constructor(
     }
     }
 
 
     internal suspend fun sendData(dataPacket: LivekitModels.DataPacket) {
     internal suspend fun sendData(dataPacket: LivekitModels.DataPacket) {
-        ensurePublisherConnected()
+        ensurePublisherConnected(dataPacket.kind)
 
 
         val buf = DataChannel.Buffer(
         val buf = DataChannel.Buffer(
             ByteBuffer.wrap(dataPacket.toByteArray()),
             ByteBuffer.wrap(dataPacket.toByteArray()),
             true,
             true,
         )
         )
 
 
-        val channel = when (dataPacket.kind) {
-            LivekitModels.DataPacket.Kind.RELIABLE -> reliableDataChannel
-            LivekitModels.DataPacket.Kind.LOSSY -> lossyDataChannel
-            else -> null
-        } ?: throw TrackException.PublishException("channel not established for ${dataPacket.kind.name}")
+        val channel = dataChannelForKind(dataPacket.kind)
+            ?: throw TrackException.PublishException("channel not established for ${dataPacket.kind.name}")
 
 
         channel.send(buf)
         channel.send(buf)
     }
     }
 
 
-    private suspend fun ensurePublisherConnected() {
+    private suspend fun ensurePublisherConnected(kind: LivekitModels.DataPacket.Kind) {
         if (!isSubscriberPrimary) {
         if (!isSubscriberPrimary) {
             return
             return
         }
         }
 
 
-        if (this.publisher.peerConnection.isConnected()) {
-            return
+        if (!this::publisher.isInitialized) {
+            throw RoomException.ConnectException("Publisher is not connected!")
+        }
+
+        if (!publisher.peerConnection.isConnected() &&
+            publisher.peerConnection.iceConnectionState() != PeerConnection.IceConnectionState.CHECKING
+        ) {
+            // start negotiation
+            this.negotiate();
         }
         }
 
 
-        // start negotiation
-        this.negotiate()
+
+        val targetChannel = dataChannelForKind(kind) ?: throw IllegalArgumentException("Unknown data packet kind!")
+        if (targetChannel.state() == DataChannel.State.OPEN) {
+            return
+        }
 
 
         // wait until publisher ICE connected
         // wait until publisher ICE connected
         val endTime = SystemClock.elapsedRealtime() + MAX_ICE_CONNECT_TIMEOUT_MS;
         val endTime = SystemClock.elapsedRealtime() + MAX_ICE_CONNECT_TIMEOUT_MS;
         while (SystemClock.elapsedRealtime() < endTime) {
         while (SystemClock.elapsedRealtime() < endTime) {
-            if (this.publisher.peerConnection.isConnected()) {
+            if (this.publisher.peerConnection.isConnected() && targetChannel.state() == DataChannel.State.OPEN) {
                 return
                 return
             }
             }
             delay(50)
             delay(50)
@@ -352,6 +359,13 @@ internal constructor(
         throw ConnectException("could not establish publisher connection")
         throw ConnectException("could not establish publisher connection")
     }
     }
 
 
+    private fun dataChannelForKind(kind: LivekitModels.DataPacket.Kind) =
+        when (kind) {
+            LivekitModels.DataPacket.Kind.RELIABLE -> reliableDataChannel
+            LivekitModels.DataPacket.Kind.LOSSY -> lossyDataChannel
+            else -> null
+        }
+
     private fun getPublisherOfferConstraints(): MediaConstraints {
     private fun getPublisherOfferConstraints(): MediaConstraints {
         return MediaConstraints().apply {
         return MediaConstraints().apply {
             with(mandatory) {
             with(mandatory) {