Core.initialize()

val subscriber = Core.createSubscriber()

launch {
    subscriber.state.map { it.connectionState }.distinctUntilChanged().collect {
        if (it == SubscriberConnectionState.Connected) {
            subscriber.subscribe()
        }
    }
}

launch {
    subscriber.track.collect { trackHolder ->
        when(trackHolder) {
            is TrackHolder.VideoTrackHolder -> {
                // Create the renderer:
                val view = com.millicast.video.TextureViewRenderer(applicationContext)
                // Add the renderer to the layout:
                val layout = findViewById<LinearLayout>(R.id.linear_layout_video)
                layout.addView(view)
                // Set the renderer as a sink on the video track:
                trackHolder.videoTrack.setVideoSink(view)
            }
            is TrackHolder.AudioTrackHolder -> {
                // No video, ignore
            }
        }
}

launchDefaultScope {
    val credentials = Credential(
        streamName = "STREAM_NAME",
        accountId = "ACCOUNT_ID",
        apiUrl = "https://director.millicast.com/api/director/subscribe"
    )

    subscriber.setCredentials(credentials)
    subscriber.connect()
}

Core.initialize()

val subscriber = Core.createSubscriber()

launch {
    subscriber.state.map { it.connectionState }.distinctUntilChanged().collect {
        if (it == SubscriberConnectionState.Connected) {
            subscriber.subscribe()
        }
    }
}

launch {
  subscriber.onRemoteTrack.collect { trackHolder ->
      when (trackHolder) {
          is RemoteAudioTrack -> {
            trackHolder.enableAsync()
          }

          is RemoteVideoTrack -> {
            trackHolder.enableAsync {videoSink = <The TextureViewRenderer View>}
          }
      }
  }
}

launchDefaultScope {
    val credentials = Credential(
        streamName = "STREAM_NAME",
        accountId = "ACCOUNT_ID",
        apiUrl = "https://director.millicast.com/api/director/subscribe"
    )

    subscriber.setCredentials(credentials)
    subscriber.connect()
}

//Using the multi-source feature requires projecting tracks into a specified transceiver using its media ID (mid). When you start subscribing, you will receive the activity flow updates. To forward the selected media to the subscriber, use the project method of the subscriber. It requires providing the source ID you are targeting and an array of the tracks you want to project. And for more advanced cases, you may need to unproject and project tracks again. So you have to store a map of <sourceId, RemoteTrackHolder> for later usage. To achieve this you should listen to the StreamSourceActivity flow, then for every new track add only the new tracks to this stored map. Which is a big effort to do and a lot of stuff to worry about, as an example WHEN to re-init this map and etc.

Core.initialize()

val subscriber = Core.createSubscriber()

launch {
    subscriber.state.map { it.connectionState }.distinctUntilChanged().collect {
        if (it == SubscriberConnectionState.Connected) {
            subscriber.subscribe()
        }
    }
}

// Initialize the local items important for this local sample
val streamIdMap = mutableMapOf<String, StreamSourceActivity>()
val queue = Queue()
// com.millicast.utils.Queue provides a scope.launch { } that will wait
// for its head to complete before calling the next item

/**
 * Retrieve the list of new tracks given modifications on the StreamSourceActivity object
 */
fun checkTracksInStreamSourceActivity(streamSourceActivity: StreamSourceActivity): StreamSourceActivity {
  // First, ensure that you find a corresponding cached version
  streamIdMap.putIfAbsent(
    streamSourceActivity.streamId,
    streamSourceActivity.copy(activeTracks = emptyArray())
  )

  val cached = streamIdMap[streamSourceActivity.streamId]!!

  // All the new tracks, for example each track that is in the new array but not the previous
  val newTracks = streamSourceActivity.activeTracks.filter { activeTrack ->
    null == cached.activeTracks.find { it.trackId == activeTrack.trackId }
  }

  // Send a copy that contains only the new tracks
  return streamSourceActivity.copy(activeTracks = newTracks.toTypedArray())
}

/**
 * When a new source becomes active, store information about it, create a local track,
 * and send the projection command
 */
launch {
  subscriber.state.map { it.streamSourceActivities }.collect { streamSourceActivities ->
    queue.post {
      // Check whether the list of activity or tracks
      // is empty, which means that everything local needs to be flushed

      streamSourceActivities.map { activity ->
        // Fetch a copy of the activity object containing only the new tracks
        val newlyFoundRemoteTracks = checkTracksInStreamSourceActivity(activity)

        // Update the cached list of activeTracks with the one obtained at the beginning
        streamIdMap[activity.streamId] = streamIdMap[activity.streamId]!!.copy(
          activeTracks = activity.activeTracks
        )

        newlyFoundRemoteTracks
      }.forEach { activity ->
        // The activity only contains the newly added tracks
        activity.activeTracks.forEach {
          // You can add the remote track locally
          val newlyAddedLocalTrack = subscriber.addRemoteTrackForResult(it.media)

          // Send the command to project the remote content locally
          subscriber.project(
            activity.sourceId, arrayListOf(
              ProjectionData(
                trackId = it.trackId,
                media = it.media.name.lowercase(),
                mid = newlyAddedLocalTrack.mid!!
              )
            )
          )
        }
      }
    }
  }
}

launchDefaultScope {
    val credentials = Credential(
        streamName = "STREAM_NAME",
        accountId = "ACCOUNT_ID",
        apiUrl = "https://director.millicast.com/api/director/subscribe"
    )

    subscriber.setCredentials(credentials)
    subscriber.connect()
}

Core.initialize()

val subscriber = Core.createSubscriber()

launch {
    subscriber.state.map { it.connectionState }.distinctUntilChanged().collect {
        if (it == SubscriberConnectionState.Connected) {
            subscriber.subscribe()
        }
    }
}

launch {
  subscriber.onRemoteTrack.collect { trackHolder ->
      when (trackHolder) {
          is RemoteAudioTrack -> {
            trackHolder.enableAsync()
          }

          is RemoteVideoTrack -> {
            trackHolder.enableAsync {videoSink = <The TextureViewRenderer View>}

            trackHolder.onState.collectInLocalScope { trackState ->
                if (!trackState.isActive) {
                    // Either call trackHolder.disableAsync() and remove the video renderer view or show an UI message till source comes back online
                }
            }
          }
      }
  }
}

launchDefaultScope {
    val credentials = Credential(
        streamName = "STREAM_NAME",
        accountId = "ACCOUNT_ID",
        apiUrl = "https://director.millicast.com/api/director/subscribe"
    )

    subscriber.setCredentials(credentials)
    subscriber.connect()
}