public void OnEventReceived(EslMessage eslMessage)
{
try
{
var eslEvent = new EslEvent(eslMessage);
var eventType = Enumm.Parse <EslEventType>(eslEvent.EventName);
_eventReceived.OnNext(new EslEventStream(eslEvent,
eventType));
}
catch (Exception exception)
{
_logger.Warn($"Encountered an issue on the channel: {exception}.");
_eventReceived.OnError(exception);
}
}
public ConnectedCall(EslEvent @event)
{
_event = @event;
}
protected override Task HandleEvents(EslEvent @event,
EslEventType eventType)
{
_logger.Debug(@event);
return(Task.CompletedTask);
}
public SendEventCommand(EslEvent @event)
{
_event = @event;
}
public void OnEventReceived(EslMessage eslMessage)
{
var eslEvent = new EslEvent(eslMessage);
var eventName = eslEvent.EventName;
var eventType = Enumm.Parse <EslEventType>(eventName);
switch (eventType)
{
case EslEventType.BACKGROUND_JOB:
var backgroundJob = new BackgroundJob(eslMessage);
eslEvent = backgroundJob;
break;
case EslEventType.CALL_UPDATE:
var callUpdate = new CallUpdate(eslMessage);
eslEvent = callUpdate;
break;
case EslEventType.CHANNEL_BRIDGE:
var channelBridge = new ChannelBridge(eslMessage);
eslEvent = channelBridge;
break;
case EslEventType.CHANNEL_HANGUP:
case EslEventType.CHANNEL_HANGUP_COMPLETE:
var channelHangup = new ChannelHangup(eslMessage);
eslEvent = channelHangup;
break;
case EslEventType.CHANNEL_PROGRESS:
var channelProgress = new ChannelProgress(eslMessage);
eslEvent = channelProgress;
break;
case EslEventType.CHANNEL_PROGRESS_MEDIA:
var channelProgressMedia = new ChannelProgressMedia(eslMessage);
eslEvent = channelProgressMedia;
break;
case EslEventType.CHANNEL_EXECUTE:
var channelExecute = new ChannelExecute(eslMessage);
eslEvent = channelExecute;
break;
case EslEventType.CHANNEL_EXECUTE_COMPLETE:
var channelExecuteComplete = new ChannelExecuteComplete(eslMessage);
eslEvent = channelExecuteComplete;
break;
case EslEventType.CHANNEL_UNBRIDGE:
var channelUnbridge = new ChannelUnbridge(eslMessage);
eslEvent = channelUnbridge;
break;
case EslEventType.SESSION_HEARTBEAT:
var sessionHeartbeat = new SessionHeartbeat(eslMessage);
eslEvent = sessionHeartbeat;
break;
case EslEventType.DTMF:
var dtmf = new Dtmf(eslMessage);
eslEvent = dtmf;
break;
case EslEventType.RECORD_STOP:
var recordStop = new RecordStop(eslMessage);
eslEvent = recordStop;
break;
case EslEventType.CUSTOM:
var custom = new Custom(eslMessage);
eslEvent = custom;
break;
case EslEventType.CHANNEL_STATE:
var channelState = new ChannelStateEvent(eslMessage);
eslEvent = channelState;
break;
case EslEventType.CHANNEL_ANSWER:
eslEvent = new EslEvent(eslMessage);
break;
case EslEventType.CHANNEL_ORIGINATE:
eslEvent = new EslEvent(eslMessage);
break;
case EslEventType.CHANNEL_PARK:
var channelPark = new ChannelPark(eslMessage);
eslEvent = channelPark;
break;
case EslEventType.CHANNEL_UNPARK:
eslEvent = new EslEvent(eslMessage);
break;
default:
OnUnhandledEvents(new EslEvent(eslMessage));
break;
}
HandleEvents(eslEvent,
eventType);
}
protected virtual Task OnUnhandledEvents(EslEvent eslEvent)
{
_logger.Debug("received unhandled freeSwitch event {0}",
eslEvent);
return(Task.CompletedTask);
}
protected abstract Task HandleEvents(EslEvent @event,
EslEventType eventType);
public bool CanHandleEvent(EslEvent @event)
{
return((@event.UniqueId == ConnectedCall.UniqueId) &&
@event.CallerGuid == ConnectedCall.CallerGuid);
}
public EslEventArgs(EslEvent eventReceived)
{
_eventReceived = eventReceived;
}
public EslEventArgs(EslEvent eslEvent)
{
EslEvent = eslEvent;
}
public EslEventStream(EslEvent eslEvent,
EslEventType eslEventType)
{
EslEvent = eslEvent;
EslEventType = eslEventType;
}
public InboundCall(EslEvent @event)
{
_event = @event;
}
public abstract Task HandleEvents(EslEvent @event,
EslEventType eventType);
/// <summary>
/// FreeSwitch Events listener hook
/// </summary>
protected async Task PopEvent(EslEvent @event)
{
if (string.IsNullOrEmpty(@event.EventName))
{
return;
}
switch (@event.EventName.ToUpper())
{
case "CHANNEL_HANGUP":
await DispatchEvents(EslEventType.CHANNEL_HANGUP, new EslEventArgs(new ChannelHangup(@event.Items)));
break;
case "CHANNEL_HANGUP_COMPLETE":
await DispatchEvents(EslEventType.CHANNEL_HANGUP_COMPLETE,
new EslEventArgs(new ChannelHangup(@event.Items)));
break;
case "CHANNEL_PROGRESS":
await
DispatchEvents(EslEventType.CHANNEL_PROGRESS,
new EslEventArgs(new ChannelProgress(@event.Items)));
break;
case "CHANNEL_PROGRESS_MEDIA":
await DispatchEvents(EslEventType.CHANNEL_PROGRESS_MEDIA,
new EslEventArgs(new ChannelProgressMedia(@event.Items)));
break;
case "CHANNEL_EXECUTE":
await
DispatchEvents(EslEventType.CHANNEL_EXECUTE, new EslEventArgs(new ChannelExecute(@event.Items)));
break;
case "CHANNEL_EXECUTE_COMPLETE":
await DispatchEvents(EslEventType.CHANNEL_EXECUTE_COMPLETE,
new EslEventArgs(new ChannelExecuteComplete(@event.Items)));
break;
case "CHANNEL_BRIDGE":
await DispatchEvents(EslEventType.CHANNEL_BRIDGE, new EslEventArgs(new ChannelBridge(@event.Items)));
break;
case "CHANNEL_UNBRIDGE":
await
DispatchEvents(EslEventType.CHANNEL_UNBRIDGE,
new EslEventArgs(new ChannelUnbridge(@event.Items)));
break;
case "BACKGROUND_JOB":
await DispatchEvents(EslEventType.BACKGROUND_JOB, new EslEventArgs(new BackgroundJob(@event.Items)));
break;
case "SESSION_HEARTBEAT":
await
DispatchEvents(EslEventType.SESSION_HEARTBEAT,
new EslEventArgs(new SessionHeartbeat(@event.Items)));
break;
case "CHANNEL_STATE":
await
DispatchEvents(EslEventType.CHANNEL_STATE, new EslEventArgs(new ChannelStateEvent(@event.Items)));
break;
case "DTMF":
await DispatchEvents(EslEventType.DTMF, new EslEventArgs(new Dtmf(@event.Items)));
break;
case "RECORD_STOP":
await DispatchEvents(EslEventType.RECORD_STOP, new EslEventArgs(new RecordStop(@event.Items)));
break;
case "CALL_UPDATE":
await DispatchEvents(EslEventType.CALL_UPDATE, new EslEventArgs(new CallUpdate(@event.Items)));
break;
case "CUSTOM":
await DispatchEvents(EslEventType.CUSTOM, new EslEventArgs(new Custom(@event.Items)));
break;
case "CHANNEL_ANSWER":
await DispatchEvents(EslEventType.CHANNEL_ANSWER, new EslEventArgs(@event));
break;
case "CHANNEL_ORIGINATE":
await DispatchEvents(EslEventType.CHANNEL_ORIGINATE, new EslEventArgs(@event));
break;
case "CHANNEL_PARK":
await DispatchEvents(EslEventType.CHANNEL_PARK, new EslEventArgs(new ChannelPark(@event.Items)));
break;
case "CHANNEL_UNPARK":
await DispatchEvents(EslEventType.CHANNEL_UNPARK, new EslEventArgs(@event));
break;
default:
await DispatchEvents(EslEventType.UN_HANDLED_EVENT, new EslEventArgs(@event));
break;
}
}
public bool CanHandleEvent(EslEvent @event)
{
return(@event.UniqueId == InboundCall.UniqueId && @event.CallerGuid == InboundCall.CallerGuid);
}
private async void OnMessageReceived(ITcpChannel channel, object message)
{
// Here we validate the channel.
if (!channel.ChannelId.Equals(_channel.ChannelId))
{
return;
}
var decodedMessage = message as EslDecodedMessage;
// Handle decoded message.
if (decodedMessage?.Headers == null ||
!decodedMessage.Headers.HasKeys())
{
return;
}
var headers = decodedMessage.Headers;
object response;
var contentType = headers["Content-Type"];
if (string.IsNullOrEmpty(contentType))
{
return;
}
contentType = contentType.ToLowerInvariant();
switch (contentType)
{
case "command/reply":
var reply = new CommandReply(headers, decodedMessage.OriginalMessage);
response = reply;
break;
case "api/response":
var apiResponse = new ApiResponse(decodedMessage.BodyText);
response = apiResponse;
break;
case "text/event-plain":
var parameters = decodedMessage.BodyLines.AllKeys.ToDictionary(key => key,
key => decodedMessage.BodyLines[key]);
var @event = new EslEvent(parameters);
response = @event;
break;
case "log/data":
var logdata = new LogData(headers, decodedMessage.BodyText);
response = logdata;
break;
case "text/disconnect-notice":
var notice = new DisconnectNotice(decodedMessage.BodyText);
response = notice;
break;
case "text/rude-rejection":
await _channel.CloseAsync();
var reject = new RudeRejection(decodedMessage.BodyText);
response = reject;
break;
default:
// Here we are handling an unknown message
var msg = new EslMessage(decodedMessage.Headers, decodedMessage.OriginalMessage);
response = msg;
break;
}
await HandleResponse(response);
}
public async Task OnEventReceived(EslMessage eslMessage)
{
var eslEvent = new EslEvent(eslMessage);
var eventType = Enumm.Parse <EslEventType>(eslEvent.EventName);
var eslEventArgs = new EslEventArgs(new EslEvent(eslMessage));
AsyncEventHandler <EslEventArgs> handler;
switch (eventType)
{
case EslEventType.BACKGROUND_JOB:
handler = OnBackgroundJob;
break;
case EslEventType.CALL_UPDATE:
handler = OnCallUpdate;
break;
case EslEventType.CHANNEL_BRIDGE:
handler = OnChannelBridge;
break;
case EslEventType.CHANNEL_HANGUP:
handler = OnChannelHangup;
break;
case EslEventType.CHANNEL_HANGUP_COMPLETE:
handler = OnChannelHangupComplete;
break;
case EslEventType.CHANNEL_PROGRESS:
handler = OnChannelProgress;
break;
case EslEventType.CHANNEL_PROGRESS_MEDIA:
handler = OnChannelProgressMedia;
break;
case EslEventType.CHANNEL_EXECUTE:
handler = OnChannelExecute;
break;
case EslEventType.CHANNEL_EXECUTE_COMPLETE:
handler = OnChannelExecuteComplete;
break;
case EslEventType.CHANNEL_UNBRIDGE:
handler = OnChannelUnbridge;
break;
case EslEventType.SESSION_HEARTBEAT:
handler = OnSessionHeartbeat;
break;
case EslEventType.DTMF:
handler = OnDtmf;
break;
case EslEventType.RECORD_STOP:
handler = OnRecordStop;
break;
case EslEventType.CUSTOM:
handler = OnCustom;
break;
case EslEventType.CHANNEL_STATE:
handler = OnChannelState;
break;
case EslEventType.CHANNEL_ANSWER:
handler = OnChannelAnswer;
break;
case EslEventType.CHANNEL_ORIGINATE:
handler = OnChannelOriginate;
break;
case EslEventType.CHANNEL_PARK:
handler = OnChannelPark;
break;
case EslEventType.CHANNEL_UNPARK:
handler = OnChannelUnPark;
break;
default:
_logger.Debug("received unhandled freeSwitch event:");
_logger.Debug(eslEvent);
handler = OnReceivedUnHandledEvent;
break;
}
if (handler != null)
{
await handler(this, eslEventArgs);
}
}
