ApsaraVideo Live:Implement a voice chat room on iOS

1. Request permissions

Check camera and microphone permissions before starting a call. The SDK checks permissions automatically, but requesting them early ensures a smooth user experience.

func checkMicrophonePermission(completion: @escaping (Bool) -> Void) {
    let status = AVCaptureDevice.authorizationStatus(for: .audio)

    switch status {
    case .notDetermined:
        AVCaptureDevice.requestAccess(for: .audio) { granted in
            completion(granted)
        }
    case .authorized:
        completion(true)
    default:
        completion(false)
    }
}

func checkCameraPermission(completion: @escaping (Bool) -> Void) {
    let status = AVCaptureDevice.authorizationStatus(for: .video)

    switch status {
    case .notDetermined:
        AVCaptureDevice.requestAccess(for: .video) { granted in
            completion(granted)
        }
    case .authorized:
        completion(true)
    default:
        completion(false)
    }
}

// Usage example
checkMicrophonePermission { granted in
    if granted {
        print("Microphone access granted.")
    } else {
        print("Microphone access denied.")
    }
}

checkCameraPermission { granted in
    if granted {
        print("Camera access granted.")
    } else {
        print("Camera access denied.")
    }
}

2. Get an authentication token

Joining an ARTC channel requires an authentication token that verifies the user's identity. A token can be generated using a single-parameter method or a multi-parameter method. The method determines which joinChannel API to call. For details on token generation, see Implement token-based authentication.

Production environments

Generate the token on your server and send it to the client. Hardcoding the AppKey on the client side poses a security risk.

Development and debugging

If your server does not yet generate tokens, temporarily use the token generation logic from the APIExample. The reference code follows:

class ARTCTokenHelper: NSObject {

    /**
    * RTC AppId
    */
    public static let AppId = "<RTC AppId>"

    /**
    * RTC AppKey
    */
    public static let AppKey = "<RTC AppKey>"

    /**
    * Generate a multi-parameter token for joining a channel based on channelId, userId, and timestamp.
    */
    public func generateAuthInfoToken(appId: String = ARTCTokenHelper.AppId, appKey: String =  ARTCTokenHelper.AppKey, channelId: String, userId: String, timestamp: Int64) -> String {
        let stringBuilder = appId + appKey + channelId + userId + "\(timestamp)"
        let token = ARTCTokenHelper.GetSHA256(stringBuilder)
        return token
    }

    /**
    * Generate a single-parameter token for joining a channel based on channelId, userId, and nonce.
    */
    public func generateJoinToken(appId: String = ARTCTokenHelper.AppId, appKey: String =  ARTCTokenHelper.AppKey, channelId: String, userId: String, timestamp: Int64, nonce: String = "") -> String {
        let token = self.generateAuthInfoToken(appId: appId, appKey: appKey, channelId: channelId, userId: userId, timestamp: timestamp)

        let tokenJson: [String: Any] = [
            "appid": appId,
            "channelid": channelId,
            "userid": userId,
            "nonce": nonce,
            "timestamp": timestamp,
            "token": token
        ]

        if let jsonData = try? JSONSerialization.data(withJSONObject: tokenJson, options: []),
        let base64Token = jsonData.base64EncodedString() as String? {
            return base64Token
        }

        return ""
    }

    /**
    * Sign a string using SHA256.
    * String signing (SHA256)
    */
    private static func GetSHA256(_ input: String) -> String {
        // Convert input string to data.
        let data = Data(input.utf8)

        // Create a buffer to store the hash result.
        var hash = [UInt8](repeating: 0, count: Int(CC_SHA256_DIGEST_LENGTH))

        // Calculate the SHA-256 hash.
        data.withUnsafeBytes {
            _ = CC_SHA256($0.baseAddress, CC_LONG(data.count), &hash)
        }

        // Convert the hash to a hexadecimal string.
        return hash.map { String(format: "%02hhx", $0) }.joined()
    }

}

3. Create and initialize the engine

Create the RTC engine

Call sharedInstance to create an RTC engine object.

private var rtcEngine: AliRtcEngine? = nil

// Create the engine and set the callback.
let engine = AliRtcEngine.sharedInstance(self, extras:nil)
self.rtcEngine = engine

Initialize the engine

Configure the channel profile, user role, and audio settings:

// Set the channel profile to interactive live streaming. AliRtcInteractivelive is used for all RTC scenarios.
engine.setChannelProfile(AliRtcChannelProfile.interactivelive)
// Set the role.
if self.isAnchor {
    // For streamer mode, which requires publishing audio and video streams, set the role to AliRtcClientRoleInteractive.
    engine.setClientRole(AliRtcClientRole.roleInteractive)
}
else {
    // For viewer mode, which does not require publishing audio and video streams, set the role to AliRtcClientRolelive.
    engine.setClientRole(AliRtcClientRole.rolelive)
}

// Set the audio profile. By default, high-quality mode (AliRtcEngineHighQualityMode) and music mode (AliRtcSceneMusicMode) are used.
engine.setAudioProfile(AliRtcAudioProfile.engineHighQualityMode, audio_scene: AliRtcAudioScenario.sceneMusicMode)

4. Configure publishing and subscription

By default, the SDK automatically publishes and subscribes to audio and video streams in the channel.

• After the role is set to viewer, the publishLocalAudioStream method becomes invalid.

• The following configuration applies to both streamers and viewers.

// Set the audio profile. By default, high-quality mode (AliRtcEngineHighQualityMode) and music mode (AliRtcAudioScenario.sceneMusicMode) are used.
engine.setAudioProfile(AliRtcAudioProfile.engineHighQualityMode, audio_scene: AliRtcAudioScenario.sceneMusicMode)

// For a voice chat scenario, you do not need to publish a video stream.
engine.publishLocalVideoStream(false)

// Set the default subscription to remote audio streams.
engine.setDefaultSubscribeAllRemoteAudioStreams(true)
engine.subscribeAllRemoteAudioStreams(true)

5. Join a channel

Call joinChannel to join a channel and start the audio-only interaction.

self.rtcEngine?.joinChannel(joinToken, channelId: nil, userId: nil, name: nil)

6. End the interaction

Leave the channel and destroy the engine to release resources:

1. Call leaveChannel to leave the channel.

2. Call destroy to destroy the engine and release resources.

self.rtcEngine?.leaveChannel()
AliRtcEngine.destroy()
self.rtcEngine = nil

7. (Optional) Switch between viewer and streamer roles

Call setClientRole to switch a viewer to streamer (to publish streams) or a streamer back to viewer (to stop publishing).

// Switch to the streamer role.
self.rtcEngine?.setClientRole(AliRtcClientRole.roleInteractive)

// Switch to the viewer role.
self.rtcEngine?.setClientRole(AliRtcClientRole.rolelive)