< Back to Package Overview

Developing conferencing applications

Overview

The CSDK Communications Package API supports three Avaya conferencing platforms with a single API. Each conference platform has a different set of features, which are articulated dynamically to the Application via CSDK capabilities. Building on the Voice and Video call capabilities of the Communications Package, the conferencing service supports the following conference types:

• meetme conferencing - where the conference starts with users dialing into the conference bridge.
• adhoc conference escalation - where the conference starts as one or more calls, and participants and/or modalities are added to a single conference call.

Basic Conference - A multiparty audio call with three or more conference participants with primitive call control. It doesn't require a conference server and can be created on the CM Conferencing platform. Enhanced Conference - multiparty audio-video call, possibly with collaboration, conference participant information and rich conference control. It requires a conference server and can be created on Scopia Conferencing and Avaya Aura Conferencing platforms.

Conference features

A conference supports different features based on its type. To recognize, whether the feature is available or not, you need to check the appropriate capability. List of supported features:

Start a Meetme conference

To join an enhanced conference, make a call to the conference bridge. The CSCallCreationInfo class can be used to set the Conference ID and pass code if the conferencing platform supports prompt suppression.

CSCallService* callService = user.callService;

CSCallCreationInfo *callCreationInfo = [[CSCallCreationInfo alloc] init];
callCreationInfo.conferenceId = conferenceID;
callCreationInfo.conferencePasscode = conferencePasscode;

CSCall* call = [callService createCallWithInfo:callCreationInfo];
call.remoteAddress = callNumber; // set bridge number
[call start];

The conference may provide an audio prompt to input the participant's or moderator's code to join the conference. The user can pass this information by sending DTMFs. To enter digits, call the sendDigit: method on the CSCall object.

[call sendDigit: DTMF_digit];

Conference tracking

To monitor call progress events, you need to use the <CSCallDelegate> interface provided by the CSCall object. <CSCallDelegate> provides the call:didChangeConferenceStatus: callback notification that can be used to recognize whether the call is a conference or not. Add <CSConferenceDelegate> for monitoring conference events when the call becomes a conference.

- (void)call:(CSCall *)call didChangeConferenceStatus:(BOOL)isConference {
    if (isConference) {
        call.conference.delegate = conferenceDelegate;
    }
    ...
}

You can also stop handling conference events, e.g. when the application goes to background:

CSConference* conference = call.conference;
if (conference != nil) {
    conference.delegate = nil;
}

Start an Adhoc conference

Each client will have a default adhoc conference provider, which is defined by the ConferenceFactoryURI. If the ConferenceFactoryURI is not provisioned, then CM Conferencing is used by default. To configure the ConferenceFactoryURL use the conferenceFactoryURL property of the CSConferenceConfiguration object.

CSUserConfiguration* userConfiguration = [[CSUserConfiguration alloc] init];
CSConferenceConfiguration *conferenceConfiguration = 
    userConfiguration.conferenceConfiguration;
conferenceConfiguration.conferenceFactoryURL = conferenceFactoryUrl;

Merge two calls into a conference

To merge calls you need to check the getAddParticipantFromCallCapability: conference capability. If it is allowed, then you can use the addParticipantFromCall:completionHandler: method of the CSConference object to process call merging:

if ([call.conference getAddParticipantFromCallCapability: callToAdd].allowed) {
    void (^completionHandler)(NSError *error) = ^(NSError *error) {
        if (error) {
            NSLog(@"Error when adding call into the conference:\n%ld-%@",
                (long)error.code, error.localizedDescription);
        }
        else {
            NSLog(@"Success adding call into the conference.");
        }
    };

    [targetCall.conference addParticipantFromCall: callToAdd 
                                completionHandler: completionHandler];
}

Remote parties will be also promoted to the conference call and receive the call:didChangeConferenceStatus: notification. If a conference URI is provided and clients call the conference bridge successfully, then an enhanced conference is created.

The participant's <CSCallDelegate> will receive the call:didChangeConferenceStatus: notification for the call.

To merge the conference call with a peer-to-peer call, use the same method.

Add a 3rd participant to an existing call to convert it into a conference

To add a participant to the call, use the addParticipant:completionHandler: method on the CSConference object. Your application can define the completion handler block and use it to obtain the result and to add the participant to the call:

if (call.conference.addParticipantViaDialoutCapability.allowed) {
    void (^completionHandler)(NSError *error) = ^(NSError *error) {
        if (error) {
            NSLog(@"Error when adding participant into the conference:\n%ld-%@",
                (long)error.code, error.localizedDescription);
        }
        else {
            NSLog(@"Success adding participant into the conference.");
        }
    };

    [call.conference addParticipant: participantAddress
                  completionHandler: completionHandler];
}

If the conference URI is provided and clients call the conference bridge successfully, then an enhanced conference is created.

Create a conference by selecting parties

To create a conference for selected parties, you need to create a call, add participants and then start the conference. If the conference URI is provided and clients call the conference bridge successfully, then an enhanced conference will be created.

Leave a conference

To leave the conference, you can just end the call that is associated with the conference:

[call end];

Your <CSCallDelegate> will receive the callDidEnd:reason: callback with CSCallEndReasonEndedLocally reason.

If a basic conference is started and only two participants remain, then the conference becomes a peer-to-peer call for the remaining parties.

An enhanced conference will not deescalate to a peer-to-peer call. The enhanced conference can be maintained with a single conference participant. The enhanced conference may terminate when the moderator leaves the conference.

Terminate Conference

If you are the moderator of an enhanced conference, you can terminate the conference for all parties.

if (call.conference.endConferenceCapability.allowed) {
    void (^completionHandler)(NSError *error) = ^(NSError *error) {
        if (error) {
            NSLog(@"Failed to terminate the conference:\n%ld-%@",
                (long)error.code, error.localizedDescription);
        }
        else {
            NSLog(@"Terminate conference started.");
        }
    };

    [call.conference endConferenceWithCompletionHandler: completionHandler];
}

The call will be ended for the participants and their <CSCallDelegate> will receive the callDidEnd:reason: callback with CSCallEndReasonDisconnectedByConferenceModerator reason for Conferencing 9 platform or CSCallEndReasonCallDisconnected reason for other platforms.

Video in the conference

To get info about a video call, you must complete the following activities Working with Video. The enhanced conference supports video calling. If your client supports video, you can establish a video conference call or add video to the existing audio conference call.

Note: Some devices do not support default video parameters provided by a conference. The user should ask the solution administrator to configure the special conference settings to support video in a conference call.

To check if video is not denied for the conference use the videoAllowed property of the CSConference object. To check if you can deny or allow video for the conference use the updateVideoAllowedCapability capability. To deny or allow video for the conference use the setVideoAllowed:completionHandler: method.

Video layout

You can change the video layout if the conferencing platform supports it. To get the current video layout option, use the videoLayout property of the CSConference object. If it returns CSVideoLayoutNone, then the conference server does not support video layout selection. To check if you are allowed to change the video layout, use the updateVideoLayoutCapability capability. Use the supportedVideoLayouts property to show supported layouts. To set another layout, use the setVideoLayout:completionHandler: method. To show participant names use the setDisplayVideoParticipantNameActive:completionHandler: method. You can check if the names are shown with the use of the participantNameDisplayActive property. To check if you are allowed to hide or show the self video in the layout use the updateVideoSelfSeeCapability capability. Use the setVideoSelfSeeActive:completionHandler: method for hiding or showing. You can check if you see the self video using videoSelfSeeActive property. To check if you are allowed to pin a specific participant's video in a specific position of the current video layout use the videoPinCapability capability. Use the pinVideo:completionHandler: method with required coordinates to change the position.

Roster list

The roster list is used to show information about the conference participants and their current status:

• participant name - displayName property of the CSParticipant
• audio status -- indicates whether the participant is an audio participant - audioActive property of the CSActiveParticipant -- shows participant's audio mute status - audioMutedByServer property of the CSActiveParticipant
• video status -- indicates whether the participant is a video participant - videoActive property of the CSActiveParticipant -- shows participant's video transmission status - videoBlockedByServer property of the CSActiveParticipant
• participant role - moderator, lecturer, and presenter properties of the CSActiveParticipant
• participant supports collaboration - applicationSharingActive property of the CSActiveParticipant
• participant talks - activeTalkers property of the CSConference
• join time - enterDate property of the CSDroppedParticipant
• last spoken time - lastSpokenDate property of the CSActiveParticipant

Initiate a roster list

To understand when the user is able to see the roster you should handle the conferenceCapabilitiesDidChange: conference event of the <CSConferenceDelegate> and check for the CSConference.retrieveParticipantListCapability capability. If it is allowed, you can start initializing the roster view with the current participants:

- (void)conferenceCapabilitiesDidChange:(CSConference *)conference {
    if (conference) {
        if (conference.retrieveParticipantListCapability.allowed) {
            NSArray *participants = 
                [NSArray arrayWithArray: conference.participants];
            ...
        }
    }
}

Handle roster updates

Three types of participants can be shown on the roster list:

• active participants - the participants who are in the conference call.
• dropped participants - the participants who have left the conference.
  -- you can get the enter and leave time from the CSDroppedParticipant object using enterDate and leaveDate properties. -- dopped participant can be reinvited if the CSConference.addParticipantViaDialoutCapability capability is allowed to use the reInviteWithCompletionHandler: method of the CSDroppedParticipant object.
• pending participants - the participants who are waiting to be accepted to join the locked conference. -- pending participant can be denied if the CSConference.denyPendingParticipantCapability capability is allowed to use the denyWithCompletionHandler: method of the CSPendingParticipant object. -- pending participant can be accepted if the CSConference.acceptPendingParticipantCapability is allowed to use the acceptWithCompletionHandler: method of the CSPendingParticipant object.

You need to use the following callbacks of <CSConferenceDelegate> to update the participants:

• active participants - (void)conference:(CSConference*)conference participantsDidChange:(CSDataCollectionChangeType)changeType changedParticipants:(NSArray*)changedParticipants;
• dropped participants - (void)conference:(CSConference*)conference droppedParticipantsDidChange:(CSDataCollectionChangeType)changeType changedParticipants:(NSArray*)changedParticipants;
• pending participants - (void)conference:(CSConference*)conference pendingParticipantsDidChange:(CSDataCollectionChangeType)changeType changedParticipants:(NSArray*)changedParticipants;

You need to update the view in accordance with the changeType value and the list of participants provided by the callback:

• CSDataCollectionChangeTypeCleared - there are no participants, clear participants from the view
• CSDataCollectionChangeTypeAdded - new participants are added and you should add participants provided by the callback to the view
• CSDataCollectionChangeTypeDeleted - participants have left the conference and you should delete the participants provided by the callback from the view
• CSDataCollectionChangeTypeUpdated - participants have an updated status and you should update it in the view

- (void)     conference:(CSConference*)conference
  participantsDidChange:(CSDataCollectionChangeType)changeType
    changedParticipants:(NSArray*)changedParticipants {

    switch (changeType) {
        case CSDataCollectionChangeTypeAdded:
        case CSDataCollectionChangeTypeUpdated:
        case CSDataCollectionChangeTypeDeleted:
            // The changedParticipants is an array of CSActiveParticipant 
            // objects that have changed.
            // Add code to update application UI for added/updated/deleted
            // participants.
            break;
        case CSDataCollectionChangeTypeCleared:
            // Add code to remove all the previous participant information
            // from the UI application.
            break;
    }
}

Participant updates

To monitor active participant's updates, you need to use the <CSActiveParticipantDelegate> protocol. <CSActiveParticipantDelegate> provides notifications about the audio status, video status, participant roles, connection status and collaboration status.

- (void)     conference:(CSConference*)conference
  participantsDidChange:(CSDataCollectionChangeType)changeType
    changedParticipants:(NSArray*)changedParticipants {

    switch (changeType) {
        case CSDataCollectionChangeTypeAdded:
            for (CSActiveParticipant *participant in changedParticipants) {
                participant.delegate = activeParticipantDelegate;
            }
            break;
        ...
    }
}

Talkers

To show who talks, you need to check the activeTalkerCapability capability and if allowed use the activeTalkers property of the CSConference object.

NSArray *activeTalkers = 
    [NSArray arrayWithArray: call.conference.activeTalkers];

You also can get the list of participants who recently talk using the recentTalkers property of the CSConference object.

NSArray *recentTalkers = 
    [NSArray arrayWithArray: call.conference.recentTalkers];

The Talker list may return up to 4 talkers (Conferencing 9). The Talker list is ordered, a descending list by energy (loudest first). The Talker list may be empty (nobody is speaking).

Conference roles

Active participants can have the following roles:

• moderator
• lecturer
• presenter

The moderator has full control of the conference and can assign roles to participants. To become the moderator, a participant needs to join the meeting using the moderator code. To recognize, whether a local participant is the moderator, use the CSConference.moderationCapability capability.

The moderator can assign the moderator role to a participant if the CSActiveParticipant.assignAsModeratorCapability capability is allowed. To assign the moderator role, use the assignAsModeratorWithCompletionHandler: method of the CSActiveParticipant object. If the operation is successful, the activeParticipantDidAssignAsModerator: notification is reported through the <CSActiveParticipantDelegate> associated with the CSActiveParticipant object.

if (activeParticipant.assignAsModeratorCapability.allowed) {
    [activeParticipant
        assignAsModeratorWithCompletionHandler: completionHandler];
}

The role can be unassigned by the moderator using unassignAsModeratorWithCompletionHandler: method of the CSActiveParticipant object. To check if the participant is moderator use moderator BOOL property of CSActiveParticipant object.

The lecturer is a participant who can talk and show video when the lecture mode is enabled. It is a moderator by default. The moderator can assign this role to a participant if the CSActiveParticipant.assignAsLecturerCapability capability is allowed. To assign the lecturer role, use the assignAsLecturerWithCompletionHandler: method of the CSActiveParticipant object. If the operation is successful, the activeParticipantDidAssignAsLecturer: notification is reported through <CSActiveParticipantDelegate> associated with the CSActiveParticipant object.

if (activeParticipant.assignAsLecturerCapability.allowed) {
    [activeParticipant
        assignAsLecturerWithCompletionHandler: completionHandler];
}

The role can be unassigned by the moderator using unassignAsLecturerWithCompletionHandler: method of the CSActiveParticipant object. To check if the participant is lecturer use lecturer BOOL property of CSActiveParticipant object.

The presenter is a participant who can start screen sharing if the conference and the participant support collaboration capability is allowed (Refer to the collaboration article for more information). The role can be assigned by the moderator if the CSActiveParticipant.assignAsPresenterCapability capability is allowed. To assign the presenter role use the assignAsPresenterWithCompletionHandler: method of the CSActiveParticipant. If the operation is successful, the activeParticipantDidAssignAsPresenter: notification is reported through the <CSActiveParticipantDelegate> associated with the CSActiveParticipant object.

if (activeParticipant.assignAsPresenterCapability.allowed) {
    [activeParticipant
        assignAsPresenterWithCompletionHandler: completionHandler];
}

The role can be unassigned by the moderator using unassignAsPresenterWithCompletionHandler: method of the CSActiveParticipant object. To check if the participant is presenter use presenter BOOL property of CSActiveParticipant object.

Note: All users may have the presenter role by default depending on the multiple presenters feature.

Raise Hand

To get the moderator's attention who can unmute and hence allow the participant to speak the local participant, being the presenter, may use the raise hand feature. To check if the raise hand feature is allowed, use the CSConference.raiseHandCapability capability. To raise the hand use the raiseHandWithCompletionHandler: method of the CSConference object. If the operation is successful, the activeParticipantDidRaiseHand: notification is reported through <CSActiveParticipantDelegate> associated with the local user's CSActiveParticipant object. When you don't need the moderator's attention anymore, you can lower the hand. To check if lowing the hand is allowed, use the CSConference.lowerHandCapability capability. To lower the hand, use the lowerHandWithCompletionHandler: method of the CSConference object. If the operation is successful, the activeParticipantDidLowerHand: notification is reported through <CSActiveParticipantDelegate> associated with the local user's CSActiveParticipant object. To check if the participant's hand is raised, use the handRaised BOOL property of CSActiveParticipant object.

Conference Control

Conference control provides an interface for interaction with the conference features allowed for the moderator.

Mute participants

The moderator can mute audio for all participants of the conference. To check if the mute all feature is allowed, use the CSConference.muteAllParticipantsCapability capability. To mute all the participants, use the muteAllParticipantsWithCompletionHandler: method of the CSConference object. All the participants will be muted except for other moderators, lecturers and presenters. If the operation is successful, the activeParticipant:didChangeAudioStatus: notification with the CSParticipantMediaReceiveOnly status is reported to all the muted participants through <CSActiveParticipantDelegate> associated with the CSActiveParticipant object. The moderator can mute audio for a certain participant. To check if muting is allowed for the participant use the muteParticipantAudioCapability capability of the CSActiveParticipant object. To mute a participant, use the muteWithCompletionHandler: method of the CSActiveParticipant object. If the operation is successful, the activeParticipant:didChangeAudioStatus: notification with the CSParticipantMediaReceiveOnly status is reported to the muted participant through <CSActiveParticipantDelegate> associated with the CSActiveParticipant object.

Block participant video

The moderator can block video for a certain participant. To check if blocking is allowed, use the blockParticipantVideoCapability capability of the CSActiveParticipant object. To block video for a participant use the blockVideoWithCompletionHandler: method of the CSActiveParticipant object. If the operation is successful, the activeParticipant:didChangeVideoStatus: notification with the CSParticipantMediaReceiveOnly status is reported to the blocked participant through <CSActiveParticipantDelegate> associated with the CSActiveParticipant object.

Lecture mode

In this mode one of the conference participants is chosen as a lecturer. Other participants are automatically muted. The lecturer sees a continuous presence layout. The participants see the video of the lecturer.

Note: In the lecture mode video of the participants is not muted. The lecturer is able to see video from the parties on the Scopia Conferencing platform, but is unable on the Avaya Aura Conferencing platform.

if (call.conference.updateLectureModeCapability.allowed) {
    void (^completionHandler)(NSError *error) = ^(NSError *error) {
        if (error) {
            NSLog(@"Failed to change conference lecture mode:\n%ld-%@",
                (long)error.code, error.localizedDescription);
        }
        else {
            NSLog(@"Successfully changed conference lecture mode.");
        }
    };

    [call.conference setLectureModeActive: isChecked 
                        completionHandler: completionHandler];
}

The conference delegate provides the conference:didChangeLectureModeStatus: callback notification that can be used to determine if the lecture mode is enabled or disabled.

- (void)        conference:(CSConference*)conference 
didChangeLectureModeStatus:(BOOL)active {
    NSLog(@"%s", @"didChangeLectureModeStatus");
}

Lock conference

The moderator can lock the meeting to prevent additional participants from joining the conference.

if (call.conference.updateLockCapability.allowed) {
    void (^completionHandler)(NSError *error) = ^(NSError *error) {
        if (error) {
            NSLog(@"Lock conference cannot be done:\n%ld-%@",
                (long)error.code, error.localizedDescription);
        }
        else {
            NSLog(@"Lock conference started.");
        }
    };

    [call.conference setLocked: isChecked completionHandler: completionHandler];
}

The conference delegate provides the conference:didChangeLockStatus: callback notification that can be used to determine if the lecture mode is enabled or disabled.

- (void) conference:(CSConference*)conference 
didChangeLockStatus:(BOOL)locked {
    NSLog(@"%s", @"didChangeLockStatus");
}

Recording

The moderator can initiate and stop recording using the UC client or the DTMF command. Once the recording is enabled, a voice announcement is played to participants. Additionally, the link to the recording is generated and is available to the moderator for sharing. The following methods of the CSConference object can be used to control the recording:

The conference delegate provides the conference:didChangeRecordingStatus: notification that can be used to determine when the recording is enabled or disabled. A visual recording indication on the UI can be shown to inform the participants that the session is being recorded.

Continuation

The Continuation setting allows the moderator to determine if the conference may continue when the moderator leaves it. The moderator can enable or disable continuations for a conference. The continuation setting applies to the current conference and does not change the moderator's default continuation setting.

if (call.conference.updateContinuationStatusCapability.allowed) {
    void (^completionHandler)(NSError *error) = ^(NSError *error) {
        if (error) {
            NSLog(@"Continuation cannot be done:\n%ld-%@",
                (long)error.code, error.localizedDescription);
        }
        else {
            NSLog(@"Continuation mode started.");
        }
    };
    [call.conference setContinuationActive: isChecked 
                         completionHandler: completionHandler];
}

The conference delegate provides the conference:didChangeContinuationStatus: notification that can be used to determine when the continuation is enabled or disabled.

Entry/Exit Tones indication

The Entry/Exit tones setting allows the moderator to determine if the conference plays a tone when a participant joins or leaves the conference.

if (call.conference.updateEntryExitToneStatusCapability.allowed) {
    void (^completionHandler)(NSError *error) = ^(NSError *error) {
        if (error) {
            NSLog(@"Play tone cannot be done:\n%ld-%@",
                (long)error.code, error.localizedDescription);
        }
        else {
            NSLog(@"Play tone started.");
        }
    };
    [call.conference setEntryExitToneActive: isChecked 
                          completionHandler: completionHandler];
}

The conference delegate provides the conference:didChangeEntryExitToneStatus: notification that can be used to determine if the play a tone feature is enabled or disabled.

Extend Meeting

The Extend Meeting setting allows the moderator to extend the current meeting end time by the specified number of minutes.

if (call.conference.extendMeetingCapability.allowed) {
    void (^completionHandler)(NSError *error) = ^(NSError *error) {
        if (error) {
            NSLog(@"Extend meeting cannot be done:\n%ld-%@",
                (long)error.code, error.localizedDescription);
        }
        else {
            NSLog(@"Extend started.");
        }
    };
    [call.conference extendMeeting: additionalTimeInMinutes
                 completionHandler: completionHandler];
}

The conference delegate provides the conference:didChangeMeetingEndTime: notification that can be used to determine the end time of the meeting.

Conference Chat

In-conference chat allows conference participants to exchange messages amongst each other without interrupting the speaker. These messages can either be private between selected participants or shared with all conference participants.

Discover if conference chat is supported and initiate chat

To initiate chat you need to check the inConferenceChatCapability conference capability. If it is allowed, you can use the inConferenceChat property of the CSConference object to get the CSChat object. Then you should implement the <CSChatDelegate> protocol, which provides notifications about the chat session status and chat messages.

if (call.conference.inConferenceChatCapability.allowed) {
    CSChat *conferenceChat = call.conference.inConferenceChat;
    conferenceChat.delegate = chatDelegate;
}

In order to identify who sent incoming message and to send private message to specific participant, you need to get list of chat participants. Call method getChatParticipantsWithCompletionHandler: and take list of the CSParticipant objects from its completion handler.

void (^completionHandler)(NSArray *participantList) = 
                        ^(NSArray *participantList) {
    if (participantList != nil && [participantList count] > 0)
        chatParticipants = [NSArray arrayWithArray: participantList];
    else
        chatParticipants = [NSArray array]; // empty
};
[conferenceChat getChatParticipantsWithCompletionHandler:completionHandler];

Receiving Chat Messages

To monitor incoming messages (both public and private, only public or only private), you should handle the folowing chat events of the <CSChatDelegate> protocol.

• chat:allMessagesDidChange:changedMessages:
• chat:publicMessagesDidChange:changedMessages:
• chat:privateMessagesDidChange:changedMessages:

The changedMessages parameter is an array of the CSChatMessage objects that have changed. Each CSChatMessage object contains following properties.

- (void)        chat:(CSChat *)chat 
allMessagesDidChange:(CSDataCollectionChangeType)changeType 
     changedMessages:(NSArray *)changedMessages {
    switch (changeType) {
        case CSDataCollectionChangeTypeAdded:
            // Add code here to update application UI for added chat messages
            break;
        case CSDataCollectionChangeTypeDeleted:
            // Add code here to update application UI for deleted chat messages
            break;
        case CSDataCollectionChangeTypeCleared:
            // Add code here to remove all messages from the UI application.
            break;
    }
}

Sending Public Chat Message

You can send a public chat message which can be seen by all conference participant.

void (^completionHandler)(NSError *error) = ^(NSError *error) {
    if (error) {
        NSLog(@"Chat message sending failed:\n%ld-%@",
            (long)error.code, error.localizedDescription);
    }
    else {
        NSLog(@"Chat message sent successfully.");
    }
};
[conferenceChat sendPublicMessage: message
                completionHandler: completionHandler];

Client is notified about successful operation also by <CSChatDelegate> apart from completion handler.

Sending Private Chat Message

To send private chat message to given CSParticipant call the sendPrivateMessage:toParticipant:completionHandler: method of the CSChat object. Pass specific CSParticipant object from list returned by getChatParticipantsWithCompletionHandler: method.

void (^completionHandler)(NSError *error) = ^(NSError *error) {
    if (error) {
        NSLog(@"Chat message sending failed:\n%ld-%@",
            (long)error.code, error.localizedDescription);
    }
    else {
        NSLog(@"Chat message sent successfully.");
    }
};
[conferenceChat sendPrivateMessage: message
                     toParticipant: participant
                 completionHandler: completionHandler];

Client is notified about successful operation also by <CSChatDelegate> apart from completion handler.

Supported Conference Platforms

• CM Conferencing (AST-1 only)
  • CM 7
  • CM 6.3
• Avaya Aura Conferencing 8.0.3
• Scopia Conferencing 8.3.2
• Conferencing 9

Solution restrictions / Limitations

1. If you have many logged in users for one extension (for example MDA or EC500), you will have a remote call if another user makes the call to the conference bridge. You will be able to join this conference, but the roster list and moderator controls will be unavailable.
2. No video is available in a conference call due to CPU overloads
3. Information about the number of participants in a CM conference is not available.
4. If the network is unstable, a conference call can be lost.
5. The video call can be established in a CM conference between two participants if only they support video.
6. If a participant drops from the conference due to a connection issue, then other participants will see the roster list updated not immediately (it usually takes several minutes: 5-10).