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:
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.
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:
Features | Basic conference (CM) | Enhanced conference (Avaya Aura Conferencing) | Enhanced conference (Scopia 8.3) | Enhanced conference (Conferencing 9) | Enhanced conference (IP Office Meet Me Conference) | Enhanced conference (IP Office Ad hoc Conference) | API to check the capability |
---|---|---|---|---|---|---|---|
video | Not Supported | Supported | Supported | Supported | Not Supported | Not Supported | |
deny video | Not Supported | Supported only for moderator | Not Supported | Not Supported | Not Supported | Not Supported | updateVideoAllowedCapability |
add participant | Not Supported | Supported only for moderator | Supported only for moderator | Supported only for moderator | Supported only for moderator | Supported only for moderator | addParticipantViaDialoutCapability |
add participant from the call | Supported | Supported only for moderator | Supported only for moderator | Supported only for moderator | Not Supported | Supported only for moderator | getAddParticipantFromCallCapability |
drop last participant | Supported | Not Supported | Not Supported | Not Supported | Not Supported | Not Supported | removeLastParticipantCapability |
drop participant | Not Supported | Not Supported | Not Supported | Supported only for moderator | Supported only for moderator | Supported only for moderator | removeParticipantCapability |
roster list | Not Supported | Supported | Supported | Supported | Supported | Supported | retrieveParticipantListCapability |
active talkers | Not Supported | Supported | Supported | Supported | Not Supported | Not Supported | activeTalkerCapability |
mute participant | Not Supported | Supported | Supported | Supported | Supported only for moderator | Supported only for moderator | muteParticipantAudioCapability |
unmute participant | Not Supported | Supported | Supported | Supported | Supported only for moderator | Supported only for moderator | unmuteParticipantAudioCapability |
mute all participants | Not Supported | Supported only for moderator | Supported only for moderator | Supported only for moderator | Supported only for moderator | Supported only for moderator | muteAllParticipantsCapability |
unmute all participants | Not Supported | Supported only for moderator | Supported only for moderator | Supported only for moderator | Supported only for moderator | Supported only for moderator | unmuteAllParticipantsCapability |
block participant video | Not Supported | Supported | Supported | Supported | Not Supported | Not Supported | blockParticipantVideoCapability |
unblock participant video | Not Supported | Supported | Supported | Supported | Not Supported | Not Supported | unblockParticipantVideoCapability |
video layout | Not Supported | Not Supported | Supported | Supported | Not Supported | Not Supported | updateVideoLayoutCapability |
lecture mode | Not Supported | Supported only for moderator | Supported only for moderator | Supported only for moderator | Supported only for moderator | Not Supported | updateLectureModeCapability |
lock conference | Not Supported | Supported only for moderator | Supported only for moderator | Supported only for moderator | Supported only for moderator | Not Supported | updateLockCapability |
continuation | Not Supported | Supported only for moderator | Not Supported | Not Supported | Supported only for moderator | Not Supported | updateContinuationStatusCapability |
recording | Not Supported | Supported only for moderator | Supported only for moderator | Supported only for moderator | Not Supported | Not Supported | startRecordingCapability |
exit tone | Not Supported | Supported only for moderator | Not Supported | Not Supported | Supported only for moderator | Not Supported | updateEntryExitToneStatusCapability |
terminate conference | Not Supported | Supported only for moderator | Supported only for moderator | Supported only for moderator | Supported only for moderator | Supported only for moderator | endConferenceCapability |
conference chat | Not Supported | Supported | Supported | Supported | Not Supported | Not Supported | inConferenceChatCapability |
meeting minutes | Not Supported | Supported | Not Supported | Not Supported | Not Supported | Not Supported | meetingMinutesCapability |
multiple presenters | Not Supported | Supported only for moderator | Not Supported | Not Supported | Not Supported | Not Supported | updateMultiplePresentersCapability |
raise hand | Not Supported | Supported only for moderator | Not Supported | Not Supported | Not Supported | Not Supported | raiseHandCapability |
extend meeting | Not Supported | Not Supported | Not Supported | Supported only for moderator | Not Supported | Not Supported | extendMeetingCapability |
accept pending participant | Not Supported | Not Supported | Not Supported | Supported only for moderator | Not Supported | Not Supported | acceptPendingParticipantCapability |
deny pending participant | Not Supported | Not Supported | Not Supported | Supported only for moderator | Not Supported | Not Supported | denyPendingParticipantCapability |
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);
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;
...
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;
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.
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.
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.
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.
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.
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.
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.
The roster list is used to show information about the conference participants and their current status:
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;
...
}
}
Three types of participants can be shown on the roster list:
You need to use the following callbacks of Conference to update the participants:
You need to update the view in accordance with the DataCollectionChangedEventArgs.ChangeType value and the list of participants (ChangedItems) provided by the callback:
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;
};
}
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;
};
}
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).
Active participants can have the following roles:
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.
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 provides an interface for interaction with the conference features allowed for the moderator.
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.
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.
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");
}
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");
}
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:
Method | API to check the capability |
---|---|
StartRecording(completionHandler) | StartRecordingCapability |
StartRecording(completionHandler, name, description) | StartRecordingCapability, AssignRecordingNameCapability |
PauseRecording(completionHandler) | PauseRecordingCapability |
ResumeRecording(completionHandler) | ResumeRecordingCapability |
StopRecording(completionHandler) | StopRecordingCapability |
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.
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.
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.
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.
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.
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);
To monitor incoming messages (both public and private, only public or only private), you should handle the folowing events of the Chat object.
The DataCollectionChangedEventArgs.ChangedItems property is an array of the ChatMessage objects that have changed. Each ChatMessage object contains following properties.
Property | Value |
---|---|
Id | string to identify message |
Time | the time when the message was sent |
Message | text of message |
Sender | Participant who sent message |
Recipient | Participant who received message |
Private | true, if it's private message |
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;
};
}
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.
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.