import com.millicast.Core
import kotlinx.coroutines.*
import com.millicast.subscribers.*

// Helper for later usage
fun <T> CoroutineScope.safeLaunch(
    onError: (suspend CoroutineScope.(err: Throwable) -> T)? = null,
    block: suspend CoroutineScope.() -> T
) = launch {
    try {
        block()
    } catch (err: Throwable) {
        onError?.invoke(this, err)
    }
}

// Creating the subscriber
val subscriber = Core.createSubscriber()

coroutineScope.safeLaunch {
    val credential = Credential(
        // Set the streamName, accountId, and API URL
        streamName = "myStreamName",
        accountId = "qwertyuiop",
        apiUrl = "https://director.millicast.com/api/director/subscribe"
    )

    subscriber.setCredentials(credential)
}

val coroutineScope = CoroutineScope(Dispatchers.IO)
coroutineScope.async {
    subscriber.state.collect { newSubscriberState ->
        Log.d("SAMPLE", "having new State ${newSubscriberState}")
    }
}
coroutineScope.async {
    subscriber.track.collect { newTrackHolder ->
        Log.d("SAMPLE", "new track ${newTrackHolder.mid.orEmpty()}")
    }
}
// ... others follow

coroutineScope.safeLaunch {
    val option = Option(
        // The main source that will be received by the default media stream
        pinnedSourceId = "mainSource",
        // Enables audio multiplexing and denotes the number of audio tracks to receive as Voice Activity Detection (VAD) multiplexed audio
        multiplexedAudioTrack = 3U,
        // Audio streams that should not be included in the multiplex, for example your own audio stream
        excludedSourceId = arrayOf("excluded")
    )
    // Set the selected options
    subscriber.connect()
    subscriber.subscribe(option)
}

// 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
 */
coroutineScope.async {
  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!!
                  )
            )
          )
        }
      }
    }
  }
} 

// Get layer updates:
coroutineScope.async {
    subscriber.layers.collect { layers ->
        // Got layers update
        if (!layers.activeLayers.isEmpty()) {
            // Select some layer; passing null will make an automatic selection
            subscriber.select(layers.activeLayers[0])
        }
    }
}

<!-- Add a layout in your fragment to add a view in Kotlin code later -->

<LinearLayout
  android:id="@+id/linear_layout_video"
  android:layout_width="match_parent"
  android:layout_height="0dp"
  android:layout_weight="0.6"
	android:orientation="horizontal">
</LinearLayout>

coroutineScope.async {
    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
            }
        }
    }
}

// Select one playback device to be able to play audio
Media.audioPlayback.firstOrNull()?.initPlayback()

// Adjust the volume of all new remote tracks
coroutineScope.async {
    subscriber.track.collect { trackHolder ->
        when(trackHolder) {
            is TrackHolder.VideoTrackHolder -> {
                // No audio, ignore
            }
            is TrackHolder.AudioTrackHolder -> {
                trackHolder.audioTrack.setVolume(1.0) // The volume must be between 0 and 1
            }
        }
    }
}