private void RegisterToDtmfResultEvent(string callConnectionId)
{
toneReceivedCompleteTask = new TaskCompletionSource <bool>(TaskContinuationOptions.RunContinuationsAsynchronously);
var dtmfReceivedEvent = new NotificationCallback((CallingServerEventBase callEvent) =>
{
Task.Run(async() =>
{
var toneReceivedEvent = (ToneReceivedEvent)callEvent;
Logger.LogMessage(Logger.MessageType.INFORMATION, $"Tone received --------- : {toneReceivedEvent.ToneInfo?.Tone}");
if (toneReceivedEvent?.ToneInfo?.Tone == ToneValue.Tone1)
{
toneReceivedCompleteTask.TrySetResult(true);
}
else
{
toneReceivedCompleteTask.TrySetResult(false);
}
EventDispatcher.Instance.Unsubscribe(CallingServerEventType.ToneReceivedEvent.ToString(), callConnectionId);
// cancel playing audio
await CancelAllMediaOperations().ConfigureAwait(false);
});
});
//Subscribe to event
EventDispatcher.Instance.Subscribe(CallingServerEventType.ToneReceivedEvent.ToString(), callConnectionId, dtmfReceivedEvent);
}
private void RegisterToCallStateChangeEvent(string callConnectionId)
{
callEstablishedTask = new TaskCompletionSource <bool>(TaskContinuationOptions.RunContinuationsAsynchronously);
reportCancellationToken.Register(() => callEstablishedTask.TrySetCanceled());
callTerminatedTask = new TaskCompletionSource <bool>(TaskContinuationOptions.RunContinuationsAsynchronously);
//Set the callback method
var callStateChangeNotificaiton = new NotificationCallback((CallingServerEventBase callEvent) =>
{
var callStateChanged = (CallConnectionStateChangedEvent)callEvent;
Logger.LogMessage(Logger.MessageType.INFORMATION, $"Call State changed to: {callStateChanged.CallConnectionState}");
if (callStateChanged.CallConnectionState == CallConnectionState.Connected)
{
callEstablishedTask.TrySetResult(true);
}
else if (callStateChanged.CallConnectionState == CallConnectionState.Disconnected)
{
EventDispatcher.Instance.Unsubscribe(CallingServerEventType.CallConnectionStateChangedEvent.ToString(), callConnectionId);
reportCancellationTokenSource.Cancel();
callTerminatedTask.SetResult(true);
}
});
//Subscribe to the event
var eventId = EventDispatcher.Instance.Subscribe(CallingServerEventType.CallConnectionStateChangedEvent.ToString(), callConnectionId, callStateChangeNotificaiton);
}
private void RegisterToPlayAudioResultEvent(string operationContext)
{
playAudioCompletedTask = new TaskCompletionSource <bool>(TaskContinuationOptions.RunContinuationsAsynchronously);
reportCancellationToken.Register(() => playAudioCompletedTask.TrySetCanceled());
var playPromptResponseNotification = new NotificationCallback((CallingServerEventBase callEvent) =>
{
Task.Run(() =>
{
var playAudioResultEvent = (PlayAudioResultEvent)callEvent;
Logger.LogMessage(Logger.MessageType.INFORMATION, $"Play audio status: {playAudioResultEvent.Status}");
if (playAudioResultEvent.Status == OperationStatus.Completed)
{
playAudioCompletedTask.TrySetResult(true);
EventDispatcher.Instance.Unsubscribe(CallingServerEventType.PlayAudioResultEvent.ToString(), operationContext);
}
else if (playAudioResultEvent.Status == OperationStatus.Failed)
{
playAudioCompletedTask.TrySetResult(false);
}
});
});
//Subscribe to event
EventDispatcher.Instance.Subscribe(CallingServerEventType.PlayAudioResultEvent.ToString(), operationContext, playPromptResponseNotification);
}
public bool Subscribe(string eventType, string eventKey, NotificationCallback notificationCallback)
{
string eventId = BuildEventKey(eventType, eventKey);
lock (this.SubscriptionLock)
{
return(NotificationCallback.TryAdd(eventId, notificationCallback));
}
}
private void RegisterToAddParticipantsResultEvent(string operationContext)
{
var addParticipantReceivedEvent = new NotificationCallback(async(CallingServerEventBase callEvent) =>
{
var addParticipantUpdatedEvent = (AddParticipantResultEvent)callEvent;
if (addParticipantUpdatedEvent.Status == OperationStatus.Completed)
{
Logger.LogMessage(Logger.MessageType.INFORMATION, $"Add participant status - {addParticipantUpdatedEvent.Status}");
EventDispatcher.Instance.Unsubscribe(CallingServerEventType.AddParticipantResultEvent.ToString(), operationContext);
Logger.LogMessage(Logger.MessageType.INFORMATION, "Sleeping for 60 seconds before proceeding further");
await Task.Delay(60 * 1000);
addParticipantCompleteTask.TrySetResult(true);
}
else if (addParticipantUpdatedEvent.Status == OperationStatus.Failed)
{
addParticipantCompleteTask.TrySetResult(false);
}
});
//Subscribe to event
EventDispatcher.Instance.Subscribe(CallingServerEventType.AddParticipantResultEvent.ToString(), operationContext, addParticipantReceivedEvent);
}
