< 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 CallCreationInfo class can be used to set the Conference ID and pass code if the conferencing platform supports prompt suppression.

CallService callService = user.CallService;

CallCreationInfo callCreationInfo = new CallCreationInfo();
callCreationInfo.ConferenceID = conferenceID;
callCreationInfo.ConferencePasscode = conferencePasscode;

call = callService.CreateCall(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 SendDtmf() method on the Call object.

call.SendDtmf(DTMF_digit);

Conference tracking

To monitor call progress events, you need to handle the events provided by the Call object. Call provides the ConferenceStatusChanged callback notification that can be used to recognize whether the call is a conference or not. Add Conference event handlers for monitoring conference events when the call becomes a conference.

call.ConferenceStatusChanged += 
  new EventHandler(onConferenceStatusChanged);

...

void onConferenceStatusChanged(object sender, 
    ConferenceStatusChangedEventArgs arg)
{
    if (arg.IsConference)
    {
        Call call = (Call)sender;
        Conference conference = call.Conference;
        conference.ParticipantsChanged += onParticipantsChanged;
        conference.Started += onConferenceStarted;
        conference.CapabilitiesChanged += onConferenceCapabilitiesChanged;
        ...
    }
}

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

Conference conference = call.Conference;
conference.ParticipantsChanged -= ParticipantsChanged;
conference.Started -= ConferenceStarted;
conference.CapabilitiesChanged -= ConferenceCapabilitiesChanged;
...

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 ConferenceFactoryURI use the ConferenceFactoryURI property of the ConferenceConfiguration object.

UserConfiguration userConfiguration = new UserConfiguration();
ConferenceConfiguration conferenceConfiguration = 
    userConfiguration.ConferenceConfiguration;
conferenceConfiguration.ConferenceFactoryURI = conferenceFactoryUri;

Merge two calls into a conference

To merge calls you need to check the GetAddParticipantFromCallCapability(Call call) conference capability. If it is allowed, then you can use the AddParticipantFromCall() method of the Conference object to process call merging:

if (call.Conference.GetAddParticipantFromCallCapability(callToAdd).Allowed) 
{
    Conference.ConferenceActionCompletionHandler completionHandler = (error) =>
    {
        if (error == null)
        {
            PrintInfo("Success adding call into the conference.");
        }
        else
        {
            PrintError(string.Format(
                "Error when adding call into the conference:{0}",
                error.Error));
        }
    };

    call.Conference.AddParticipantFromCall(callToAdd, completionHandler);
}

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

The participant's event handler will receive the ConferenceStatusChanged 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 method on the Conference object. Your application can define the completion handler and use it to obtain the result and to add the participant to the call:

if (call.Conference.AddParticipantViaDialoutCapability.Allowed)
{
    Conference.ConferenceActionCompletionHandler completionHandler = (error) =>
    {
        if (error == null)
        {
            PrintInfo("Success adding participant into the conference.");
        }
        else
        {
            PrintError(string.Format(
                "Error when adding participant into the conference:{0}",
                error.Error));
        }
    };

    call.Conference.AddParticipant(participantAddress, 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 event handler will receive the Call.Ended callback with CallEndReason.CallEndedLocally reason in CallEndedEventArgs.EndReason property.

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)
{
    Conference.ConferenceActionCompletionHandler completionHandler = (error) =>
    {
        if (error == null)
        {
            PrintInfo("Terminate conference started.");
        }
        else
        {
            PrintError(string.Format(
                "Failed to terminate the conference: {0}",
                error.Error));
        }
    };

    call.Conference.EndConference(completionHandler);
}

The call will be ended for the participants and their event handlers will receive the Call.Ended callback with CallEndReason.DisconnectedByConferenceModerator reason for Conferencing 9 platform or CallEndReason.CallDisconnected 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 IsVideoAllowed property of the Conference object. To check if you can deny or allow video for the conference use the SetVideoAllowedStatusCapability capability. To deny or allow video for the conference use the SetVideoAllowed() method.

Video layout

You can change the video layout if the conferencing platform supports it. To get the current video layout option, use the CurrentVideoLayout property of the Conference object. If it returns VideoLayoutType.None, then the conference server does not support video layout selection.

To check if you are allowed to change the video layout, use the SetVideoLayoutCapability capability. Use the SupportedVideoLayouts property to show supported layouts. To set another layout, use the SetVideoLayout() method.

To show participant names use the SetDisplayVideoParticipantName method. You can check if the names are shown with the use of the IsVideoParticipantNameDisplayActive property.

To check if you are allowed to hide or show the self video in the layout use the SetVideoSelfSeeCapability capability. Use the SetVideoSelfSee method for hiding or showing. You can check if you see the self video using IsVideoSelfSeeActive 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() 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 Participant
• audio status -- indicates whether the participant is an audio participant - IsActiveAudioParticipant property of the ActiveParticipant -- shows participant's audio mute status - IsAudioMutedByServer property of the ActiveParticipant
• video status -- indicates whether the participant is a video participant - IsActiveVideoParticipant property of the ActiveParticipant -- shows participant's video transmission status - IsVideoBlockedByServer property of the ActiveParticipant
• participant role - IsModerator, IsLecturer, and IsPresenter properties of the ActiveParticipant
• participant supports collaboration - IsApplicationSharingActive property of the ActiveParticipant
• participant talks - ActiveTalkers property of the Conference
• join time - EntryTime property of the DroppedParticipant
• last spoken time - LastSpokenTime property of the ActiveParticipant

Initiate a roster list

To understand when the user is able to see the roster you should handle the CapabilitiesChanged conference event and check for the Conference.ParticipantListRetrievalCapability capability. If it is allowed, you can start initializing the roster view with the current participants:

call.Conference.CapabilitiesChanged += onConferenceCapabilitiesChanged;
...
void onConferenceCapabilitiesChanged(object sender, EventArgs e)
{
    Conference conference = (Conference)sender;
    if (conference != null)
        if (conference.ParticipantListRetrievalCapability.Allowed)
        {
            List participants = 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 DroppedParticipant object using EntryTime and ExitTime properties. -- dopped participant can be reinvited if the Conference.AddParticipantViaDialoutCapability capability is allowed to use the Reinvite() method of the DroppedParticipant object.
• pending participants - the participants who are waiting to be accepted to join the locked conference. -- pending participant can be denied if the Conference.DenyPendingParticipantCapability capability is allowed to use the Deny() method of the PendingParticipant object. -- pending participant can be accepted if the Conference.AcceptPendingParticipantCapability is allowed to use the Accept() method of the PendingParticipant object.

You need to use the following callbacks of Conference to update the participants:

• active participants - Conference.ParticipantsChanged
• dropped participants - Conference.DroppedParticipantsChanged
• pending participants - Conference.PendingParticipantsChanged

You need to update the view in accordance with the DataCollectionChangedEventArgs.ChangeType value and the list of participants (ChangedItems) provided by the callback:

• DataCollectionChangeType.CollectionCleared - there are no participants, clear participants from the view
• DataCollectionChangeType.ItemsAdded - new participants are added and you should add participants provided by the callback to the view
• DataCollectionChangeType.ItemsDeleted - participants have left the conference and you should delete the participants provided by the callback from the view
• DataCollectionChangeType.ItemsUpdated - participants have an updated status and you should update it in the view

call.Conference.ParticipantsChanged += onConferenceParticipantsChanged;
...
void onConferenceParticipantsChanged(object sender, 
    DataCollectionChangedEventArgs arg)
{
    Conference conference = (Conference)sender;
    switch (arg.ChangeType)
    {
        case DataCollectionChangeType.ItemsAdded:
        case DataCollectionChangeType.ItemsUpdated:
        case DataCollectionChangeType.ItemsDeleted:
            // The arg.ChangedItems is an array of ActiveParticipant 
            // objects that have changed.
            // Add code to update application UI for added/updated/deleted
            // participants.
            break;

        case DataCollectionChangeType.CollectionCleared:
            // 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 ActiveParticipant's events. ActiveParticipant provides notifications about the audio status, video status, participant roles, connection status and collaboration status.

void onConferenceParticipantsChanged(object sender, 
    DataCollectionChangedEventArgs arg)
{
    Conference conference = (Conference)sender;
    switch (arg.ChangeType)
    {
        case DataCollectionChangeType.ItemsAdded:
            foreach (ActiveParticipant participant in arg.ChangedItems)
            {
                participant.VideoStatusChanged += onVideoStatusChanged;
                participant.AudioStatusChanged += onAudioStatusChanged;
                participant.AssignedAsModerator += onAssignedAsModerator;
                ...
            }
            break;
    };
}

Talkers

To show who talks, you need to check the ActiveTalkerCapability capability and if allowed use the ActiveTalkers property of the Conference object.

List activeTalkers = call.Conference.ActiveTalkers;

You also can get the list of participants who recently talk using the RecentTalkers property of the Conference object.

List recentTalkers = 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 Conference.ModerateConferenceCapability capability.

The moderator can assign the moderator role to a participant if the ActiveParticipant.AssignAsModeratorCapability capability is allowed. To assign the moderator role, use the AssignAsModerator() method of the ActiveParticipant object. If the operation is successful, the notification is reported through the AssignedAsModerator event associated with the ActiveParticipant object.

if (activeParticipant.AssignAsModeratorCapability.Allowed) 
{
    activeParticipant.AssignAsModerator(completionHandler)
}

The role can be unassigned by the moderator using UnassignAsModerator() method of the ActiveParticipant object. To check if the participant is moderator use IsModerator bool property of the ActiveParticipant 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 ActiveParticipant.AssignAsLecturerCapability capability is allowed. To assign the lecturer role, use the AssignAsLecturer() method of the ActiveParticipant object. If the operation is successful, the notification is reported through AssignedAsLecturer event associated with the ActiveParticipant object.

if (activeParticipant.AssignAsLecturerCapability.Allowed) 
{
    activeParticipant.AssignAsLecturer(completionHandler)
}

The role can be unassigned by the moderator using UnassignAsLecturer() method of the ActiveParticipant object. To check if the participant is lecturer use IsLecturer bool property of ActiveParticipant 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 ActiveParticipant.AssignAsPresenterCapability capability is allowed. To assign the presenter role use the AssignAsPresenter() method of the ActiveParticipant. If the operation is successful, the notification is reported through the AssignedAsPresenter event associated with the ActiveParticipant object.

if (activeParticipant.AssignAsPresenterCapability.Allowed) 
{
    activeParticipant.AssignAsPresenter(completionHandler)
}

The role can be unassigned by the moderator using UnassignAsPresenter() method of the ActiveParticipant object. To check if the participant is presenter use IsPresenter bool property of ActiveParticipant 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 Conference.RaiseHandCapability capability. To raise the hand use the RaiseHand() method of the Conference object. If the operation is successful, the notification is reported through HandRaised event associated with the local user's ActiveParticipant 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 Conference.LowerHandCapability capability. To lower the hand, use the LowerHand() method of the Conference object. If the operation is successful, the notification is reported through HandLowered event associated with the local user's ActiveParticipant object. To check if the participant's hand is raised, use the IsHandRaised bool property of ActiveParticipant 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 Conference.MuteAllParticipantsCapability capability. To mute all the participants, use the MuteAllParticipants() method of the Conference object. All the participants will be muted except for other moderators, lecturers and presenters. If the operation is successful, the AudioStatusChanged notification with the ParticipantMediaEventArgs.MediaStatus = ParticipantMediaStatus.ReceiveOnly status is reported to all the muted participants through event handler associated with the ActiveParticipant object. The moderator can mute audio for a certain participant. To check if muting is allowed for the participant use the MuteCapability capability of the ActiveParticipant object. To mute a participant, use the Mute() method of the ActiveParticipant object. If the operation is successful, the AudioStatusChanged notification with the ParticipantMediaEventArgs.MediaStatus = ParticipantMediaStatus.ReceiveOnly status is reported to the muted participant through event handler associated with the ActiveParticipant object.

Block participant video

The moderator can block video for a certain participant. To check if blocking is allowed, use the BlockVideoCapability capability of the ActiveParticipant object. To block video for a participant use the BlockVideo() method of the ActiveParticipant object. If the operation is successful, the VideoStatusChanged notification with the ParticipantMediaEventArgs.MediaStatus = ParticipantMediaStatus.ReceiveOnly status is reported to the blocked participant through event handler associated with the ActiveParticipant 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.SetLectureModeStatusCapability.Allowed)
{
    Conference.ConferenceActionCompletionHandler completionHandler = (error) =>
    {
        if (error == null)
        {
            PrintInfo("Successfully changed conference lecture mode.");
        }
        else
        {
            PrintError(string.Format(
                "Failed to change conference lecture mode: {0}",
                error.Error));
        }
    };

    call.Conference.SetLectureModeActive(isChecked, completionHandler);
}

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

call.Conference.LectureModeStatusChanged += 
    new EventHandler(onLectureModeStatusChanged);
...
void onLectureModeStatusChanged(object sender, ConferencePropertyEventArgs arg)
{
    Conference conference = (Conference)sender;
    if (arg.Enabled)
        PrintInfo("Lecturemode enabled");
    else
        PrintInfo("Lecturemode disabled");
}

Lock conference

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

if (call.Conference.SetLockStatusCapability.Allowed)
{
    Conference.ConferenceActionCompletionHandler completionHandler = (error) =>
    {
        if (error == null)
        {
            PrintInfo("Lock conference started.");
        }
        else
        {
            PrintError(string.Format(
                "Lock conference cannot be done: {0}",
                error.Error));
        }
    };

    call.Conference.SetLocked(isChecked, completionHandler);
}

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

call.Conference.LockStatusChanged += 
    new EventHandler(onLockStatusChanged);
...
void onLockStatusChanged(object sender, ConferencePropertyEventArgs arg)
{
    Conference conference = (Conference)sender;
    if (arg.Enabled)
        PrintInfo("Lock enabled");
    else
        PrintInfo("Lock disabled");
}

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 Conference object can be used to control the recording:

The conference object provides the RecordingStatusChanged 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.SetContinuationStatusCapability.Allowed)
{
    Conference.ConferenceActionCompletionHandler completionHandler = (error) =>
    {
        if (error == null)
        {
            PrintInfo("Continuation mode started.");
        }
        else
        {
            PrintError(string.Format(
                "Continuation cannot be done: {0}",
                error.Error));
        }
    };

    call.Conference.SetContinuationActive(isChecked, completionHandler);
}

The conference object provides the ContinuationStatusChanged 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.SetEntryExitToneStatusCapability.Allowed)
{
    Conference.ConferenceActionCompletionHandler completionHandler = (error) =>
    {
        if (error == null)
        {
            PrintInfo("Play tone started.");
        }
        else
        {
            PrintError(string.Format(
                "Play tone cannot be done: {0}",
                error.Error));
        }
    };

    call.Conference.SetEntryExitToneActive(isChecked, completionHandler);
}

The conference object provides the EntryExitToneStatusChanged 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)
{
    Conference.ConferenceActionCompletionHandler completionHandler = (error) =>
    {
        if (error == null)
        {
            PrintInfo("Extend started.");
        }
        else
        {
            PrintError(string.Format(
                "Extend meeting cannot be done: {0}",
                error.Error));
        }
    };

    call.Conference.ExtendMeeting(additionalTimeInMinutes, completionHandler);
}

The conference object provides the EndTimeChanged 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 Conference object to get the Chat object. Then you should set the event handlers, which provide notifications about the chat session status and chat messages.

if (call.Conference.InConferenceChatCapability.Allowed) 
{
    Chat conferenceChat = call.Conference.InConferenceChat;
    conferenceChat.PrivateMessagesChanged += onPrivateMessagesChanged;
    conferenceChat.PublicMessagesChanged += onPublicMessagesChanged;
    conferenceChat.AllMessagesChanged += onAllMessagesChanged;
}

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 GetChatParticipants() and take list of the Participant objects from its completion handler.

Chat.ParticipantsCompletionHandler completionHandler = 
    (List participants) =>
    {
        chatParticipants = participants;
        if (chatParticipants.Count > 0)
        {
            PrintInfo("Participants list was retrieved.");
        }
        else
        {
            PrintInfo("Empty participants list was retrieved.");
        }
    };
conferenceChat.GetChatParticipants(completionHandler);

Receiving Chat Messages

To monitor incoming messages (both public and private, only public or only private), you should handle the folowing events of the Chat object.

• AllMessagesChanged
• PublicMessagesChanged
• PrivateMessagesChanged

The DataCollectionChangedEventArgs.ChangedItems property is an array of the ChatMessage objects that have changed. Each ChatMessage object contains following properties.

conferenceChat.AllMessagesChanged += onAllMessagesChanged;
...
void onAllMessagesChanged(object sender, 
    DataCollectionChangedEventArgs arg)
{
    Chat chat = (Chat)sender;
    switch (arg.ChangeType)
    {
        case DataCollectionChangeType.ItemsAdded:
            // Add code here to update application UI for added chat messages
            break;
        case DataCollectionChangeType.ItemsDeleted:
            // Add code here to update application UI for deleted chat messages
            break;
        case DataCollectionChangeType.CollectionCleared:
            // 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.

Chat.SendMessageCompletionHandler completionHandler = 
    (ChatFailureEventArgs error) =>
    {
        if (error == null)
        {
            PrintInfo("Chat message sent successfully");
        }
        else
        {
            PrintError("Chat message sending failed: " + error.Error);
        }
    };
conferenceChat.SendPublicMessage(message, completionHandler);

Client is notified about successful operation also by the AllMessagesChanged and PublicMessagesChanged events apart from completion handler.

Sending Private Chat Message

To send private chat message to given Participant call the SendPrivateMessage() method of the Chat object. Pass specific Participant object from list returned by GetChatParticipants() method.

Chat.SendMessageCompletionHandler completionHandler = 
    (ChatFailureEventArgs error) =>
    {
        if (error == null)
        {
            PrintInfo("Chat message sent successfully");
        }
        else
        {
            PrintError("Chat message sending failed: " + error.Error);
        }
    };
conferenceChat.SendPrivateMessage(participant, message, completionHandler);

Client is notified about successful operation also by the AllMessagesChanged and PrivateMessagesChanged events 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).