tirtc-react-native 2.2.0

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

@@ -0,0 +1,482 @@
+package com.tange.ai.tirtc.reactnative
+
+import android.util.Log
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.module.annotations.ReactModule
+import com.tange.ai.tirtc.TiRtc
+import com.tange.ai.tirtc.TiRtcAudioInput
+import com.tange.ai.tirtc.TiRtcAudioOutput
+import com.tange.ai.tirtc.TiRtcConn
+import com.tange.ai.tirtc.TiRtcInitOptions
+import com.tange.ai.tirtc.TiRtcVideoInput
+import com.tange.ai.tirtc.TiRtcVideoOutput
+
+@ReactModule(name = TiRtcModule.NAME)
+class TiRtcModule(
+    private val reactContext: ReactApplicationContext,
+) : NativeTiRtcSpec(reactContext) {
+    private val registry = TiRtcReactNativeRegistry
+    private val events =
+        TiRtcReactNativeEventSink(registry) { event ->
+            reactContext.runOnJSQueueThread {
+                emitOnTiRtcEvent(event)
+            }
+        }
+    private val eventBinder = TiRtcReactNativeEventBinder(events)
+
+    init {
+        registry.bindEventSink(events)
+    }
+
+    override fun getName(): String = NAME
+
+    @ReactMethod
+    override fun initialize(
+        options: ReadableMap,
+        promise: Promise,
+    ) {
+        val code =
+            TiRtc.initialize(
+                reactContext,
+                TiRtcInitOptions(
+                    appId = options.getString("appId") ?: "",
+                    endpoint = options.getString("endpoint") ?: "",
+                    consoleLogEnabled = options.getBoolean("consoleLogEnabled"),
+                ),
+            )
+        promise.resolve(TiRtcReactNativeErrors.normalizeAndroid(code))
+    }
+
+    override fun shutdown(): Double {
+        if (registry.hasLiveObjects()) {
+            return TiRtcReactNativeErrors.RUNTIME_OBJECTS_LIVE.toDouble()
+        }
+        return TiRtcReactNativeErrors.normalizeAndroid(TiRtc.shutdown()).toDouble()
+    }
+
+    override fun errorToString(code: Double): String = TiRtc.errorToString(code.toInt())
+
+    override fun writeLog(
+        level: Double,
+        tag: String,
+        message: String,
+    ) {
+        when (level.toInt()) {
+            0 -> com.tange.ai.tirtc.TiRtcLogging.d(tag, message)
+            1 -> com.tange.ai.tirtc.TiRtcLogging.i(tag, message)
+            2 -> com.tange.ai.tirtc.TiRtcLogging.w(tag, message)
+            3 -> com.tange.ai.tirtc.TiRtcLogging.e(tag, message)
+        }
+    }
+
+    @ReactMethod
+    override fun uploadLogs(promise: Promise) {
+        uploadLogsToPromise(promise, TAG)
+    }
+
+    override fun createConn(): WritableMap =
+        registerReactNativeObject(
+            registry,
+            factory = { TiRtcConn() },
+            onRegistered = { entry, value -> eventBinder.wireConn(entry.id, value as TiRtcConn) },
+        )
+
+    override fun connGetState(id: Double): WritableMap {
+        val conn = registry.conn(id.toInt()) ?: return stateResult(TiRtcReactNativeErrors.OBJECT_RELEASED, null)
+        return stateResult(TiRtcReactNativeErrors.OK, conn.state.name.lowercase())
+    }
+
+    override fun connConnect(
+        id: Double,
+        remoteId: String,
+        token: String,
+    ): Double {
+        val objectId = id.toInt()
+        val code = registry.conn(objectId)?.connect(remoteId, token).normalized()
+        Log.i(
+            TAG,
+            "connConnect objectId=$objectId remoteIdPresent=${remoteId.isNotEmpty()} tokenPresent=${token.isNotEmpty()} code=${code.toInt()}",
+        )
+        return code
+    }
+
+    override fun connDisconnect(id: Double): Double {
+        val objectId = id.toInt()
+        val code = registry.conn(objectId)?.disconnect().normalized()
+        Log.i(TAG, "connDisconnect objectId=$objectId code=${code.toInt()}")
+        return code
+    }
+
+    override fun connSendCommand(
+        id: Double,
+        commandId: Double,
+        data: ReadableArray,
+    ): Double = registry.conn(id.toInt())?.sendCommand(commandId.toLong(), data.toByteArray()).normalized()
+
+    override fun connSendStreamMessage(
+        id: Double,
+        streamId: Double,
+        timestampMs: Double,
+        data: ReadableArray,
+    ): Double =
+        registry.conn(id.toInt())
+            ?.sendStreamMessage(streamId.toInt(), timestampMs.toLong(), data.toByteArray())
+            .normalized()
+
+    override fun connSubscribeVideo(id: Double, streamId: Double): Double =
+        registry.conn(id.toInt())?.subscribeVideo(streamId.toInt()).normalized()
+
+    override fun connUnsubscribeVideo(id: Double, streamId: Double): Double =
+        registry.conn(id.toInt())?.unsubscribeVideo(streamId.toInt()).normalized()
+
+    override fun connSubscribeAudio(id: Double, streamId: Double): Double =
+        registry.conn(id.toInt())?.subscribeAudio(streamId.toInt()).normalized()
+
+    override fun connUnsubscribeAudio(id: Double, streamId: Double): Double =
+        registry.conn(id.toInt())?.unsubscribeAudio(streamId.toInt()).normalized()
+
+    override fun connRequestKeyFrame(id: Double, streamId: Double): Double =
+        registry.conn(id.toInt())?.requestKeyFrame(streamId.toInt()).normalized()
+
+    override fun connGetMetricsSnapshot(id: Double): WritableMap {
+        val conn = registry.conn(id.toInt()) ?: return releasedSnapshotResult()
+        return connMetricsResult(conn.getMetricsSnapshot())
+    }
+
+    override fun connDispose(id: Double): Double {
+        val objectId = id.toInt()
+        val code = registry.conn(objectId)?.dispose().normalized()
+        if (code.toInt() == TiRtcReactNativeErrors.OK) {
+            registry.release(objectId)
+        }
+        return code
+    }
+
+    override fun createAudioOutput(): WritableMap =
+        registerReactNativeObject(
+            registry,
+            factory = { TiRtcAudioOutput() },
+            onRegistered = { entry, value -> eventBinder.wireAudioOutput(entry.id, value as TiRtcAudioOutput) },
+        )
+
+    override fun audioOutputGetState(id: Double): WritableMap {
+        val output = registry.audioOutput(id.toInt()) ?: return stateResult(TiRtcReactNativeErrors.OBJECT_RELEASED, null)
+        return stateResult(0, output.state.name.lowercase())
+    }
+
+    override fun audioOutputConfigure(id: Double, options: ReadableMap): Double {
+        return registry.audioOutput(id.toInt())
+            ?.configure(audioOutputOptions(options))
+            .normalized()
+    }
+
+    override fun audioOutputSetVolume(id: Double, volumePercent: Double): Double {
+        if (!volumePercent.isFinite() ||
+            volumePercent != volumePercent.toInt().toDouble() ||
+            volumePercent < 0.0 ||
+            volumePercent > 100.0
+        ) {
+            return TiRtcReactNativeErrors.INVALID_ARGUMENT.toDouble()
+        }
+        return registry.audioOutput(id.toInt())?.setVolume(volumePercent.toInt()).normalized()
+    }
+
+    override fun audioOutputAttach(id: Double, connId: Double, streamId: Double): Double {
+        val conn = registry.conn(connId.toInt()) ?: return TiRtcReactNativeErrors.OBJECT_RELEASED.toDouble()
+        return registry.audioOutput(id.toInt())?.attach(conn, streamId.toInt()).normalized()
+    }
+
+    override fun audioOutputDetach(id: Double): Double = registry.audioOutput(id.toInt())?.detach().normalized()
+
+    override fun audioOutputGetMetricsSnapshot(id: Double): WritableMap {
+        val output = registry.audioOutput(id.toInt()) ?: return releasedSnapshotResult()
+        return audioMetricsResult(output.getMetricsSnapshot())
+    }
+
+    override fun audioOutputResetMetricsSession(id: Double): Double =
+        registry.audioOutput(id.toInt())?.resetMetricsSession().normalized()
+
+    override fun audioOutputGetDebugSnapshot(id: Double): WritableMap {
+        val output = registry.audioOutput(id.toInt()) ?: return releasedSnapshotResult()
+        return audioDebugResult(output.getDebugSnapshot())
+    }
+
+    override fun audioOutputDispose(id: Double): Double {
+        val objectId = id.toInt()
+        val code = registry.audioOutput(objectId)?.dispose().normalized()
+        if (code.toInt() == TiRtcReactNativeErrors.OK) {
+            registry.release(objectId)
+        }
+        return code
+    }
+
+    override fun createVideoOutput(): WritableMap =
+        registerReactNativeObject(
+            registry,
+            factory = { TiRtcVideoOutput() },
+            onRegistered = { entry, value -> eventBinder.wireVideoOutput(entry.id, value as TiRtcVideoOutput) },
+        )
+
+    override fun videoOutputGetState(id: Double): WritableMap {
+        val output = registry.videoOutput(id.toInt()) ?: return stateResult(TiRtcReactNativeErrors.OBJECT_RELEASED, null)
+        return stateResult(0, output.state.name.lowercase())
+    }
+
+    override fun videoOutputGetRenderSize(id: Double): WritableMap {
+        val output = registry.videoOutput(id.toInt()) ?: return sizeResult(TiRtcReactNativeErrors.OBJECT_RELEASED, null, null)
+        val size = output.renderSize
+        return sizeResult(0, size?.width, size?.height)
+    }
+
+    override fun videoOutputSetOptions(id: Double, options: ReadableMap): Double {
+        return registry.videoOutput(id.toInt())
+            ?.setOptions(videoOutputOptions(options))
+            .normalized()
+    }
+
+    override fun videoOutputAttach(id: Double, connId: Double, streamId: Double): Double {
+        val conn = registry.conn(connId.toInt()) ?: return TiRtcReactNativeErrors.OBJECT_RELEASED.toDouble()
+        return registry.videoOutput(id.toInt())?.attach(conn, streamId.toInt()).normalized()
+    }
+
+    override fun videoOutputDetach(id: Double): Double = registry.videoOutput(id.toInt())?.detach().normalized()
+
+    override fun videoOutputGetMetricsSnapshot(id: Double): WritableMap {
+        val output = registry.videoOutput(id.toInt()) ?: return releasedSnapshotResult()
+        return videoMetricsResult(output.getMetricsSnapshot())
+    }
+
+    override fun videoOutputResetMetricsSession(id: Double): Double =
+        registry.videoOutput(id.toInt())?.resetMetricsSession().normalized()
+
+    override fun videoOutputGetDebugSnapshot(id: Double): WritableMap {
+        val output = registry.videoOutput(id.toInt()) ?: return releasedSnapshotResult()
+        return videoDebugResult(output.getDebugSnapshot())
+    }
+
+    override fun videoOutputDispose(id: Double): Double {
+        val objectId = id.toInt()
+        val code = registry.videoOutput(objectId)?.dispose().normalized()
+        if (code.toInt() == TiRtcReactNativeErrors.OK) {
+            registry.release(objectId)
+        }
+        return code
+    }
+
+    override fun createAudioInput(): WritableMap =
+        registerReactNativeObject(
+            registry,
+            factory = { TiRtcAudioInput() },
+            onRegistered = { entry, value -> eventBinder.wireAudioInput(entry.id, value as TiRtcAudioInput) },
+        )
+
+    override fun audioInputGetState(id: Double): WritableMap {
+        val input = registry.audioInput(id.toInt()) ?: return stateResult(TiRtcReactNativeErrors.OBJECT_RELEASED, null)
+        return stateResult(0, input.state.name.lowercase())
+    }
+
+    @ReactMethod
+    override fun audioInputSetOptions(
+        id: Double,
+        options: ReadableMap,
+        promise: Promise,
+    ) {
+        promise.resolve(
+            registry.audioInput(id.toInt())
+                ?.setOptions(audioInputOptions(options))
+                .normalized(),
+        )
+    }
+
+    @ReactMethod
+    override fun audioInputAttach(
+        id: Double,
+        connId: Double,
+        streamId: Double,
+        promise: Promise,
+    ) {
+        val conn = registry.conn(connId.toInt())
+        val code =
+            if (conn == null) {
+                TiRtcReactNativeErrors.OBJECT_RELEASED
+            } else {
+                TiRtcReactNativeErrors.normalizeAndroid(
+                    registry.audioInput(id.toInt())?.attach(conn, streamId.toInt())
+                        ?: TiRtcReactNativeErrors.OBJECT_RELEASED,
+                )
+            }
+        Log.i(TAG, "audioInputAttach objectId=${id.toInt()} connId=${connId.toInt()} streamId=${streamId.toInt()} code=$code")
+        promise.resolve(code.toDouble())
+    }
+
+    @ReactMethod
+    override fun audioInputStart(
+        id: Double,
+        promise: Promise,
+    ) {
+        val code =
+            TiRtcReactNativeErrors.normalizeAndroid(
+                registry.audioInput(id.toInt())?.start()
+                    ?: TiRtcReactNativeErrors.OBJECT_RELEASED,
+            )
+        Log.i(TAG, "audioInputStart objectId=${id.toInt()} code=$code")
+        promise.resolve(code.toDouble())
+    }
+
+    @ReactMethod
+    override fun audioInputStop(
+        id: Double,
+        promise: Promise,
+    ) {
+        promise.resolve(registry.audioInput(id.toInt())?.stop().normalized())
+    }
+
+    @ReactMethod
+    override fun audioInputDetach(
+        id: Double,
+        connId: Double,
+        promise: Promise,
+    ) {
+        val conn = registry.conn(connId.toInt())
+        promise.resolve(
+            if (conn == null) {
+                TiRtcReactNativeErrors.OBJECT_RELEASED.toDouble()
+            } else {
+                registry.audioInput(id.toInt())?.detach(conn).normalized()
+            },
+        )
+    }
+
+    @ReactMethod
+    override fun audioInputDispose(
+        id: Double,
+        promise: Promise,
+    ) {
+        val objectId = id.toInt()
+        val code = registry.audioInput(objectId)?.dispose().normalized()
+        if (code.toInt() == TiRtcReactNativeErrors.OK) {
+            registry.release(objectId)
+        }
+        promise.resolve(code)
+    }
+
+    override fun createVideoInput(): WritableMap =
+        registerReactNativeObject(
+            registry,
+            factory = { TiRtcVideoInput() },
+            onRegistered = { entry, value -> eventBinder.wireVideoInput(entry.id, value as TiRtcVideoInput) },
+        )
+
+    override fun videoInputGetState(id: Double): WritableMap {
+        val input = registry.videoInput(id.toInt()) ?: return stateResult(TiRtcReactNativeErrors.OBJECT_RELEASED, null)
+        return stateResult(0, input.state.name.lowercase())
+    }
+
+    override fun videoInputGetActualConfig(id: Double): WritableMap {
+        val input = registry.videoInput(id.toInt()) ?: return sizeResult(TiRtcReactNativeErrors.OBJECT_RELEASED, null, null)
+        val size = input.outputSize
+        return sizeResult(0, size?.width, size?.height).apply {
+            val fps = input.outputFps
+            if (fps == null) {
+                putNull("fps")
+            } else {
+                putInt("fps", fps)
+            }
+        }
+    }
+
+    @ReactMethod
+    override fun videoInputSetOptions(
+        id: Double,
+        options: ReadableMap,
+        promise: Promise,
+    ) {
+        promise.resolve(
+            registry.videoInput(id.toInt())
+                ?.setOptions(videoInputOptions(options))
+                .normalized(),
+        )
+    }
+
+    @ReactMethod
+    override fun videoInputAttach(
+        id: Double,
+        connId: Double,
+        streamId: Double,
+        promise: Promise,
+    ) {
+        val conn = registry.conn(connId.toInt())
+        val code =
+            if (conn == null) {
+                TiRtcReactNativeErrors.OBJECT_RELEASED
+            } else {
+                TiRtcReactNativeErrors.normalizeAndroid(
+                    registry.videoInput(id.toInt())?.attach(conn, streamId.toInt())
+                        ?: TiRtcReactNativeErrors.OBJECT_RELEASED,
+                )
+            }
+        Log.i(TAG, "videoInputAttach objectId=${id.toInt()} connId=${connId.toInt()} streamId=${streamId.toInt()} code=$code")
+        promise.resolve(code.toDouble())
+    }
+
+    @ReactMethod
+    override fun videoInputStart(
+        id: Double,
+        promise: Promise,
+    ) {
+        val code =
+            TiRtcReactNativeErrors.normalizeAndroid(
+                registry.videoInput(id.toInt())?.start()
+                    ?: TiRtcReactNativeErrors.OBJECT_RELEASED,
+            )
+        Log.i(TAG, "videoInputStart objectId=${id.toInt()} code=$code")
+        promise.resolve(code.toDouble())
+    }
+
+    @ReactMethod
+    override fun videoInputStop(
+        id: Double,
+        promise: Promise,
+    ) {
+        promise.resolve(registry.videoInput(id.toInt())?.stop().normalized())
+    }
+
+    @ReactMethod
+    override fun videoInputDetach(
+        id: Double,
+        connId: Double,
+        promise: Promise,
+    ) {
+        val conn = registry.conn(connId.toInt())
+        promise.resolve(
+            if (conn == null) {
+                TiRtcReactNativeErrors.OBJECT_RELEASED.toDouble()
+            } else {
+                registry.videoInput(id.toInt())?.detach(conn).normalized()
+            },
+        )
+    }
+
+    @ReactMethod
+    override fun videoInputDispose(
+        id: Double,
+        promise: Promise,
+    ) {
+        val objectId = id.toInt()
+        val code = registry.videoInput(objectId)?.dispose().normalized()
+        if (code.toInt() == TiRtcReactNativeErrors.OK) {
+            registry.release(objectId)
+        }
+        promise.resolve(code)
+    }
+
+    companion object {
+        const val NAME = "TiRtc"
+        private const val TAG = "TiRtcReactNative"
+    }
+}

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

@@ -0,0 +1,43 @@
+package com.tange.ai.tirtc.reactnative
+
+import com.facebook.react.TurboReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfo
+import com.facebook.react.module.model.ReactModuleInfoProvider
+import com.facebook.react.uimanager.ViewManager
+
+class TiRtcPackage : TurboReactPackage() {
+    override fun getModule(
+        name: String,
+        reactContext: ReactApplicationContext,
+    ): NativeModule? {
+        return if (name == TiRtcModule.NAME) TiRtcModule(reactContext) else null
+    }
+
+    override fun getReactModuleInfoProvider(): ReactModuleInfoProvider {
+        return ReactModuleInfoProvider {
+            mapOf(
+                TiRtcModule.NAME to
+                    ReactModuleInfo(
+                        TiRtcModule.NAME,
+                        TiRtcModule.NAME,
+                        false,
+                        false,
+                        true,
+                        false,
+                        true,
+                    ),
+            )
+        }
+    }
+
+    override fun createViewManagers(
+        reactContext: ReactApplicationContext,
+    ): MutableList<ViewManager<*, *>> {
+        return mutableListOf(
+            TiRtcVideoOutputViewManager(),
+            TiRtcVideoInputPreviewManager(),
+        )
+    }
+}

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

@@ -0,0 +1,32 @@
+package com.tange.ai.tirtc.reactnative
+
+internal object TiRtcReactNativeErrors {
+    const val OK = 0
+    const val INVALID_ARGUMENT = 6000
+    const val OBJECT_RELEASED = 1008
+    const val PLATFORM_INTERNAL = 1001
+    const val RUNTIME_OBJECTS_LIVE = 1007
+
+    fun normalizeAndroid(code: Int): Int {
+        return when (code) {
+            1002 -> INVALID_ARGUMENT
+            1004 -> 1005
+            1005 -> RUNTIME_OBJECTS_LIVE
+            1006 -> OBJECT_RELEASED
+            1007 -> 1010
+            1008 -> 6026
+            1009 -> 6027
+            1010 -> 6028
+            1011 -> 6029
+            1012 -> 1016
+            1013 -> 6024
+            1014 -> 1201
+            1015 -> 1202
+            1016 -> 1203
+            1017 -> 1204
+            1018 -> 1205
+            1019 -> 6034
+            else -> code
+        }
+    }
+}

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

@@ -0,0 +1,99 @@
+package com.tange.ai.tirtc.reactnative
+
+import android.util.Log
+import com.tange.ai.tirtc.TiRtcAudioInput
+import com.tange.ai.tirtc.TiRtcAudioOutput
+import com.tange.ai.tirtc.TiRtcAudioOutputErrorListener
+import com.tange.ai.tirtc.TiRtcAudioOutputStateListener
+import com.tange.ai.tirtc.TiRtcConn
+import com.tange.ai.tirtc.TiRtcConnCommandListener
+import com.tange.ai.tirtc.TiRtcConnStateListener
+import com.tange.ai.tirtc.TiRtcConnStreamMessageListener
+import com.tange.ai.tirtc.TiRtcInputErrorListener
+import com.tange.ai.tirtc.TiRtcInputStateListener
+import com.tange.ai.tirtc.TiRtcVideoInput
+import com.tange.ai.tirtc.TiRtcVideoInputActualConfigListener
+import com.tange.ai.tirtc.TiRtcVideoOutput
+import com.tange.ai.tirtc.TiRtcVideoOutputErrorListener
+import com.tange.ai.tirtc.TiRtcVideoOutputRenderSizeListener
+import com.tange.ai.tirtc.TiRtcVideoOutputStateListener
+
+internal class TiRtcReactNativeEventBinder(
+    private val events: TiRtcReactNativeEventSink,
+) {
+    fun wireConn(
+        id: Int,
+        conn: TiRtcConn,
+    ) {
+        conn.onStateChanged = TiRtcConnStateListener { state, errorCode ->
+            Log.i(TAG, "connStateChanged objectId=$id state=${state.name.lowercase()} code=$errorCode")
+            events.connStateChanged(id, state.name.lowercase(), errorCode)
+        }
+        conn.onCommand = TiRtcConnCommandListener { command, data ->
+            events.connCommand(id, command, data)
+        }
+        conn.onStreamMessage = TiRtcConnStreamMessageListener { streamId, timestampMs, data ->
+            events.connStreamMessage(id, streamId, timestampMs, data)
+        }
+    }
+
+    fun wireAudioOutput(
+        id: Int,
+        output: TiRtcAudioOutput,
+    ) {
+        output.onStateChanged = TiRtcAudioOutputStateListener { state ->
+            events.audioOutputStateChanged(id, state.name.lowercase())
+        }
+        output.onError = TiRtcAudioOutputErrorListener { code ->
+            events.audioOutputError(id, code)
+        }
+    }
+
+    fun wireVideoOutput(
+        id: Int,
+        output: TiRtcVideoOutput,
+    ) {
+        output.onStateChanged = TiRtcVideoOutputStateListener { state ->
+            events.videoOutputStateChanged(id, state.name.lowercase())
+        }
+        output.onRenderSizeChanged = TiRtcVideoOutputRenderSizeListener { size ->
+            events.videoOutputRenderSizeChanged(id, size)
+        }
+        output.onError = TiRtcVideoOutputErrorListener { code ->
+            events.videoOutputError(id, code)
+        }
+    }
+
+    fun wireAudioInput(
+        id: Int,
+        input: TiRtcAudioInput,
+    ) {
+        input.onStateChanged = TiRtcInputStateListener { state ->
+            Log.i(TAG, "audioInputStateChanged objectId=$id state=${state.name.lowercase()}")
+            events.audioInputStateChanged(id, state.name.lowercase())
+        }
+        input.onError = TiRtcInputErrorListener { code, message ->
+            events.audioInputError(id, code, message)
+        }
+    }
+
+    fun wireVideoInput(
+        id: Int,
+        input: TiRtcVideoInput,
+    ) {
+        input.onStateChanged = TiRtcInputStateListener { state ->
+            Log.i(TAG, "videoInputStateChanged objectId=$id state=${state.name.lowercase()}")
+            events.videoInputStateChanged(id, state.name.lowercase())
+        }
+        input.onActualConfigChanged = TiRtcVideoInputActualConfigListener { size, fps ->
+            events.videoInputActualConfigChanged(id, size, fps)
+        }
+        input.onError = TiRtcInputErrorListener { code, message ->
+            events.videoInputError(id, code, message)
+        }
+    }
+
+    private companion object {
+        const val TAG = "TiRtcReactNative"
+    }
+}