tirtc-react-native 2.2.0

package/android/src/main/java/com/tange/ai/tirtc/reactnative/TiRtcReactNativeEventSink.kt

@@ -0,0 +1,168 @@
+package com.tange.ai.tirtc.reactnative
+
+import android.util.Size
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableArray
+import com.facebook.react.bridge.WritableMap
+
+internal class TiRtcReactNativeEventSink(
+    private val registry: TiRtcReactNativeRegistry,
+    private val emit: (WritableMap) -> Unit,
+) {
+    fun connStateChanged(
+        objectId: Int,
+        state: String,
+        errorCode: Int,
+    ) {
+        emit(base("connStateChanged", objectId).apply {
+            putString("state", state)
+            putInt("errorCode", TiRtcReactNativeErrors.normalizeAndroid(errorCode))
+        })
+    }
+
+    fun connCommand(
+        objectId: Int,
+        commandId: Long,
+        data: ByteArray,
+    ) {
+        emit(base("connCommand", objectId).apply {
+            putDouble("commandId", commandId.toDouble())
+            putArray("data", data.toWritableArray())
+        })
+    }
+
+    fun connStreamMessage(
+        objectId: Int,
+        streamId: Int,
+        timestampMs: Long,
+        data: ByteArray,
+    ) {
+        emit(base("connStreamMessage", objectId).apply {
+            putInt("streamId", streamId)
+            putDouble("timestampMs", timestampMs.toDouble())
+            putArray("data", data.toWritableArray())
+        })
+    }
+
+    fun audioOutputStateChanged(
+        objectId: Int,
+        state: String,
+    ) {
+        emit(base("audioOutputStateChanged", objectId).apply {
+            putString("state", state)
+        })
+    }
+
+    fun audioOutputError(
+        objectId: Int,
+        code: Int,
+    ) {
+        emit(base("audioOutputError", objectId).apply {
+            putInt("code", TiRtcReactNativeErrors.normalizeAndroid(code))
+        })
+    }
+
+    fun videoOutputStateChanged(
+        objectId: Int,
+        state: String,
+    ) {
+        emit(base("videoOutputStateChanged", objectId).apply {
+            putString("state", state)
+        })
+    }
+
+    fun videoOutputRenderSizeChanged(
+        objectId: Int,
+        size: Size,
+    ) {
+        emit(base("videoOutputRenderSizeChanged", objectId).apply {
+            putMap("size", size.toWritableMap())
+        })
+    }
+
+    fun videoOutputError(
+        objectId: Int,
+        code: Int,
+    ) {
+        emit(base("videoOutputError", objectId).apply {
+            putInt("code", TiRtcReactNativeErrors.normalizeAndroid(code))
+        })
+    }
+
+    fun audioInputStateChanged(
+        objectId: Int,
+        state: String,
+    ) {
+        emit(base("audioInputStateChanged", objectId).apply {
+            putString("state", state)
+        })
+    }
+
+    fun audioInputError(
+        objectId: Int,
+        code: Int,
+        message: String?,
+    ) {
+        emit(base("audioInputError", objectId).apply {
+            putInt("code", TiRtcReactNativeErrors.normalizeAndroid(code))
+            putString("message", message)
+        })
+    }
+
+    fun videoInputStateChanged(
+        objectId: Int,
+        state: String,
+    ) {
+        emit(base("videoInputStateChanged", objectId).apply {
+            putString("state", state)
+        })
+    }
+
+    fun videoInputActualConfigChanged(
+        objectId: Int,
+        size: Size,
+        fps: Int,
+    ) {
+        emit(base("videoInputActualConfigChanged", objectId).apply {
+            putMap("size", size.toWritableMap())
+            putInt("fps", fps)
+        })
+    }
+
+    fun videoInputError(
+        objectId: Int,
+        code: Int,
+        message: String?,
+    ) {
+        emit(base("videoInputError", objectId).apply {
+            putInt("code", TiRtcReactNativeErrors.normalizeAndroid(code))
+            putString("message", message)
+        })
+    }
+
+    private fun base(
+        type: String,
+        objectId: Int,
+    ): WritableMap {
+        return Arguments.createMap().apply {
+            putString("type", type)
+            putInt("objectId", objectId)
+            putInt("generation", registry.generation(objectId) ?: 0)
+        }
+    }
+
+    private fun ByteArray.toWritableArray(): WritableArray {
+        return Arguments.createArray().apply {
+            for (byte in this@toWritableArray) {
+                pushInt(byte.toInt() and 0xff)
+            }
+        }
+    }
+
+    private fun Size.toWritableMap(): WritableMap {
+        return Arguments.createMap().apply {
+            putInt("width", width)
+            putInt("height", height)
+        }
+    }
+}

package/android/src/main/java/com/tange/ai/tirtc/reactnative/TiRtcReactNativeMaps.kt

@@ -0,0 +1,49 @@
+package com.tange.ai.tirtc.reactnative
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableMap
+
+internal fun createResult(
+    code: Int,
+    objectId: Int,
+    generation: Int,
+    message: String? = null,
+): WritableMap {
+    return Arguments.createMap().apply {
+        putInt("code", code)
+        putInt("objectId", objectId)
+        putInt("generation", generation)
+        putString("message", message)
+    }
+}
+
+internal fun stateResult(
+    code: Int,
+    state: String?,
+): WritableMap {
+    return Arguments.createMap().apply {
+        putInt("code", code)
+        putString("state", state)
+    }
+}
+
+internal fun sizeResult(
+    code: Int,
+    width: Int?,
+    height: Int?,
+): WritableMap {
+    return Arguments.createMap().apply {
+        putInt("code", code)
+        if (width == null || height == null) {
+            putNull("size")
+        } else {
+            putMap(
+                "size",
+                Arguments.createMap().apply {
+                    putInt("width", width)
+                    putInt("height", height)
+                },
+            )
+        }
+    }
+}

package/android/src/main/java/com/tange/ai/tirtc/reactnative/TiRtcReactNativeMetricsMaps.kt

@@ -0,0 +1,173 @@
+package com.tange.ai.tirtc.reactnative
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableMap
+import com.tange.ai.tirtc.TiRtcAudioOutputDebugSnapshotResult
+import com.tange.ai.tirtc.TiRtcAudioOutputMetricsResult
+import com.tange.ai.tirtc.TiRtcConnMetricsResult
+import com.tange.ai.tirtc.TiRtcOutputStartupMetrics
+import com.tange.ai.tirtc.TiRtcOutputStutterMetrics
+import com.tange.ai.tirtc.TiRtcVideoOutputDebugSnapshotResult
+import com.tange.ai.tirtc.TiRtcVideoOutputMetricsResult
+
+internal fun audioMetricsResult(result: TiRtcAudioOutputMetricsResult): WritableMap =
+    snapshotResult(result.code, result.snapshot?.let { snapshot ->
+        Arguments.createMap().apply {
+            putMap("startup", startup(snapshot.startup))
+            putMap("stutter", stutter(snapshot.stutter))
+            putDouble("estimatedOutputLatencyMs", snapshot.estimatedOutputLatencyMs.toDouble())
+            putNullableString("audioCodec", audioCodec(snapshot.audioCodec))
+            putInt("audioSampleRateHz", snapshot.audioSampleRateHz)
+            putInt("audioChannels", snapshot.audioChannels)
+            putDouble("audioInputBitrateKbps", snapshot.audioInputBitrateKbps)
+            putDouble("audioInputPacketRate", snapshot.audioInputPacketRate)
+            putDouble("audioRenderCallbackRate", snapshot.audioRenderCallbackRate)
+            putDouble("statsRefreshIntervalMs", snapshot.statsRefreshIntervalMs.toDouble())
+            putDouble("statsUpdatedAtMonotonicMs", snapshot.statsUpdatedAtMs.toDouble())
+        }
+    })
+
+internal fun videoMetricsResult(result: TiRtcVideoOutputMetricsResult): WritableMap =
+    snapshotResult(result.code, result.snapshot?.let { snapshot ->
+        Arguments.createMap().apply {
+            putMap("startup", startup(snapshot.startup))
+            putMap("stutter", stutter(snapshot.stutter))
+            putDouble("estimatedOutputLatencyMs", snapshot.estimatedOutputLatencyMs.toDouble())
+            putNullableString("videoCodec", videoCodec(snapshot.videoCodec))
+            putInt("videoWidth", snapshot.videoWidth)
+            putInt("videoHeight", snapshot.videoHeight)
+            putString("decoderBackend", decoderBackend(snapshot.decoderBackend))
+            putDouble("videoInputBitrateKbps", snapshot.videoInputBitrateKbps)
+            putDouble("videoInputFps", snapshot.videoInputFps)
+            putDouble("videoDecodedFps", snapshot.videoDecodedFps)
+            putDouble("videoRenderFps", snapshot.videoRenderFps)
+            putDouble("statsRefreshIntervalMs", snapshot.statsRefreshIntervalMs.toDouble())
+            putDouble("statsUpdatedAtMonotonicMs", snapshot.statsUpdatedAtMs.toDouble())
+        }
+    })
+
+internal fun connMetricsResult(result: TiRtcConnMetricsResult): WritableMap =
+    snapshotResult(result.code, result.snapshot?.let { snapshot ->
+        Arguments.createMap().apply {
+            putBoolean("hasConnectStart", snapshot.hasConnectStart)
+            putBoolean("hasConnected", snapshot.hasConnected)
+            putDouble("connectStartMonotonicMs", snapshot.connectStartMonotonicMs.toDouble())
+            putDouble("connectedMonotonicMs", snapshot.connectedMonotonicMs.toDouble())
+            putBoolean("isReady", snapshot.isReady)
+            snapshot.connectDurationMs?.let { putDouble("connectDurationMs", it.toDouble()) } ?: putNull("connectDurationMs")
+        }
+    })
+
+internal fun audioDebugResult(result: TiRtcAudioOutputDebugSnapshotResult): WritableMap =
+    snapshotResult(result.code, result.snapshot?.let { snapshot ->
+        Arguments.createMap().apply {
+            putNullableString("codec", audioCodec(snapshot.codec))
+            putInt("sampleRateHz", snapshot.sampleRate)
+            putInt("channels", snapshot.channels)
+        }
+    })
+
+internal fun videoDebugResult(result: TiRtcVideoOutputDebugSnapshotResult): WritableMap =
+    snapshotResult(result.code, result.snapshot?.let { snapshot ->
+        Arguments.createMap().apply {
+            putNullableString("codec", videoCodec(snapshot.codec))
+            putString("bitstreamFormat", bitstreamFormat(snapshot.bitstreamFormat))
+            putInt("width", snapshot.width)
+            putInt("height", snapshot.height)
+            putString("decoderPreference", decoderPreference(snapshot.decoderPreference))
+            putString("resolvedDecoderBackend", decoderBackend(snapshot.resolvedDecoderBackend))
+        }
+    })
+
+internal fun releasedSnapshotResult(): WritableMap =
+    snapshotResult(TiRtcReactNativeErrors.OBJECT_RELEASED, null)
+
+private fun snapshotResult(
+    code: Int,
+    snapshot: WritableMap?,
+): WritableMap =
+    Arguments.createMap().apply {
+        putInt("code", TiRtcReactNativeErrors.normalizeAndroid(code))
+        if (snapshot == null) {
+            putNull("snapshot")
+        } else {
+            putMap("snapshot", snapshot)
+        }
+    }
+
+private fun startup(metrics: TiRtcOutputStartupMetrics): WritableMap =
+    Arguments.createMap().apply {
+        putBoolean("hasConnectStart", metrics.hasConnectStart)
+        putBoolean("hasConnected", metrics.hasConnected)
+        putBoolean("hasFirstPacket", metrics.hasFirstPacket)
+        putBoolean("hasFirstOutput", metrics.hasFirstOutput)
+        putDouble("connectStartMonotonicMs", metrics.connectStartMonotonicMs.toDouble())
+        putDouble("connectedMonotonicMs", metrics.connectedMonotonicMs.toDouble())
+        putDouble("firstPacketMonotonicMs", metrics.firstPacketMonotonicMs.toDouble())
+        putDouble("firstOutputMonotonicMs", metrics.firstOutputMonotonicMs.toDouble())
+        putDouble("firstPacketAfterConnectedMs", metrics.firstPacketAfterConnectedMs.toDouble())
+        putDouble("firstOutputAfterConnectedMs", metrics.firstOutputAfterConnectedMs.toDouble())
+        putDouble("timeToFirstOutputMs", metrics.timeToFirstOutputMs.toDouble())
+    }
+
+private fun stutter(metrics: TiRtcOutputStutterMetrics): WritableMap =
+    Arguments.createMap().apply {
+        putDouble("stutterThresholdMs", metrics.stutterThresholdMs.toDouble())
+        putDouble("outputDurationMs", metrics.outputDurationMs.toDouble())
+        putDouble("stutterTotalMs", metrics.stutterTotalMs.toDouble())
+        putDouble("stutterCount", metrics.stutterCount.toDouble())
+        putDouble("stutterPeakMs", metrics.stutterPeakMs.toDouble())
+        putDouble("stutterAverageMs", metrics.stutterAverageMs.toDouble())
+        putDouble("stutterRatePercent", metrics.stutterRate)
+    }
+
+private fun WritableMap.putNullableString(
+    name: String,
+    value: String?,
+) {
+    if (value == null) {
+        putNull(name)
+    } else {
+        putString(name, value)
+    }
+}
+
+private fun audioCodec(codec: Int): String? =
+    when (codec) {
+        1 -> "g711a"
+        2 -> "aac"
+        3 -> "pcm"
+        4 -> "opus"
+        5 -> "amr"
+        else -> null
+    }
+
+private fun videoCodec(codec: Int): String? =
+    when (codec) {
+        65 -> "h264"
+        66 -> "h265"
+        67 -> "mjpeg"
+        else -> null
+    }
+
+private fun decoderBackend(backend: Int): String =
+    when (backend) {
+        1 -> "software"
+        2 -> "hardware"
+        else -> "unknown"
+    }
+
+private fun decoderPreference(preference: Int): String =
+    when (preference) {
+        1 -> "software"
+        2 -> "hardware"
+        else -> "auto"
+    }
+
+private fun bitstreamFormat(format: Int): String =
+    when (format) {
+        1 -> "h264AnnexB"
+        2 -> "h265AnnexB"
+        3 -> "mjpegJfif"
+        else -> "unknown"
+    }

package/android/src/main/java/com/tange/ai/tirtc/reactnative/TiRtcReactNativeModuleSupport.kt

@@ -0,0 +1,91 @@
+package com.tange.ai.tirtc.reactnative
+
+import android.os.Handler
+import android.os.Looper
+import android.util.Log
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.WritableMap
+import com.tange.ai.tirtc.TiRtcLogging
+import java.util.concurrent.atomic.AtomicBoolean
+
+private const val LOG_UPLOAD_TIMEOUT_MS = 30_000L
+
+internal fun uploadLogsToPromise(
+    promise: Promise,
+    tag: String,
+) {
+    Log.i(tag, "uploadLogs start")
+    val settled = AtomicBoolean(false)
+    val timeoutHandler = Handler(Looper.getMainLooper())
+    val timeout =
+        Runnable {
+            if (settled.compareAndSet(false, true)) {
+                Log.w(tag, "uploadLogs timeout")
+                promise.resolve(
+                    Arguments.createMap().apply {
+                        putInt("code", TiRtcReactNativeErrors.PLATFORM_INTERNAL)
+                        putNull("logId")
+                    },
+                )
+            }
+        }
+    timeoutHandler.postDelayed(timeout, LOG_UPLOAD_TIMEOUT_MS)
+    val startCode = TiRtcLogging.upload { code, logId ->
+        if (!settled.compareAndSet(false, true)) {
+            return@upload
+        }
+        timeoutHandler.removeCallbacks(timeout)
+        Log.i(tag, "uploadLogs completed code=$code logIdPresent=${!logId.isNullOrEmpty()}")
+        promise.resolve(
+            Arguments.createMap().apply {
+                putInt("code", TiRtcReactNativeErrors.normalizeAndroid(code))
+                putString("logId", logId)
+            },
+        )
+    }
+    if (startCode != 0) {
+        if (!settled.compareAndSet(false, true)) {
+            return
+        }
+        timeoutHandler.removeCallbacks(timeout)
+        Log.w(tag, "uploadLogs failed_to_start code=$startCode")
+        promise.resolve(
+            Arguments.createMap().apply {
+                putInt("code", TiRtcReactNativeErrors.normalizeAndroid(startCode))
+                putNull("logId")
+            },
+        )
+    }
+}
+
+internal fun registerReactNativeObject(
+    registry: TiRtcReactNativeRegistry,
+    factory: () -> Any,
+    onRegistered: ((
+        TiRtcReactNativeRegistry.Entry,
+        Any,
+    ) -> Unit)? = null,
+): WritableMap {
+    return try {
+        val value = factory()
+        val entry = registry.add(value)
+        onRegistered?.invoke(entry, value)
+        createResult(TiRtcReactNativeErrors.OK, entry.id, entry.generation)
+    } catch (error: Throwable) {
+        createResult(extractNativeCreateCode(error.message), 0, 0, error.message)
+    }
+}
+
+internal fun Int?.normalized(): Double =
+    TiRtcReactNativeErrors.normalizeAndroid(this ?: TiRtcReactNativeErrors.OBJECT_RELEASED).toDouble()
+
+internal fun ReadableArray.toByteArray(): ByteArray {
+    return ByteArray(size()) { index -> getInt(index).toByte() }
+}
+
+private fun extractNativeCreateCode(message: String?): Int {
+    val code = Regex("code=(\\d+)").find(message ?: "")?.groupValues?.getOrNull(1)?.toIntOrNull()
+    return TiRtcReactNativeErrors.normalizeAndroid(code ?: TiRtcReactNativeErrors.PLATFORM_INTERNAL)
+}

package/android/src/main/java/com/tange/ai/tirtc/reactnative/TiRtcReactNativeOptions.kt

@@ -0,0 +1,127 @@
+package com.tange.ai.tirtc.reactnative
+
+import com.facebook.react.bridge.ReadableMap
+import com.tange.ai.tirtc.TiRtcAudioAecMode
+import com.tange.ai.tirtc.TiRtcAudioAgcLevel
+import com.tange.ai.tirtc.TiRtcAudioAnsLevel
+import com.tange.ai.tirtc.TiRtcAudioChannelCount
+import com.tange.ai.tirtc.TiRtcAudioCodec
+import com.tange.ai.tirtc.TiRtcAudioInputOptions
+import com.tange.ai.tirtc.TiRtcAudioOutputOptions
+import com.tange.ai.tirtc.TiRtcAudioSampleRate
+import com.tange.ai.tirtc.TiRtcCameraFacing
+import com.tange.ai.tirtc.TiRtcOutputBufferStrategy
+import com.tange.ai.tirtc.TiRtcVideoDecoderPreference
+import com.tange.ai.tirtc.TiRtcVideoEncoderCodec
+import com.tange.ai.tirtc.TiRtcVideoFrameRate
+import com.tange.ai.tirtc.TiRtcVideoInputOptions
+import com.tange.ai.tirtc.TiRtcVideoOutputOptions
+
+internal fun audioOutputOptions(options: ReadableMap): TiRtcAudioOutputOptions {
+    return TiRtcAudioOutputOptions(
+        agcLevel = audioAgcLevel(options.getString("agcLevel")),
+        ansLevel = audioAnsLevel(options.getString("ansLevel")),
+        bufferStrategy = outputBufferStrategy(options),
+        maxBufferWatermarkMs = nullableInt(options, "maxBufferWatermarkMs"),
+    )
+}
+
+internal fun videoOutputOptions(options: ReadableMap): TiRtcVideoOutputOptions {
+    return TiRtcVideoOutputOptions(
+        decoderPreference = videoDecoderPreference(options.getString("decoderPreference")),
+        bufferStrategy = outputBufferStrategy(options),
+        maxBufferWatermarkMs = nullableInt(options, "maxBufferWatermarkMs"),
+    )
+}
+
+internal fun audioInputOptions(options: ReadableMap): TiRtcAudioInputOptions {
+    return TiRtcAudioInputOptions(
+        codec =
+            when (options.getString("codec")) {
+                "aac" -> TiRtcAudioCodec.AAC
+                "pcm" -> TiRtcAudioCodec.PCM
+                "opus" -> TiRtcAudioCodec.OPUS
+                "amr" -> TiRtcAudioCodec.AMR
+                else -> TiRtcAudioCodec.G711A
+            },
+        sampleRate =
+            if (options.getString("sampleRate") == "rate8k") {
+                TiRtcAudioSampleRate.RATE_8K
+            } else {
+                TiRtcAudioSampleRate.RATE_16K
+            },
+        channels = TiRtcAudioChannelCount.MONO,
+        aecMode =
+            if (options.getString("aecMode") == "enabled") {
+                TiRtcAudioAecMode.ENABLED
+            } else {
+                TiRtcAudioAecMode.DISABLED
+            },
+        agcLevel = audioAgcLevel(options.getString("agcLevel")),
+        ansLevel = audioAnsLevel(options.getString("ansLevel")),
+    )
+}
+
+internal fun videoInputOptions(options: ReadableMap): TiRtcVideoInputOptions {
+    return TiRtcVideoInputOptions(
+        codec =
+            when (options.getString("codec")) {
+                "mjpeg" -> TiRtcVideoEncoderCodec.MJPEG
+                else -> TiRtcVideoEncoderCodec.H264
+            },
+        width = options.getInt("width"),
+        height = options.getInt("height"),
+        frameRate =
+            when (options.getString("frameRate")) {
+                "fps10" -> TiRtcVideoFrameRate.FPS_10
+                "fps30" -> TiRtcVideoFrameRate.FPS_30
+                else -> TiRtcVideoFrameRate.FPS_15
+            },
+        bitrateKbps = options.getInt("bitrateKbps"),
+        cameraFacing =
+            if (options.getString("cameraFacing") == "back") {
+                TiRtcCameraFacing.BACK
+            } else {
+                TiRtcCameraFacing.FRONT
+            },
+    )
+}
+
+private fun audioAgcLevel(value: String?): TiRtcAudioAgcLevel {
+    return when (value) {
+        "low" -> TiRtcAudioAgcLevel.LOW
+        "medium" -> TiRtcAudioAgcLevel.MEDIUM
+        "high" -> TiRtcAudioAgcLevel.HIGH
+        else -> TiRtcAudioAgcLevel.DISABLED
+    }
+}
+
+private fun audioAnsLevel(value: String?): TiRtcAudioAnsLevel {
+    return when (value) {
+        "low" -> TiRtcAudioAnsLevel.LOW
+        "medium" -> TiRtcAudioAnsLevel.MEDIUM
+        "high" -> TiRtcAudioAnsLevel.HIGH
+        else -> TiRtcAudioAnsLevel.DISABLED
+    }
+}
+
+private fun videoDecoderPreference(value: String?): TiRtcVideoDecoderPreference {
+    return when (value) {
+        "software" -> TiRtcVideoDecoderPreference.SOFTWARE
+        "hardware" -> TiRtcVideoDecoderPreference.HARDWARE
+        else -> TiRtcVideoDecoderPreference.AUTO
+    }
+}
+
+private fun outputBufferStrategy(options: ReadableMap): TiRtcOutputBufferStrategy {
+    return if (options.getString("bufferStrategy") == "noBuffer") {
+        TiRtcOutputBufferStrategy.NO_BUFFER
+    } else {
+        TiRtcOutputBufferStrategy.AUTOMATIC
+    }
+}
+
+private fun nullableInt(
+    options: ReadableMap,
+    key: String,
+): Int? = if (options.isNull(key)) null else options.getInt(key)

package/android/src/main/java/com/tange/ai/tirtc/reactnative/TiRtcReactNativeRegistry.kt

@@ -0,0 +1,71 @@
+package com.tange.ai.tirtc.reactnative
+
+import com.tange.ai.tirtc.TiRtcAudioInput
+import com.tange.ai.tirtc.TiRtcAudioOutput
+import com.tange.ai.tirtc.TiRtcConn
+import com.tange.ai.tirtc.TiRtcVideoInput
+import com.tange.ai.tirtc.TiRtcVideoOutput
+import java.util.concurrent.ConcurrentHashMap
+import java.util.concurrent.atomic.AtomicInteger
+
+internal object TiRtcReactNativeRegistry {
+    private val nextId = AtomicInteger(1)
+    private val nextGeneration = AtomicInteger(1)
+    private val entries = ConcurrentHashMap<Int, Entry>()
+    @Volatile private var events: TiRtcReactNativeEventSink? = null
+
+    data class Entry(
+        val id: Int,
+        val generation: Int,
+        val value: Any,
+    )
+
+    fun add(value: Any): Entry {
+        val id = nextId.getAndIncrement()
+        val generation = nextGeneration.getAndIncrement()
+        val entry = Entry(id, generation, value)
+        entries[id] = entry
+        return entry
+    }
+
+    fun bindEventSink(eventSink: TiRtcReactNativeEventSink) {
+        events = eventSink
+    }
+
+    fun release(id: Int) {
+        entries.remove(id)
+    }
+
+    fun generation(id: Int): Int? = entries[id]?.generation
+
+    fun conn(id: Int): TiRtcConn? = entries[id]?.value as? TiRtcConn
+
+    fun audioOutput(id: Int): TiRtcAudioOutput? = entries[id]?.value as? TiRtcAudioOutput
+
+    fun videoOutput(id: Int): TiRtcVideoOutput? = entries[id]?.value as? TiRtcVideoOutput
+
+    fun audioInput(id: Int): TiRtcAudioInput? = entries[id]?.value as? TiRtcAudioInput
+
+    fun videoInput(id: Int): TiRtcVideoInput? = entries[id]?.value as? TiRtcVideoInput
+
+    fun reportVideoOutputError(
+        id: Int,
+        code: Int,
+    ) {
+        if (entries.containsKey(id)) {
+            events?.videoOutputError(id, code)
+        }
+    }
+
+    fun reportVideoInputError(
+        id: Int,
+        code: Int,
+        message: String?,
+    ) {
+        if (entries.containsKey(id)) {
+            events?.videoInputError(id, code, message)
+        }
+    }
+
+    fun hasLiveObjects(): Boolean = entries.isNotEmpty()
+}