private void ParseAntennaReplyParam(XmlTextReader replyReader, ref CommandReply result) { // do until end XML tag </returnValue> is found while (replyReader.Read() && !(replyReader.Name == "returnValue" && replyReader.NodeType == XmlNodeType.EndElement)) { // start XML tag <antenna>: we get an paramblock for antennas if (replyReader.Name == "antenna" && replyReader.NodeType == XmlNodeType.Element) { ParameterDesc container = new ParameterDesc("antenna", true, true); result.Parameters.Add(container); // do until end XML tag </antenna> is found while (replyReader.Read() && !(replyReader.Name == "antenna" && replyReader.NodeType == XmlNodeType.EndElement)) { if (replyReader.NodeType == XmlNodeType.Element) { string paramName = replyReader.Name; if (replyReader.Read() && (XmlNodeType.Text == replyReader.NodeType)) { ParameterDesc param = new ParameterDesc(paramName, replyReader.Value); result.Parameters.Add(param); } } } } } }
public async Task Ipv6() { var commandReply = new CommandReply( CommandReplyType.Succeeded, new IPEndPoint(IPAddress.Parse("2001:db8:85a3:8d3:1319:8a2e:370:7348"), 65534)); var stream = new MemoryWriteOnlyStream(); await commandReply.WriteToAsync(stream, this._bufferPool).ConfigureAwait(true); stream.ToArray().Should().Equal( 5, (byte)CommandReplyType.Succeeded, 0, (byte)AddressType.Ipv6, 32, 1, 13, 184, 133, 163, 8, 211, 19, 25, 138, 46, 3, 112, 115, 72, 255, 254); }
public override async void ChannelRead(IChannelHandlerContext context, object message) { switch (message) { case EslMessage msg when !string.IsNullOrEmpty(msg?.ContentType()): switch (msg.ContentType()) { case EslHeadersValues.AuthRequest: await _outboundListener.OnAuthentication(); break; case EslHeadersValues.CommandReply: var commandAsyncEvent1 = CommandAsyncEvents.Dequeue(); var cmdResponse = new CommandReply(commandAsyncEvent1.Command.Command, msg); commandAsyncEvent1.Complete(cmdResponse); break; case EslHeadersValues.ApiResponse: var commandAsyncEvent = CommandAsyncEvents.Dequeue(); var apiResponse = new ApiResponse(commandAsyncEvent.Command.Command, msg); commandAsyncEvent.Complete(apiResponse); break; case EslHeadersValues.TextEventPlain: _outboundListener.OnEventReceived(msg); break; case EslHeadersValues.TextDisconnectNotice: var channel = context.Channel; var address = channel.RemoteAddress; await _outboundListener.OnDisconnectNotice(msg, address); break; case EslHeadersValues.TextRudeRejection: await _outboundListener.OnRudeRejection(); break; default: // Unexpected freeSwitch message _logger.Warn("Unexpected message content type [{0}]", msg.ContentType()); break; } break; default: // Unexpected freeSwitch message _logger.Warn("Unexpected message [{0}]", message); return; } }
public void SendCommandReply(Command command, Action messageCompletedAction = null) { using (Stream message = Convert(CommandReply.Parse(command))) { communicationProtocol.SendMessage(message, messageCompletedAction); } }
public async Task Domain() { var commandReply = new CommandReply(CommandReplyType.Succeeded, new DnsEndPoint("google.com", 65534)); var stream = new MemoryWriteOnlyStream(); await commandReply.WriteToAsync(stream, this._bufferPool).ConfigureAwait(true); stream.ToArray().Should().Equal( 5, (byte)CommandReplyType.Succeeded, 0, (byte)AddressType.DomainName, 10, 103, 111, 111, 103, 108, 101, 46, 99, 111, 109, 255, 254); }
async Task RunProxyAsync(CancellationToken cancellationToken) { IProxy proxy; try { var command = await Command.ReadFromAsync(this._clientStream, this._bufferPool).ConfigureAwait(false); switch (command.CommandType) { case CommandType.Connect: proxy = this._proxyFactory.CreateTcpProxy( this._clientStream, command.EndPoint, this._bufferPool); break; case CommandType.UdpAssociate: proxy = this._proxyFactory.CreateUdpProxy(this._clientStream, this._bufferPool); break; default: throw new ProtocolException(CommandReplyType.CommandNotSupported); } } catch (Exception ex) { var commandReplyType = CommandReplyType.GeneralFailure; switch (ex) { case ProtocolException socksEx: this._log.LogError(socksEx, "Protocol error"); commandReplyType = socksEx.ErrorCode; break; case IOException _: case SocketException _: this._log.LogError("Network error: {0}", ex.Message); break; default: this._log.LogError("Connection error.", ex); break; } await new CommandReply(commandReplyType, s_EmptyEndPoint) .WriteToAsync(this._clientStream, this._bufferPool) .ConfigureAwait(false); return; } var reply = new CommandReply(CommandReplyType.Succeeded, proxy.BindEndPoint); await reply.WriteToAsync(this._clientStream, this._bufferPool).ConfigureAwait(false); using (proxy) { await proxy.RunAsync(cancellationToken).ConfigureAwait(false); } }
private void OnCallIdReply(CmdBase command, CommandReply reply) { if (!reply.Success) { Debug.WriteLine("OnCallIdReply " + reply.ErrorMessage); } command.ReplyReceived -= OnCallIdReply; }
private static void OnCommandReply(CmdBase command, CommandReply reply) { command.ReplyReceived -= OnCommandReply; if (!reply.Success) { Console.WriteLine("Command failed: " + reply.ErrorMessage); } }
public override async void ChannelRead(IChannelHandlerContext context, object message) { var eslMessage = message as EslMessage; var contentType = eslMessage?.ContentType(); if (string.IsNullOrEmpty(contentType)) { return; } // Handle command/reply if (contentType.Equals(EslHeadersValues.CommandReply)) { var commandAsyncEvent = CommandAsyncEvents.Dequeue(); var reply = new CommandReply(commandAsyncEvent.Command.Command, eslMessage); commandAsyncEvent.Complete(reply); return; } // Handle api/response if (contentType.Equals(EslHeadersValues.ApiResponse)) { var commandAsyncEvent = CommandAsyncEvents.Dequeue(); var apiResponse = new ApiResponse(commandAsyncEvent.Command.Command, eslMessage); commandAsyncEvent.Complete(apiResponse); return; } // Handle text/event-plain if (contentType.Equals(EslHeadersValues.TextEventPlain)) { await _inboundListener.OnEventReceived(eslMessage); return; } // Handle disconnect/notice message if (contentType.Equals(EslHeadersValues.TextDisconnectNotice)) { var channel = context.Channel; var address = channel.RemoteAddress; await _inboundListener.OnDisconnectNotice(eslMessage, address); return; } // Handle rude/rejection message if (contentType.Equals(EslHeadersValues.TextRudeRejection)) { await _inboundListener.OnRudeRejection(); return; } // Unexpected freeSwitch message _logger.Warn("Unexpected message content type [{0}]", contentType); }
public virtual void HandleReply(CommandReply reply) { // a command is only invoked once. if (ReplyReceived != null) { ReplyReceived(this, reply); ReplyReceived = null; } }
/// <summary> /// Handle an message /// </summary> /// <param name="context">Context unique for this handler instance</param> /// <param name="message">Message to process</param> /// <remarks> /// All messages that can't be handled MUST be send up the chain using <see cref="IPipelineHandlerContext.SendUpstream"/>. /// </remarks> public void HandleUpstream(IPipelineHandlerContext context, IPipelineMessage message) { if (message is EventRecieved) { HandleBackgroundCompletion(context, (EventRecieved)message); return; } if (!(message is ReceivedMessage)) { context.SendUpstream(message); return; } var msg = (ReceivedMessage)message; var type = msg.Message.Headers["Content-Type"]; if (type == null || type != "command/reply") { context.SendUpstream(message); return; } SendCommandMessage nextCommand = null; ICommand curMsg; lock (_outbound) { if (_current == null) { throw new InvalidOperationException("No active command set."); } _logger.Trace("Got reply for " + _current); curMsg = _current; nextCommand = _outbound.Count > 0 ? _outbound.Dequeue() : null; _current = null; } if (curMsg is BgApiCmd) { HandleBgApi(context, msg.Message, (BgApiCmd)curMsg); } else { var result = msg.Message.Headers["Reply-Text"].StartsWith("+"); var body = msg.Message.Headers["Reply-Text"]; var reply = new CommandReply(curMsg, result, body); _logger.Debug("Sending reply " + body); context.SendUpstream(reply); } if (nextCommand != null) { _logger.Trace("Sending next command down: " + nextCommand.Command); SendCommand(context, nextCommand); } }
/// <summary> /// /// </summary> /// public void Unsubscribe(string typeOfChannel) { PerfTiming perfTimer1 = new PerfTiming(); perfTimer1.Start(); // Validate current state of Reader API if (!RfReaderApi.IsValid) { throw new RfReaderApiInvalidModeException(); } if (RfReaderApi.TER == typeOfChannel || RfReaderApi.ALARM == typeOfChannel || RfReaderApi.ALL == typeOfChannel) { UnSubscribeChannelListener(typeOfChannel); } else { throw new RfReaderApiException(RfReaderApiException.ResultCode_System, RfReaderApiException.Error_InvalidParameter); } // Send unsubscribe command to ReaderService // We do this deliberately after turning down our channels in order not // to prevent channel shutdowns if exception during unsubscribe commands occur // Do a security check whether we are connected at all if (!this.CommandChannel.IsConnected()) { throw new RfReaderApiException(RfReaderApiException.ResultCode_System, RfReaderApiException.Error_NoConnection); } List <ParameterDesc> unsubscribeParams = new List <ParameterDesc>(); unsubscribeParams.Add(new ParameterDesc("type", typeOfChannel)); Command rpCommand = new Command("unsubscribe", unsubscribeParams); string commandID = ""; string replyMsg = this.CommandChannel.execute(rpCommand.getXmlCommand(ref commandID), commandID); CommandReply rpReply = CommandReply.DecodeXmlCommand(replyMsg); if (rpReply == null) { // There is no reply from our connected reader throw new RfReaderApiException(RfReaderApiException.ResultCode_System, RfReaderApiException.Error_NoReply); } if (rpReply.ResultCode != 0) { // forward errors as exceptions throw new RfReaderApiException(rpReply.ResultCode, rpReply.Error, rpReply.Cause); } if (RfReaderApi.showPerformanceInfo) { ProvideInformation(this, "Unsubscribe took " + perfTimer1.End().ToString("##.###") + "s"); } }
public void Unsupported_endpoint_type_should_throw() { var commandReply = new CommandReply(CommandReplyType.Succeeded, new DummyEndPoint()); var stream = new MemoryWriteOnlyStream(); commandReply .Awaiting(x => x.WriteToAsync(stream, this._bufferPool)) .Should() .Throw <InvalidDataException>() .And.Message.Should().ContainEquivalentOf(nameof(EndPoint)); }
public virtual CommandReply CreateReply(string dataToParse) { if (string.IsNullOrEmpty(dataToParse.Trim())) { return(new CommandReply(false)); } CommandReply reply = new CommandReply(dataToParse.Trim()[0] == '+'); reply.ErrorMessage = dataToParse; return(reply); }
public override CommandReply CreateReply(string dataToParse) { if (dataToParse == "OK") { return(new CommandReply(true)); } else { CommandReply reply = new CommandReply(false); reply.ErrorMessage = dataToParse; return(reply); } }
private void HandleCommandReply(MpvEvent @event) { if (CommandReply == null) { return; } var replyUserData = @event.ReplyUserData; var error = @event.Error; var eventArgs = new MpvCommandReplyEventArgs(replyUserData, error); CommandReply.Invoke(this, eventArgs); }
private void OnBridgeCallId(CmdBase command, CommandReply reply) { GetVariableReply gvr = (GetVariableReply)reply; if (!gvr.Success) { Debug.WriteLine("OnBridgeCallId " + reply.ErrorMessage); } string otherChannelId = (string)command.ContextData; SetVariable sv = new SetVariable(otherChannelId, "gate_callid", gvr.Value); sv.ReplyReceived += OnCallIdReply; _eventMgr.Send(sv); command.ReplyReceived -= OnBridgeCallId; }
public void ChannelDataParserAsCommandReplyTest() { var eventData = AppDomain.CurrentDomain.BaseDirectory + "\\Messages\\ChannelData.txt"; var backgroundJobBytes = File.ReadAllBytes(eventData); var byteBuffer = Unpooled.CopiedBuffer(backgroundJobBytes); var channel = new EmbeddedChannel(new EslFrameDecoder()); channel.WriteInbound(byteBuffer); var message = channel.ReadInbound <EslMessage>(); var commandReply = new CommandReply("connect", message); Assert.Equal("+OK", commandReply.ReplyText); Assert.Equal(true, commandReply.IsOk); Assert.Equal("command/reply", commandReply.ContentType); }
public async Task can_send_multple_commands() { using (var listener = new OutboundListener(0)) { listener.Start(); bool commandRequestReceived = false; CommandReply commandReply = null; listener.Connections.Subscribe( async(socket) => { await socket.Connect(); commandReply = await socket.Linger(); commandReply = await socket.NoLinger(); }); using (var freeSwitch = new FakeFreeSwitchSocket(listener.Port)) { freeSwitch.MessagesReceived.FirstAsync(m => m.StartsWith("connect")) .Subscribe(async _ => await freeSwitch.SendChannelDataEvent()); freeSwitch.MessagesReceived.FirstAsync(m => m.StartsWith("linger")) .Subscribe(async _ => { await freeSwitch.SendCommandReplyOk(); }); freeSwitch.MessagesReceived.FirstAsync(m => m.StartsWith("nolinger")) .Subscribe(async _ => { await freeSwitch.SendCommandReplyError("FAILED"); commandRequestReceived = true; }); await Wait.Until(() => commandRequestReceived); Assert.True(commandRequestReceived); Assert.NotNull(commandReply); Assert.False(commandReply.Success); } } }
public void it_should_parse_Command_Reply_OK() { var parser = new Parser(); var rawInput = "Content-Type: command/reply\nReply-Text: +OK\n\n"; foreach (char c in rawInput) { parser.Append(c); } Assert.True(parser.Completed); var reply = new CommandReply(parser.ExtractMessage()); Assert.NotNull(reply); Assert.True(reply.Success); Console.WriteLine(reply); }
public async Task Ipv4() { var commandReply = new CommandReply( CommandReplyType.Succeeded, new IPEndPoint(IPAddress.Parse("1.2.3.4"), 65534)); var stream = new MemoryWriteOnlyStream(); await commandReply.WriteToAsync(stream, this._bufferPool).ConfigureAwait(true); stream.ToArray().Should().Equal( 5, (byte)CommandReplyType.Succeeded, 0, (byte)AddressType.Ipv4, 1, 2, 3, 4, 255, 254); }
private void ParseReplyParam(XmlTextReader replyReader, ref CommandReply result, Collection <string> Name) { while (replyReader.Read() && !(replyReader.Name == "returnValue" && replyReader.NodeType == XmlNodeType.EndElement)) { if (replyReader.NodeType == XmlNodeType.Element) { foreach (string paramName in Name) { if (replyReader.Name == paramName) { if (replyReader.Read() && (XmlNodeType.Text == replyReader.NodeType || XmlNodeType.CDATA == replyReader.NodeType)) { ParameterDesc param = new ParameterDesc(paramName, replyReader.Value); result.Parameters.Add(param); } } } } } }
public override void Action(CommandCaller caller, string input, string[] args) { string command = string.Join(" ", args); List <string> argList = new List <string>(); while (command.Contains("\"")) { int first = command.IndexOf("\"", StringComparison.Ordinal); int last = command.IndexOf("\"", first + 1, StringComparison.Ordinal); string arg = command.Substring(first, last - first + 1); command = command.Replace(arg, ""); argList.Add(arg.Trim(' ', '"')); } argList.AddRange(command.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries)); if (argList.Count < MinimumArguments) { throw new UsageException(); } CommandReply reply = Action(caller, argList.ToArray()); if (!reply.IsEmpty) { if (Main.netMode == 0 || Type.HasFlag(CommandType.Chat)) { caller.Reply(reply.Text, reply.TextColor); } else { NetMessage.BroadcastChatMessage(NetworkText.FromLiteral(reply.Text), reply.TextColor); } } }
public static void EventLoop() { while (true) { IntPtr ptr = mpv_wait_event(Handle, -1); mpv_event evt = (mpv_event)Marshal.PtrToStructure(ptr, typeof(mpv_event)); if (WindowHandle == IntPtr.Zero) { WindowHandle = FindWindowEx(MainForm.Hwnd, IntPtr.Zero, "mpv", null); } // Debug.WriteLine(evt.event_id.ToString()); try { switch (evt.event_id) { case mpv_event_id.MPV_EVENT_SHUTDOWN: if (App.DebugMode) { Trace.WriteLine("before Shutdown.Invoke"); } Shutdown?.Invoke(); if (App.DebugMode) { Trace.WriteLine("after Shutdown.Invoke"); } WriteHistory(null); ShutdownAutoResetEvent.Set(); return; case mpv_event_id.MPV_EVENT_LOG_MESSAGE: LogMessage?.Invoke(); break; case mpv_event_id.MPV_EVENT_GET_PROPERTY_REPLY: GetPropertyReply?.Invoke(); break; case mpv_event_id.MPV_EVENT_SET_PROPERTY_REPLY: SetPropertyReply?.Invoke(); break; case mpv_event_id.MPV_EVENT_COMMAND_REPLY: CommandReply?.Invoke(); break; case mpv_event_id.MPV_EVENT_START_FILE: StartFile?.Invoke(); break; case mpv_event_id.MPV_EVENT_END_FILE: var end_fileData = (mpv_event_end_file)Marshal.PtrToStructure(evt.data, typeof(mpv_event_end_file)); EndFileEventMode reason = (EndFileEventMode)end_fileData.reason; EndFile?.Invoke(reason); break; case mpv_event_id.MPV_EVENT_FILE_LOADED: HideLogo(); FileLoaded?.Invoke(); WriteHistory(get_property_string("path")); break; case mpv_event_id.MPV_EVENT_TRACKS_CHANGED: TracksChanged?.Invoke(); break; case mpv_event_id.MPV_EVENT_TRACK_SWITCHED: TrackSwitched?.Invoke(); break; case mpv_event_id.MPV_EVENT_IDLE: Idle?.Invoke(); if (get_property_int("playlist-count") == 0) { ShowLogo(); } break; case mpv_event_id.MPV_EVENT_PAUSE: Pause?.Invoke(); break; case mpv_event_id.MPV_EVENT_UNPAUSE: Unpause?.Invoke(); break; case mpv_event_id.MPV_EVENT_TICK: Tick?.Invoke(); break; case mpv_event_id.MPV_EVENT_SCRIPT_INPUT_DISPATCH: ScriptInputDispatch?.Invoke(); break; case mpv_event_id.MPV_EVENT_CLIENT_MESSAGE: var client_messageData = (mpv_event_client_message)Marshal.PtrToStructure(evt.data, typeof(mpv_event_client_message)); string[] args = NativeUtf8StrArray2ManagedStrArray(client_messageData.args, client_messageData.num_args); if (args.Length > 1 && args[0] == "mpv.net") { Command.Execute(args[1], args.Skip(2).ToArray()); } else if (args.Length > 0) { ClientMessage?.Invoke(args); } break; case mpv_event_id.MPV_EVENT_VIDEO_RECONFIG: VideoReconfig?.Invoke(); break; case mpv_event_id.MPV_EVENT_AUDIO_RECONFIG: AudioReconfig?.Invoke(); break; case mpv_event_id.MPV_EVENT_METADATA_UPDATE: MetadataUpdate?.Invoke(); break; case mpv_event_id.MPV_EVENT_SEEK: Seek?.Invoke(); break; case mpv_event_id.MPV_EVENT_PROPERTY_CHANGE: var propData = (mpv_event_property)Marshal.PtrToStructure(evt.data, typeof(mpv_event_property)); if (propData.format == mpv_format.MPV_FORMAT_FLAG) { foreach (var i in BoolPropChangeActions) { if (i.Key == propData.name) { i.Value.Invoke(Marshal.PtrToStructure <int>(propData.data) == 1); } } } if (propData.format == mpv_format.MPV_FORMAT_STRING) { foreach (var i in StringPropChangeActions) { if (i.Key == propData.name) { i.Value.Invoke(StringFromNativeUtf8(Marshal.PtrToStructure <IntPtr>(propData.data))); } } } if (propData.format == mpv_format.MPV_FORMAT_INT64) { foreach (var i in IntPropChangeActions) { if (i.Key == propData.name) { i.Value.Invoke(Marshal.PtrToStructure <int>(propData.data)); } } } break; case mpv_event_id.MPV_EVENT_PLAYBACK_RESTART: PlaybackRestart?.Invoke(); string path = get_property_string("path"); if (LastPlaybackRestartFile != path) { Size vidSize = new Size(get_property_int("dwidth"), get_property_int("dheight")); if (vidSize.Width == 0 || vidSize.Height == 0) { vidSize = new Size(1, 1); } if (VideoSize != vidSize) { VideoSize = vidSize; VideoSizeChanged?.Invoke(); } VideoSizeAutoResetEvent.Set(); Task.Run(new Action(() => ReadMetaData())); LastPlaybackRestartFile = path; } break; case mpv_event_id.MPV_EVENT_CHAPTER_CHANGE: ChapterChange?.Invoke(); break; case mpv_event_id.MPV_EVENT_QUEUE_OVERFLOW: QueueOverflow?.Invoke(); break; case mpv_event_id.MPV_EVENT_HOOK: Hook?.Invoke(); break; } } catch (Exception ex) { Msg.ShowException(ex); } } }
internal CommandReply ParseReply(string replyMsg) { Collection <string> paramName = new Collection <string>(); CommandReply result = new CommandReply(); StringReader strReader = new StringReader(replyMsg); XmlTextReader replyReader = new XmlTextReader(strReader); while ("" != replyMsg && replyReader.Read()) { switch (replyReader.NodeType) { case XmlNodeType.Element: if (replyReader.Name == "returnValue") { switch (result.CommandName) { case "readTagIDs": case "readTagMemory": case "writeTagMemory": case "readTagField": case "writeTagField": case "killTag": case "lockTagBank": case "nXP_SetReadProtect": case "nXP_ResetReadProtect": case "nXP_Calibrate": ParseForTagData(replyReader, ref result); break; case "hostGreetings": paramName.Add("version"); paramName.Add("configType"); paramName.Add("configID"); ParseReplyParam(replyReader, ref result, paramName); break; case "setConfiguration": paramName.Add("configID"); ParseReplyParam(replyReader, ref result, paramName); break; case "getConfigVersion": paramName.Add("configID"); paramName.Add("configType"); ParseReplyParam(replyReader, ref result, paramName); break; case "getConfiguration": paramName.Add("configID"); paramName.Add("configData"); ParseReplyParam(replyReader, ref result, paramName); break; case "getAllSources": paramName.Add("sourceName"); ParseReplyParam(replyReader, ref result, paramName); break; case "getTime": paramName.Add("utcTime"); ParseReplyParam(replyReader, ref result, paramName); break; case "getIO": paramName.Add("inValue"); paramName.Add("outValue"); ParseReplyParam(replyReader, ref result, paramName); break; case "getReaderStatus": paramName.Add("readerType"); paramName.Add("mLFB"); paramName.Add("hWVersion"); paramName.Add("fWVersion"); paramName.Add("readerMode"); paramName.Add("version"); ParseReplyParam(replyReader, ref result, paramName); break; case "getProtocolConfig": paramName.Add("initialQ"); paramName.Add("profile"); paramName.Add("channels"); paramName.Add("session"); paramName.Add("rSSIThreshold"); paramName.Add("retry"); paramName.Add("idLength"); paramName.Add("writeMode"); paramName.Add("writeBoost"); ParseReplyParam(replyReader, ref result, paramName); break; case "getAntennaConfig": ParseAntennaReplyParam(replyReader, ref result); break; case "sendCommand": paramName.Add("byteReply"); ParseReplyParam(replyReader, ref result, paramName); break; // This is an unknown result so we just ignore it default: break; } // Here we are: Now the interesting part begins which is the real // return value. while (replyReader.Read() && !(replyReader.Name == "returnValue" && replyReader.NodeType == XmlNodeType.EndElement)) { if (replyReader.Name == "value") { if (replyReader.Read()) { if (XmlNodeType.Text == replyReader.NodeType) { ParameterDesc param = new ParameterDesc("value", replyReader.Value); result.Parameters.Add(param); } } } } } else if (replyReader.Name == "error") { // Read in extended error information while (replyReader.Read() && !(replyReader.Name == "error" && replyReader.NodeType == XmlNodeType.EndElement)) { if (replyReader.Name == "name" && replyReader.NodeType == XmlNodeType.Element) { if (replyReader.Read() && XmlNodeType.Text == replyReader.NodeType) { result.Error = replyReader.Value.ToString(); } } else if (replyReader.Name == "cause" && replyReader.NodeType == XmlNodeType.Element) { if (replyReader.Read() && XmlNodeType.Text == replyReader.NodeType) { result.Cause = replyReader.Value.ToString(); } } } } else if (this.m_IsHeaderRead) { result.CommandName = replyReader.Name; } else if (this.m_IsValidReply) { switch (replyReader.Name) { case "id": if (replyReader.Read()) { if (XmlNodeType.Text == replyReader.NodeType) { result.CommandID = replyReader.Value.ToString(); } } break; case "resultCode": if (replyReader.Read()) { if (XmlNodeType.Text == replyReader.NodeType) { result.ResultCode = Int32.Parse(replyReader.Value); } } break; default: break; } } else if (replyReader.Name == "reply") { this.m_IsValidReply = true; } break; case XmlNodeType.EndElement: switch (replyReader.Name) { case "resultCode": this.m_IsHeaderRead = true; break; default: break; } break; default: break; } } return(result); }
private void ParseForTagData(XmlTextReader replyReader, ref CommandReply result) { result.TagData = ParseReportForTags(replyReader, "returnValue"); }
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 static void EventLoop() { while (true) { IntPtr ptr = mpv_wait_event(MpvHandle, -1); mpv_event evt = (mpv_event)Marshal.PtrToStructure(ptr, typeof(mpv_event)); if (MpvWindowHandle == IntPtr.Zero) { MpvWindowHandle = FindWindowEx(MainForm.Hwnd, IntPtr.Zero, "mpv", null); } //Debug.WriteLine(evt.event_id.ToString()); switch (evt.event_id) { case mpv_event_id.MPV_EVENT_SHUTDOWN: Shutdown?.Invoke(); AutoResetEvent.Set(); return; case mpv_event_id.MPV_EVENT_LOG_MESSAGE: LogMessage?.Invoke(); break; case mpv_event_id.MPV_EVENT_GET_PROPERTY_REPLY: GetPropertyReply?.Invoke(); break; case mpv_event_id.MPV_EVENT_SET_PROPERTY_REPLY: SetPropertyReply?.Invoke(); break; case mpv_event_id.MPV_EVENT_COMMAND_REPLY: CommandReply?.Invoke(); break; case mpv_event_id.MPV_EVENT_START_FILE: StartFile?.Invoke(); break; case mpv_event_id.MPV_EVENT_END_FILE: var end_fileData = (mpv_event_end_file)Marshal.PtrToStructure(evt.data, typeof(mpv_event_end_file)); EndFile?.Invoke((EndFileEventMode)end_fileData.reason); break; case mpv_event_id.MPV_EVENT_FILE_LOADED: FileLoaded?.Invoke(); LoadFolder(); break; case mpv_event_id.MPV_EVENT_TRACKS_CHANGED: TracksChanged?.Invoke(); break; case mpv_event_id.MPV_EVENT_TRACK_SWITCHED: TrackSwitched?.Invoke(); break; case mpv_event_id.MPV_EVENT_IDLE: Idle?.Invoke(); break; case mpv_event_id.MPV_EVENT_PAUSE: Pause?.Invoke(); break; case mpv_event_id.MPV_EVENT_UNPAUSE: Unpause?.Invoke(); break; case mpv_event_id.MPV_EVENT_TICK: Tick?.Invoke(); break; case mpv_event_id.MPV_EVENT_SCRIPT_INPUT_DISPATCH: ScriptInputDispatch?.Invoke(); break; case mpv_event_id.MPV_EVENT_CLIENT_MESSAGE: if (ClientMessage != null) { try { var client_messageData = (mpv_event_client_message)Marshal.PtrToStructure(evt.data, typeof(mpv_event_client_message)); string[] args = NativeUtf8StrArray2ManagedStrArray(client_messageData.args, client_messageData.num_args); if (args != null && args.Length > 1 && args[0] == "mpv.net") { bool found = false; foreach (var i in mpvnet.Command.Commands) { if (args[1] == i.Name) { found = true; i.Action.Invoke(args.Skip(2).ToArray()); } } if (!found) { List <string> names = mpvnet.Command.Commands.Select((item) => item.Name).ToList(); names.Sort(); MainForm.Instance.ShowMsgBox($"No command '{args[1]}' found. Available commands are:\n\n{string.Join("\n", names)}\n\nHow to bind these commands can be seen in the default input bindings and menu definition located at:\n\nhttps://github.com/stax76/mpv.net/blob/master/mpv.net/Resources/input.conf.txt", MessageBoxIcon.Error); } } ClientMessage?.Invoke(args); } catch (Exception ex) { MainForm.Instance.ShowMsgBox(ex.GetType().Name + "\n\n" + ex.ToString(), MessageBoxIcon.Error); } } break; case mpv_event_id.MPV_EVENT_VIDEO_RECONFIG: VideoReconfig?.Invoke(); break; case mpv_event_id.MPV_EVENT_AUDIO_RECONFIG: AudioReconfig?.Invoke(); break; case mpv_event_id.MPV_EVENT_METADATA_UPDATE: MetadataUpdate?.Invoke(); break; case mpv_event_id.MPV_EVENT_SEEK: Seek?.Invoke(); break; case mpv_event_id.MPV_EVENT_PROPERTY_CHANGE: var event_propertyData = (mpv_event_property)Marshal.PtrToStructure(evt.data, typeof(mpv_event_property)); if (event_propertyData.format == mpv_format.MPV_FORMAT_FLAG) { foreach (var i in BoolPropChangeActions) { if (i.Key == event_propertyData.name) { i.Value.Invoke(Marshal.PtrToStructure <int>(event_propertyData.data) == 1); } } } break; case mpv_event_id.MPV_EVENT_PLAYBACK_RESTART: PlaybackRestart?.Invoke(); Size s = new Size(get_property_int("dwidth"), get_property_int("dheight")); if (VideoSize != s && s != Size.Empty) { VideoSize = s; VideoSizeChanged?.Invoke(); } break; case mpv_event_id.MPV_EVENT_CHAPTER_CHANGE: ChapterChange?.Invoke(); break; case mpv_event_id.MPV_EVENT_QUEUE_OVERFLOW: QueueOverflow?.Invoke(); break; case mpv_event_id.MPV_EVENT_HOOK: Hook?.Invoke(); break; } } }
/// <summary> /// /// </summary> /// <param name="iPAddress">IP Address of listener, to which channel send data</param> /// <param name="port">Port of listener, to which channel send data</param> /// <param name="bufferTag">If true: buffers data during offline. Listener must acknowledge data</param> /// <returns></returns> public void Subscribe(string typeOfChannel, IPAddress iPAddress, int port, bool bufferTag) { // Validate current state of Reader API if (!RfReaderApi.IsValid) { throw new RfReaderApiInvalidModeException(); } // Tssting only: Setup listener, but do not send commands to reader if (RfReaderApi.testFlag_ListenOnly) { SubscribeChannelListener(typeOfChannel, iPAddress, port, bufferTag); } else { PerfTiming perfTimer1 = new PerfTiming(); perfTimer1.Start(); // Security check for preconditions: Are we connected at all? if (!this.CommandChannel.IsConnected()) { throw new RfReaderApiException(RfReaderApiException.ResultCode_System, RfReaderApiException.Error_NoConnection); } // setup channel Listener for alarms if (RfReaderApi.TER == typeOfChannel || RfReaderApi.ALARM == typeOfChannel || RfReaderApi.ALL == typeOfChannel) { // Tssting only: send subscribe command, but don't listen if (false == RfReaderApi.testFlag_SubscribeOnly) { if (IPAddress.None != iPAddress) { SubscribeChannelListener(typeOfChannel, iPAddress, port, bufferTag); } else { UnSubscribeChannelListener(typeOfChannel); } } } else { throw new RfReaderApiException(RfReaderApiException.ResultCode_System, RfReaderApiException.Error_InvalidParameter); } List <ParameterDesc> subscribeParams = new List <ParameterDesc>(); subscribeParams.Add(new ParameterDesc("type", typeOfChannel)); if (IPAddress.None != iPAddress) { subscribeParams.Add(new ParameterDesc("iPAddress", iPAddress.ToString())); subscribeParams.Add(new ParameterDesc("port", port.ToString())); } subscribeParams.Add(new ParameterDesc("bufferTag", bufferTag.ToString())); Command rpCommand = new Command("subscribe", subscribeParams); string commandID = ""; string replyMsg = this.CommandChannel.execute(rpCommand.getXmlCommand(ref commandID), commandID); CommandReply rpReply = CommandReply.DecodeXmlCommand(replyMsg); if (rpReply == null) { // There is no reply from our connected reader throw new RfReaderApiException(RfReaderApiException.ResultCode_System, RfReaderApiException.Error_NoReply); } if (rpReply.ResultCode != 0) { // forward errors as exceptions throw new RfReaderApiException(rpReply.ResultCode, rpReply.Error, rpReply.Cause); } if (RfReaderApi.showPerformanceInfo) { ProvideInformation(this, "Subscribe took " + perfTimer1.End().ToString("##.###") + "s"); } } }
private void OnAuthed(CmdBase command, CommandReply reply) { LogWriter(LogPrio.Trace, "We have not authenticated."); _authed = true; RequestEvents(); }