快速开始

private lateinit var rtcEngine: RTCEngine

fun initRtcSdk(application: Application) {
    rtcEngine = RTCEngine.create(
        app = application,
        enableLocalLog = true,
        engineEvent = object : RTCEngineSimpleEvent() {
            override fun onError(channelId: String?, errorCode: Int, message: String?) {
                // 统一记录或展示 Engine 错误
            }
        },
        localLogPath = null,
        version = "app: ${BuildConfig.VERSION_NAME}"
    )
    rtcEngine.initSDK()
}

private val clientEvent = object : RTCClientSimpleEvent() {
    override fun onJoinSucceed(channel: String, uid: String, whiteBoard: String?) {
        // 真正入会成功；可在这里更新 UI 或开始发布
    }

    override fun onJoinFailed(channel: String?, statusCode: Int) {
        // 入会失败；statusCode 见错误码文档
    }

    override fun onRemoteUserJoin(channel: String, uid: String) {
        // 维护本频道成员列表
    }

    override fun onStreamTrackAdd(
        uid: String,
        channel: String,
        trackId: String,
        trackDesc: String
    ) {
        subscribeRemoteVideo(uid, trackId, trackDesc)
    }

    override fun onDisconnected(
        channel: String,
        leaveReason: LeaveReason,
        statusCode: Int,
        message: String
    ) {
        // 本频道发生不可恢复断连
    }
}

rtcEngine.setRtcMediaEvent(object : RTCMediaSimpleEvent() {
    override fun onMediaConnected(channel: String) {
        // 默认频道的流媒体服务器连接成功
    }

    override fun onVolumesReport(
        channel: String,
        volumes: MutableMap<UserTrackDesc, VolumeInfo>
    ) {
        // 频道音量信息，可用于说话人高亮
    }
})

private var defaultChannel: RTCChannel? = null

fun joinChannel(activity: Activity, token: String) {
    defaultChannel = rtcEngine.join(
        activity = activity,
        token = token,
        clientEvent = clientEvent,
        options = JoinOptions(
            autoSubscribeAudio = true,
            autoSubscribeVideo = false
        )
    )

    if (defaultChannel == null) {
        // 请求在创建频道会话前被拒绝；具体原因仍通过 onJoinFailed 返回
    }
}

private lateinit var cameraTrack: LocalCameraTrack

fun startCamera(previewView: VcsPlayerGlTextureView) {
    cameraTrack = rtcEngine.getLocalCameraTrack(PreOptionCamera._720P)
    cameraTrack.addPlayView(previewView)
    cameraTrack.startCapture(object : RTCResultListener {
        override fun onSuccess() {
            rtcEngine.publishLocalVideo(
                track = cameraTrack,
                publishCustomOpt = PublishCustomOptions(
                    desc = TrackDesc.TRACK_MAIN.value,
                    props = null,
                    simulcasts = null
                ),
                listener = null
            )
        }

        override fun onFail(code: Int) {
            // 例如未授予 CAMERA 权限
        }
    })
}

private lateinit var micTrack: LocalMicTrack

fun startMicrophone() {
    micTrack = rtcEngine.getLocalMicTrack(PreOptionMic.def)
    micTrack.startCapture(object : RTCResultListener {
        override fun onSuccess() {
            rtcEngine.publishLocalAudio(
                track = micTrack,
                publishCustomOpt = PublishCustomOptions(
                    desc = TrackDesc.TRACK_AUDIO.value,
                    props = null,
                    simulcasts = null
                ),
                listener = null
            )
        }

        override fun onFail(code: Int) {
            // 例如未授予 RECORD_AUDIO 权限或麦克风打开失败
        }
    })
}

val screenTrack = rtcEngine.getLocalScreenTrack(this, PreOptionScreen.def)

screenTrack.setEvent(object : RTCScreenStateEvent {
    override fun onScreenCaptureStateChanged(state: ScreenCaptureState, args: String?) {
        when (state) {
            ScreenCaptureState.START -> Unit // 屏幕采集已经建立
            ScreenCaptureState.STOP -> Unit  // 屏幕采集已经停止
            ScreenCaptureState.ERROR -> Unit // args 中包含错误信息
        }
    }
})

screenTrack.request { granted, intent ->
    if (granted && intent != null) {
        screenTrack.startCapture(intent, object : RTCResultListener {
            override fun onSuccess() {
                // 这里只表示 SDK 已接纳启动操作，真实状态由 RTCScreenStateEvent 通知
                rtcEngine.publishLocalVideo(
                    track = screenTrack,
                    publishCustomOpt = PublishCustomOptions(
                        desc = TrackDesc.TRACK_SHARE.value,
                        props = null,
                        simulcasts = null
                    ),
                    listener = null
                )
            }

            override fun onFail(code: Int) {
                // 例如重复启动或当前生命周期状态不允许启动
            }
        })
    }
}

private fun subscribeRemoteVideo(uid: String, trackId: String, trackDesc: String) {
    val remoteTrack = rtcEngine.getRemoteVideoTrack(uid, trackDesc)
    remoteTrack?.addPlayView(remoteView)

    rtcEngine.subscribeRemoteTrack(
        uid = uid,
        trackId = trackId,
        preferTrackIds = null,
        result = object : RTCResultListener {
            override fun onSuccess() = Unit
            override fun onFail(code: Int) {
                // 订阅失败
            }
        }
    )
}

// 放在前面的 clientEvent 实现中
override fun onStreamTrackRemove(uid: String, channel: String, trackInfo: TrackInfo) {
    rtcEngine.unSubscribeRemoteTrack(uid, trackInfo.id)
    rtcEngine.getRemoteVideoTrack(uid, trackInfo.desc)?.removePlayView(remoteView)
}

// 先从默认频道停止发布
rtcEngine.unPublishLocalAudio(micTrack, null)
rtcEngine.unPublishLocalVideo(cameraTrack, null)

// 再关闭共享采集设备
micTrack.stopCapture()
cameraTrack.stopCapture()

// 离开默认频道；也可调用 defaultChannel?.leave()
rtcEngine.leave()

// 应用不再使用 RTC 时释放 Engine
rtcEngine.releaseSDK()