SendBirdCall

The app id of your SendBirdCalls application. Configure the app id using configure(appId:). This is get-only property.

SendBirdCall.appId    // "Optional(YOUR_APP_ID)"

Initiate SendBirdCall instance when a client app is launched. If another initialization with another APP_ID takes place, all existing data will be deleted and the SendBirdCall instance will be initialized with the new APP_ID.

SendBirdCall.configure(appId: "YOUR_APP_ID")

• Tag: configure(appId)

SendBirdCalls SDK Version

self.versionLabel.text = "SendBirdCalls v\(SendBirdCall.sdkVersion)"

// "SendBirdCalls v1.0.0"

Provides a view that allows user to change the system audio route. Returns AVRoutePickerView in iOS 11 or later and MPVolumeView in earlier iOS version.

let routePickerView = SendBirdCall.routePickerView(frame: frame)
self.parentView.addSubView(routePickerView)

• Customization

if #available(iOS 11.0, *) {
   guard let routePickerView = routePickerView as? AVRoutePickerView else { return }
   // Set up AVRoutePickerView
} else {
   guard let routePickerView = routePickerView as? MPVolumeView else { return }
   // Set up MPVolumeView
}

• Tag: routePickerView(frame)

Specifies the queue that you want to use for callbacks and delegate methods

Registers a device-specific SendBirdCallDelegateevent handler. Responding to device-wide events (e.g. incoming calls) is then managed as shown below:

SendBirdCall.addDelegate(self, identifier: UNIQUE_HANDLER_ID)

func didStartRinging(_ call: DirectCall) {
    call.delegate = self
}

Removes delegate for the given identifier.

Removes all delegate for SendBirdCall events.

Adds a SendBirdRecordingDelegate to the SDK which is invoked when a recording session is finished successfully.

SendBirdCall.addRecordingDelegate(self, identifier: UNIQUE_HANDLER_ID)

func didSaveRecording(call: DirectCall, recordingId: String, options: RecordingOptions, outputURL: URL) {
   // Handle successful recording
}

func didFailToSaveRecording(call: DirectCall, recordingId: String, error: SBCError) {
   // Handle failed recording
}

Removes a SendBirdRecordingDelegate that has the specified identifier from the SDK.

Removes all SendBirdRecordingDelegates from the SDK.

Returns call for call ID.

Returns call for a given UUID.

Returns number of ongoing calls.

Returns all ongoing calls, including the active call and all calls on hold.

Returns the currently authenticated user.

Authenticates user with user ID and access token that you generated at SendBird Dashboard. In order to make and receive calls, authenticate the user with SendBird server with the the SendBirdCall.authenticate()method.

let params = AuthenticateParams(userId: userId, accessToken: accessToken)

SendBirdCall.authenticate(with: params) { user, error in
    guard let user = user, error == nil else {
        return
    }
}

• Tag: authenticate(with,completionHandler)

Deauthenticates user. To stop receiving calls after deauthentication, you should unregister according push tokens by calling unregisterVoIPPush and unregisterRemotePush before deauthenticating.

SendBirdCall.unregisterVoIPPush(token: myVoIPPushToken) { error in // Unregister push tokens to stop receiving push notifications on deauhtenticated devices. Unregistering push tokens must be done before deauthenticating.
   // Handle unregister push token

   SendBirdCall.deauthenticate { error in
       guard error == nil else {
           // handle error
           return
       }
   )
}

Makes a call to user(callee) directly. (1:1 Call). Use the CallOptions object to choose initial call configuration (e.g. muted/unmuted)

 let params = DialParams(calleeId: CALLEE_ID, callOptions: CallOptions())

 let directCall = SendBirdCall.dial(with: params) { directCall, error in
     //
 }

 directCall.delegate = self

• Tag: dial(with,completionHandler)

Sets timeout value for the timeout period before unanswered ringing or dialing calls expires and ends. Its default value is 60 seconds.

SendBirdCall.setRingingTimeout(30)

Sets timeout value for the timeout period before the call is connected. Default value is 60 seconds.

SendBirdCall.setCallConnectingTimeout(30)

Handles incoming VoIP push with SendBirdCalls payload. Incoming calls are received either via the application’s persistent internal server connection, or (if the application is in the background) via PushKit. PushKit messages received by the SendBirdCall instance MUST be delivered to the SDK.

class MyClass: PKPushRegistryDelegate {
    func pushRegistry(_ registry: PKPushRegistry, didReceiveIncomingPushWith payload: PKPushPayload, for type: PKPushType, completion: @escaping () -> Void) {
        SendBirdCall.pushRegistry(registry, didReceiveIncomingPushWith: payload, for: type) { uuid in

            // IMPORTANT: You MUST report incoming call to CallKit when you receive a pushkit push.
            let provider = CXProvider(configuration: CXProviderConfiguration)
            let update = CXCallUpdate()
            update.remoteHandle = CXHandle(type: .generic, value: HANDLE_VALUE)
            provider.reportNewIncomingCall(with: uuid, update: update) { error in
                completion()
            })
        }
    }
}

To receive native-like calls while an app is in the background or closed, a device registration token must be registered to the server. Register a device push token during authentication by either providing it as a parameter in the SendBirdCall.authenticate() method, or after authentication has completed using the SendBirdCall.registerVoIPPushToken() method.

// PKPushRegistryDelegate
class AppDelegate: PKPushRegistryDelegate {
    func voipRegistration() {
        self.voipRegistry = PKPushRegistry(queue: DispatchQueue.main)
        self.voipRegistry?.delegate = self
        self.voipRegistry?.desiredPushTypes = [.voIP]
    }

    ...
    func pushRegistry(_ registry: PKPushRegistry, didUpdate pushCredentials: PKPushCredentials, for type: PKPushType) {
        SendBirdCall.registerVoIPPush(token: pushCredentials.token) { (error) in
            guard let error = error else {
                return
            }
            // The Push Token has been registered successfully
        }
    }
    ...
}

• Tag: registerVoIPPush(token,unique,completionHandler)

Unregisters a VoIP push token of specific device. You will not receive VoIP push notification for a call anymore. If you don’t want to receive a call in all of the devices of the users, call unregisterAllVoIPPushTokens(completionHandler:).

func removeVoIPPushToken() {
    SendBirdCall.unregisterVoIPPush(token: myVoIPPushToken) { error in
    guard error == nil else { return }
    // Unregistered successfully
}

• Tag: unregisterVoIPPush(token,completionHandler)

Unregister all VoIP push token registered to the current user(multi device). You will not receive a call in all of the devices of the users.

func removeAllOfVoIPPushTokens() {
    func unregisterAllVoIPPushTokens(completionHandler: ErrorHandler?) {
        guard error == nil else { return }
        // Unregistered all push tokens successfully
    }
}

To receive remote notifications when the app is in the background or closed, you must deliver the received remote notification to SendBirdCalls SDK.

class AppDelegate {
    func application(_ application: UIApplication, didReceiveRemoteNotification userInfo: [AnyHashable : Any], fetchCompletionHandler completionHandler: @escaping (UIBackgroundFetchResult) -> Void) {
        SendBirdCall.application(application, didReceiveRemoteNotification: userInfo)
    }
}

To receive remote notifications while an app is in the background or closed, a device registration token must be registered to the server. Register a remote push token during by using the SendBirdCall.registerRemotePushToken() method.

func application(_ application: UIApplication, didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data) {
   SendBirdCall.registerRemotePush(token: deviceToken) { error in
       //
   }
}

• Tag: registerRemotePush(token:unique:completionHandler:)

Unregisters a remote push token of specific device. You will not receive remote push notification on the device anymore. If you don’t want to receive remote notifications in all of the devices of the users, call unregisterAllRemotePushTokens(completionHandler:).

• token: Optional Data for the push token that you want to unregister
• completionHandler: ErrorHandler that returns callback with error.

func removeRemotePushToken() {
   SendBirdCall.unregisterRemotePush(token: myRemotePushToken) { error in
       guard error == nil else { return }
       // Unregistered successfully
   }
}

• Tag: unregisterRemotePush(token,completionHandler)

Unregister all remote push token registered to the current user(multi device). You will not receive remote notifications in all of the devices of the users.

func removeAllOfRemotePushTokens() {
    func unregisterAllRemotePushTokens(completionHandler: ErrorHandler?) {
        guard error == nil else { return }
        // Unregistered all remote push tokens successfully
    }
}

Creates a Direct Call Log List Query from given params.

Creates a query for room list with specified parameters.

Updates custom items for a given call Id.

Deletes custom items for a given call Id.

Deletes all custom items for a given call Id.

Called when the audio session is activated outside of the app by iOS.

class AppDelegate: CXProviderDelegate {
    func provider(_ provider: CXProvider, didActivate audioSession: AVAudioSession) {
        SendBirdCall.audioSessionDidActivate(audioSession)
    }
}

// MARK: - Audio Session

Called when the audio session is deactivated outside of the app by iOS.

class AppDelegate: CXProviderDelegate {
    func provider(_ provider: CXProvider, didDeactivate audioSession: AVAudioSession) {
        SendBirdCall.audioSessionDidDeactivate(audioSession)
    }
}

Adds sound used in DirectCall such as ringtone and some sound effects with its file name and bundle.

SendBirdCall.addDirectCallSound("dialing.mp3", forType: .dialing)

Enables / disables dial sound used in DirectCall even when the device is in silent mode. Call this method right after addDirectCallSound(_:forType:).

SendBirdCall.addDirectCallSound("dialing.mp3", forType: .dialing)
SendBirdCall.setDirectCallDialingSoundOnWhenSilentMode(isEnabled: true) // Will play dial direct call sounds in silent mode

Adds sound used in DirectCall such as ringtone and some sound effects with URL. If you use bundle to play sound, addDirectCallSound(_:bundle:forType:) is recommended.

SendBirdCall.addDirectCallSound("dialing.mp3", forType: .dialing)

Removes sound used in DirectCall with SoundType value.

SendBirdCall.removeDirectCallSound(forType: .dialing)

Creates a room for group calls.

SendBirdCall.createRoom { room, error in
   ...
   // Set up delegate to receive events
}

• Tag: createRoom(with:completionHandler:)

Gets a locally-cached room instance by room ID.

Fetches a room instance from Sendbird server.