Android Headless SDK

// app/build.gradle.kts
dependencies {
    implementation("io.hotmic:sdk:0.1.0")
}

import io.hotmic.sdk.HotMicClient
import io.hotmic.sdk.HotMicClientConfig

val client = HotMicClient(HotMicClientConfig(
    apiKey = "your-api-key",
    baseUrl = "https://api.hotmic.io",
    deviceId = stableDeviceId(context),
))

val session = client.joinStream(streamId)

session.onStreamUpdated = { stream ->
    println("title: ${stream.title}, viewers: ${stream.viewers}")
    // stream.hlsUrl is what you feed to ExoPlayer
}

session.onChat = { chat ->
    println("${chat.userName}: ${chat.message}")
}

session.sendChat("hello world")

// When the user leaves:
session.end()

HotMicClient(HotMicClientConfig(
    apiKey: String,                  // required — provisioned by HotMic
    baseUrl: String,                 // required — typically "https://api.hotmic.io"
    deviceId: String,                // required — stable per install (UUID)
    platform: String = "android",    // populates hm-platform header
    sdkVersion: String = "0.1.0",
    osVersion: String? = null,       // populates hm-os-version
    deviceModel: String? = null,     // populates hm-device-model
    accessToken: String? = null,     // pre-existing JWT (logged-in flow)
))

fun stableDeviceId(context: Context): String {
    val prefs = context.getSharedPreferences("hotmic", Context.MODE_PRIVATE)
    return prefs.getString("deviceId", null) ?: java.util.UUID.randomUUID().toString().also {
        prefs.edit().putString("deviceId", it).apply()
    }
}

val auth = client.signIn(email = "pat@example.com", password = "...")
// SDK now uses auth.accessToken automatically.

val auth = client.signUp(name = "Pat", email = "pat@example.com", password = "...")

val client = HotMicClient(HotMicClientConfig(
    ...,
    accessToken = existingJwt
))
// or later:
client.setAccessToken(existingJwt)

val live      = client.listStreams(ListStreamsQuery(state = "LIVE",      limit = 25))
val scheduled = client.listStreams(ListStreamsQuery(state = "SCHEDULED", limit = 25))
val past      = client.listStreams(ListStreamsQuery(state = "VOD",       limit = 25))

val stream = client.getStream(streamId)

val community = client.getCommunity(communityId)
// Community(id, name, topic, description, tone, thumbnailImage, emotes,
//           memberCount, streamCount, isJoined?, config: JsonObject?)

val tone = community.config?.get("questionGen")?.let { it as? kotlinx.serialization.json.JsonObject }
    ?.get("tone")?.let { it as? kotlinx.serialization.json.JsonPrimitive }?.contentOrNull

val session = client.joinStream(streamId)
val stream = session.currentStream
val user = session.currentUser

session.onChat = { chat ->
    lifecycleScope.launch(Dispatchers.Main) {
        chatAdapter.append(chat)
    }
}

session.onStreamUpdated = { stream ->
    lifecycleScope.launch(Dispatchers.Main) { viewModel.update(stream) }
}

session.onEnded = {
    lifecycleScope.launch(Dispatchers.Main) { dismissPlayer() }
}

val snapshot: Stream? = session.currentStream
val chats: List<Chat> = session.chats           // sorted ascending by createdAt
val reactions: List<Reaction> = session.reactions
val me: User? = session.currentUser

session.sendChat("hello world")
session.react(chatId = chatId, type = ReactionType.FIRE)
session.removeReaction(chatId = chatId, type = ReactionType.FIRE)
session.deleteChat(chatId)            // sender, mod, or broadcaster
session.reportChat(chatId)
session.blockUserInChat(userId)       // mod/broadcaster only
session.submitPollAnswer(pollId, optionId)

// Audience Q&A — create a new question on this session's stream.
// Returns the persisted Question with a server-assigned `id`.
val q = session.createQuestion("Who wins this round?")

session.end()  // POSTs /end_session/ with watched-ms, cancels timers

override fun onDestroy() {
    super.onDestroy()
    lifecycleScope.launch { session?.end() }
}

import androidx.media3.exoplayer.ExoPlayer
import androidx.media3.common.MediaItem
import androidx.media3.exoplayer.hls.HlsMediaSource
import androidx.media3.datasource.DefaultHttpDataSource

class PlayerHolder(context: Context) {
    val player: ExoPlayer = ExoPlayer.Builder(context).build()
    private var currentUrl: String? = null

    fun apply(stream: Stream) {
        val url = stream.hlsUrl ?: stream.vodUrl ?: return
        if (url == currentUrl) return
        val source = HlsMediaSource.Factory(DefaultHttpDataSource.Factory())
            .createMediaSource(MediaItem.fromUri(url))
        player.setMediaSource(source)
        player.prepare()
        player.playWhenReady = true
        currentUrl = url
    }

    fun release() {
        player.release()
        currentUrl = null
    }
}

// Wiring:
session.onStreamUpdated = { stream ->
    lifecycleScope.launch(Dispatchers.Main) {
        playerHolder.apply(stream)
    }
}
session.onEnded = {
    lifecycleScope.launch(Dispatchers.Main) {
        playerHolder.player.pause()
    }
}

try {
    session.sendChat("hi")
} catch (err: HotMicError) {
    when (err.status) {
        401, 403 -> { /* re-auth */ }
        429 -> { /* rate-limited */ }
        else -> Log.w("hotmic", "${err.status} ${err.message}")
    }
}

session.onError = { err ->
    Log.w("hotmic-bg", err)
}