iOS

import TXLiteAVSDK_TRTC

class TRTCManager: NSObject {
    // Obtain TRTCCloud singleton
    let trtcCloud = TRTCCloud.sharedInstance()

    override init() {
        super.init()
        // Set event callback delegate
        trtcCloud.delegate = self
    }
}

func enterRoom(sdkAppId: UInt32, roomId: UInt32, userId: String, userSig: String) {
    // Configure room parameters
    let params = TRTCParams()
    params.sdkAppId = sdkAppId
    params.roomId = roomId
    params.userId = userId
    params.userSig = userSig
    params.role = .anchor  // Anchor role can publish streams

    // Enter room and specify scene
    // .videoCall - video call scene
    // .audioCall - audio call scene
    // .LIVE - live streaming scene
    // .voiceChatRoom - voice chat room scene
    trtcCloud.enterRoom(params, appScene: .LIVE)
}

extension TRTCManager: TRTCCloudDelegate {
    // Room entry result callback
    // result > 0: Success (milliseconds)
    // result < 0: Failure (error code)
    func onEnterRoom(_ result: Int) {
        if result > 0 {
            print("Entered room successfully, time: \(result)ms")
        } else {
            print("Failed to enter room, error code: \(result)")
        }
    }

    // Room exit callback
    // reason: 0 - voluntary exit, 1 - kicked out, 2 - room dismissed
    func onExitRoom(_ reason: Int) {
        print("Exited room, reason: \(reason)")
    }

    // Error callback
    func onError(_ errCode: TXLiteAVError, errMsg: String?, extInfo: [AnyHashable: Any]?) {
        print("Error: \(errCode.rawValue) - \(errMsg ?? "")")
    }

    // Remote user entered room
    func onRemoteUserEnterRoom(_ userId: String) {
        print("Remote user entered: \(userId)")
    }

    // Remote user left room
    func onRemoteUserLeaveRoom(_ userId: String, reason: Int) {
        print("Remote user left: \(userId), reason: \(reason)")
    }

    // Remote user video availability changed
    func onUserVideoAvailable(_ userId: String, available: Bool) {
        print("User \(userId) video available: \(available)")
    }

    // Remote user audio availability changed
    func onUserAudioAvailable(_ userId: String, available: Bool) {
        print("User \(userId) audio available: \(available)")
    }
}

// MARK: - Local Video

func startLocalVideo(view: UIView, frontCamera: Bool = true) {
    // Set local preview rendering parameters (optional, SDK provides defaults)
    let renderParams = TRTCRenderParams()
    renderParams.fillMode = .fill      // .fill (fill) or .fit (fit)
    renderParams.mirrorType = .auto    // .auto (front camera), .enable (always mirror), .disable (no mirror)
    trtcCloud.setLocalRenderParams(renderParams)

    // Start local video preview
    // frontCamera: true = front camera, false = rear camera
    trtcCloud.startLocalPreview(frontCamera, view: view)
}

func stopLocalVideo() {
    trtcCloud.stopLocalPreview()
}

func muteLocalVideo(_ mute: Bool) {
    trtcCloud.muteLocalVideo(.big, mute: mute)
}

func switchCamera(_ frontCamera: Bool) {
    trtcCloud.getDeviceManager().switchCamera(frontCamera)
}

// MARK: - Local Audio

func startLocalAudio(quality: TRTCAudioQuality = .default) {
    // quality options:
    // .speech - speech mode
    // .default - default mode
    // .music - music mode
    trtcCloud.startLocalAudio(quality)
}

func stopLocalAudio() {
    trtcCloud.stopLocalAudio()
}

func muteLocalAudio(_ mute: Bool) {
    trtcCloud.muteLocalAudio(mute)
}

extension TRTCManager: TRTCCloudDelegate {
    // Remote user video availability changed
    func onUserVideoAvailable(_ userId: String, available: Bool) {
        if available {
            // Subscribe to remote user's video stream
            // streamType: .big (main), .small (small), .sub (screen sharing)
            trtcCloud.startRemoteView(userId, streamType: .big, view: remoteVideoView)
        } else {
            // Stop subscription if video becomes unavailable
            trtcCloud.stopRemoteView(userId, streamType: .big)
        }
    }

    // Remote user audio availability changed
    func onUserAudioAvailable(_ userId: String, available: Bool) {
        if available {
            // Audio auto-plays, use mute control as needed
            trtcCloud.muteRemoteAudio(userId, mute: false)
        }
    }
}

// Manual control methods
func muteRemoteAudio(userId: String, mute: Bool) {
    trtcCloud.muteRemoteAudio(userId, mute: mute)
}

func muteAllRemoteAudio(_ mute: Bool) {
    trtcCloud.muteAllRemoteAudio(mute)

func exitRoom() {
    // Stop local preview and audio first
    trtcCloud.stopLocalPreview()
    trtcCloud.stopLocalAudio()

    // Leave the room
    trtcCloud.exitRoom()
}

extension TRTCManager: TRTCCloudDelegate {
    func onExitRoom(_ reason: Int) {
        // reason: 0 - called exitRoom(), 1 - kicked by server, 2 - room dismissed
        switch reason {
        case 0:
            print("Exited room normally")
        case 1:
            print("Kicked by server")
        case 2:
            print("Room dismissed")
        default:
            break
        }
    }
}

class TRTCManager: NSObject {
    deinit {
        // Destroy instance after use
        TRTCCloud.destroySharedInstance()
    }
}