public Task OnDisconnectNotice(EslMessage eslMessage,
EndPoint channelEndPoint)
{
_logger.Debug("received disconnection message : {0}", eslMessage);
_logger.Warn("channel {0} disconnected", channelEndPoint);
return(Task.CompletedTask);
}
/// <summary>
/// Valiates every response received seeing that we can send commands to FreeSwitch asynchronously and wait for
/// responses.
/// However some responses may be for another command previously sent. In that regard, every command has a sequence
/// number
/// attached to it that helps differentiate between them and easily map their responses.
/// </summary>
/// <param name="command">The original command send</param>
/// <param name="response">The actual response received</param>
/// <returns>EslMessage</returns>
protected async Task <EslMessage> ValidateResponse(BaseCommand command, EslMessage response)
{
if (response == null)
{
return(null);
}
if (_requestsQueue.Count <= 0)
{
return(null);
}
CommandAsyncEvent event2;
if (!_requestsQueue.TryDequeue(out event2))
{
return(null);
}
if (event2 == null)
{
return(null);
}
if (!event2.Command.Equals(command))
{
return(null);
}
event2.Complete(response);
return(await event2.Task);
}
public async Task OnDisconnectNotice(EslMessage eslMessage,
EndPoint channelEndPoint)
{
_logger.Debug("received disconnection message : {0}", eslMessage);
_logger.Warn("channel {0} disconnected", channelEndPoint);
await CleanUpAsync();
}
private void SetActualMessage()
{
if (_actualMessage == null)
{
_actualMessage = new EslMessage();
}
}
private void CompleteDecoding(List <object> output)
{
// complete the decoding. Get ready for the next message
Checkpoint(DecoderState.ReadHeader);
// send message upstream
output.Add(_actualMessage);
_actualMessage = null;
}
public CommandReply(string command,
EslMessage response)
{
Command = command;
Response = response;
ReplyText = Response != null?Response.HeaderValue(EslHeaders.ReplyText) : string.Empty;
IsOk = !string.IsNullOrEmpty(ReplyText) && ReplyText.StartsWith(EslHeadersValues.Ok);
}
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 Dtmf(EslMessage message) : base(message)
{
}
public EslEvent(EslMessage response,
bool ignoreBody = false)
{
_response = response;
_ignoreBody = ignoreBody;
}
public ChannelExecuteComplete(EslMessage message) : base(message)
{
}
public ChannelStateEvent(EslMessage message) : base(message)
{
}
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);
}
public ChannelPark(EslMessage message) : base(message)
{
}
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);
}
}
public SessionHeartbeat(EslMessage message) : base(message)
{
}
/// <summary>
/// Valiates every response received seeing that we can send commands to FreeSwitch asynchronously and wait for
/// responses.
/// However some responses may be for another command previously sent. In that regard, every command has a sequence
/// number
/// attached to it that helps differentiate between them and easily map their responses.
/// </summary>
/// <param name="command">The original command send</param>
/// <param name="response">The actual response received</param>
/// <returns>EslMessage</returns>
protected async Task<EslMessage> ValidateResponse(BaseCommand command, EslMessage response) {
if (response == null) return null;
if (_requestsQueue.Count <= 0) return null;
CommandAsyncEvent event2;
if (!_requestsQueue.TryDequeue(out event2)) return null;
if (event2 == null) return null;
if (!event2.Command.Equals(command)) return null;
event2.Complete(response);
return await event2.Task;
}
public ChannelProgress(EslMessage message) : base(message)
{
}
public BackgroundJob(EslMessage message) : base(message)
{
}
public RecordStop(EslMessage message) : base(message)
{
}
public Custom(EslMessage message) : base(message)
{
}
public ChannelHangup(EslMessage message) : base(message)
{
}
public CallUpdate(EslMessage message) : base(message)
{
}
/// <summary>
/// Fired when a decoded message is received by the channel.
/// </summary>
/// <param name="channel">Receiving channel</param>
/// <param name="message">Decoded message received</param>
private async void OnMessageReceived(ITcpChannel channel, object message) {
var decodedMessage = message as EslDecodedMessage;
// Handle decoded message.
if (decodedMessage?.Headers == null
|| !decodedMessage.Headers.HasKeys())
return;
var headers = decodedMessage.Headers;
object response = null;
var contentType = headers["Content-Type"];
if (string.IsNullOrEmpty(contentType)) return;
contentType = contentType.ToLowerInvariant();
switch (contentType) {
case "auth/request":
if (OnAuthentication != null) await OnAuthentication(this, EventArgs.Empty).ConfigureAwait(false);
break;
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/rude-rejection":
await _channel.CloseAsync();
var reject = new RudeRejection(decodedMessage.BodyText);
response = reject;
break;
case "text/disconnect-notice":
var notice = new DisconnectNotice(decodedMessage.BodyText);
response = notice;
break;
default:
// Here we are handling an unknown message
var msg = new EslMessage(decodedMessage.Headers, decodedMessage.OriginalMessage);
response = msg;
break;
}
await HandleResponse(response).ConfigureAwait(false);
}
public ChannelUnbridge(EslMessage message) : base(message)
{
}
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 EslEvent(EslMessage response) : this(response, false)
{
}
