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); } }