public void ReadyToRecord(List <IPEndPoint> iPEnds) { UdpSender sender = new UdpSender(); UdpMessage messageToB1 = new UdpMessage("ARecToBPlay", user.UserName); sender.Send(iPEnds[3], udpSender.GetLocalIP(), "17719", messageToB1.ToString()); UdpMessage messageToB2 = new UdpMessage("APlayToBRec", user.UserName); sender.Send(iPEnds[2], udpSender.GetLocalIP(), "17720", messageToB2.ToString()); UdpMessage messageToServer = new UdpMessage("APlayToBRecHoleOpened:" + otherName, user.UserName); sender.Send("152.136.73.240", "17722", udpSender.GetLocalIP(), "17721", messageToServer.ToString()); voiceReceiver.Start(); IPEndPoint srcEndPoint = new IPEndPoint(IPAddress.Parse(udpSender.GetLocalIP()), 17719); voiceSender.Start(iPEnds[3], srcEndPoint); }
/// <summary>Initializes a new instance of the <see cref="ObjectCommandEnvelope" /> class.</summary> /// <param name="message">The message.</param> /// <exception cref="ArgumentNullException">Message is null.</exception> public ObjectCommandEnvelope(UdpMessage message) { if (message == null) { throw new ArgumentNullException(nameof(message)); } using (MemoryStream stream = new MemoryStream(message.CommandBody)) { using (BinaryReader br = new BinaryReader(stream)) { this.SenderId = br.ReadUInt32(); this.ToObjectId = br.ReadUInt64(); this.Command = new BaseCommand(br); } } }
public void Send(UdpMessage message, ProtocolUdpClient client) { if (EndPoint == null) { return; } message.EndPoint = EndPoint; try { client.SendMessage(message); } catch { ConnectedUser.Id = -1; } }
public void SendPosition(Guid netObjId, Transform transformToSend) { var positionMessage = new UdpMessage("position") { Data = new PositionUpdate { Id = netObjId, X = transformToSend.position.x, Y = transformToSend.position.y, Z = transformToSend.position.z, RotX = transformToSend.rotation.eulerAngles.x, RotY = transformToSend.rotation.eulerAngles.y, RotZ = transformToSend.rotation.eulerAngles.z, } }; SendMessageToServer(positionMessage); }
public static UdpMessage ToUdpMessage(this byte[] message, IPEndPoint endPoint) { using (var stream = new MemoryStream(message)) { using (var binaryReader = new BinaryReader(stream)) { var udpMsg = new UdpMessage(endPoint) { Message = message, PacketType = binaryReader.ReadByte(), Flags = binaryReader.ReadByte(), Session = binaryReader.ReadUInt16(), Key = binaryReader.ReadUInt16() }; return(udpMsg); } } }
private System.Timers.Timer controlTimer = new System.Timers.Timer(300000);//Sync up every 5 min private void controlTimer_Elapsed(object sender, System.Timers.ElapsedEventArgs e) { UdpMessage udpMess = new UdpMessage(0, DateTime.Now, "All", "control"); SendUdpBroadcast(udpMess); //Check for broken connections & clients that are turned off and still connected foreach (ManageSystem sys in SystemsCollection) { if (sys.IsMonitorOn && sys.Status == ManageComm.statDISCONNECTED) { sys.TurnOnMonitor(); } else if (!sys.IsMonitorOn && sys.Status != ManageComm.statDISCONNECTED) { sys.TurnOffMonitor(); } } }
private void ProcessHeartbeat(UdpMessage message) { var heartbeat = message as GameHeartbeat; Logger.Info(string.Format("{0} Heartbeat", heartbeat.RemoteEndPoint)); if (SessionHandler.Heartbeat(heartbeat.RemoteEndPoint)) { var session = SessionHandler.GetSession(heartbeat.RemoteEndPoint); //send game info request var gameInfoReq = new GameInfoRequest(heartbeat.RemoteEndPoint); gameInfoReq.AddSession(session); gameInfoReq.Message = gameInfoReq.WriteUdpMessage(); Send(gameInfoReq); } }
/// <summary>Processes the message frame.</summary> /// <param name="frame">The frame.</param> /// <exception cref="ArgumentNullException">Frame is null.</exception> public void ProcessMessageFrame(UdpTransferFrame frame) { if (frame == null) { throw new ArgumentNullException(nameof(frame)); } using (MemoryStream memstrm = new MemoryStream(frame.MessageBuffer)) { using (BinaryReader br = new BinaryReader(memstrm)) { while (memstrm.Position < memstrm.Length) { UdpMessage udpMessage = new UdpMessage(br); this.ProcessUdpMessage(udpMessage); } } } }
private void AppendAckMessages(MemoryStream memstrm) { while (!this.pendingAckMessages.IsEmpty) { UdpMessage udpMessageToAck; if (!this.pendingAckMessages.TryPeek(out udpMessageToAck)) { continue; } var udpAckMessage = new UdpMessage(udpMessageToAck.SequenceId, MessageControlFlags.ACK, Array.Empty <byte>()); if (!this.AppendMessage(memstrm, udpAckMessage)) { break; } this.MessageSentCount++; this.pendingAckMessages.TryDequeue(out udpMessageToAck); } }
protected IObservable <IUdpMessage> CreateObservableMessageStream(CancellationTokenSource cancelToken) { _cancellationTokenSource = cancelToken; var observable = Observable.Create <IUdpMessage>( obs => { var disp = Observable.While( () => !cancelToken.Token.IsCancellationRequested, Observable.FromAsync(BackingUdpClient.ReceiveAsync)) .Select(msg => { var message = new UdpMessage { ByteData = msg.Buffer, RemotePort = msg.RemoteEndPoint.Port.ToString(), RemoteAddress = msg.RemoteEndPoint.Address.ToString() }; return(message); }).Subscribe( msg => obs.OnNext(msg), ex => { Cleanup(); var getEx = NativeSocketExceptions.Contains(ex.GetType()) ? new SocketException(ex) : ex;; obs.OnError(getEx); }, () => { Cleanup(); cancelToken.Cancel(); }); return(disp); }); return(observable); }
public bool Consume(UdpMessage message, ProtocolUdpClient server) { if (!_clients.ContainsKey(message.UserId)) { return(false); } var client = _clients[message.UserId]; client.EndPoint = message.EndPoint; foreach (var roommate in _clients.Values) { if (message.colorLine.Valid != (roommate == client)) { roommate.Send(message, server); } } return(true); }
void HandleInboundMessage(UdpMessage message) { switch (message.Event) { case "connected": Connected?.Invoke(); break; case "position": PositionUpdate?.Invoke(Deserialize <PositionUpdate>(message.Data.ToString())); break; case "newplayer": NewPlayer?.Invoke(new Guid(message.Data.ToString())); break; case "playerdisconnected": PlayerDisconnected?.Invoke(new Guid(message.Data.ToString())); break; case "newnetobj": NewNetObj?.Invoke(Deserialize <NetObj>(message.Data.ToString())); break; case "destroynetobj": NetObjDestroyed?.Invoke(new Guid(message.Data.ToString())); break; case "owner-changed": OwnerChanged?.Invoke(new Guid(message.Data.ToString())); break; default: Debug.LogError("Received invalid inbound message event: " + message.Event); break; } }
private void HandleReceivedUdpMessage(UdpMessage message) { var infos = MyMessageEncoder.Decode(message.Content); foreach (var info in infos) { //TODO: this getsourcesocket was used to track connected players.... but we have the discoverer now var socket = GetSourceSocket(message.From, info); socket.UpdatesSinceLastMessage = 0; if (ReceivedInTheRightOrder(info, socket)) { socket.LastMessageTime = info.Time; //if (ip == serverIp) // MessageReceivedFromServer(ip, info); //else MessageReceivedFromOtherClients(message.From, info); } } }
/// <summary> /// 初始化端口 /// </summary> /// <returns>成功与否</returns> public bool Init() { try { UdpMessage ConnectRequestLiveRecorder = new UdpMessage("ConnectRequestLiveRecorder", userName); UdpMessage ConnectRequestLivePlayer = new UdpMessage("ConnectRequestLivePlayer", userName); UdpMessage ConnectRequestSender = new UdpMessage("ConnectRequestSender", userName); UdpMessage ConnectRequestReceiver = new UdpMessage("ConnectRequestReceiver", userName); //打开各个端口 udpSender.Send(ServerIP, 17722, LocalIP, 17719, ConnectRequestLiveRecorder.ToString()); udpSender.Send(ServerIP, 17722, LocalIP, 17720, ConnectRequestLivePlayer.ToString()); udpSender.Send(ServerIP, 17722, LocalIP, 17721, ConnectRequestSender.ToString()); udpSender.Send(ServerIP, 17721, LocalIP, 17722, ConnectRequestReceiver.ToString()); udpSender.Send(ServerIP, 17722, LocalIP, 17722, ConnectRequestReceiver.ToString()); return(true); } catch { return(false); } }
private void OnVideoPrepareCompleted(VideoPlayer source) { Debug.Log(source.name + "Prepare Completed!"); mPrepareCount++; //等左中右视频都准备完毕以后,统一开始播放 if (mPrepareCount >= 3) { MaskImage.Hide(); LeftVideo.Play(); MidVideo.Play(); RightVideo.Play(); mPrepareCount = 0; if (source.url.Contains("四季")) { //通知交互端开始倒计时 var msg = new UdpMessage(MessageDefine.WholeVideoEnd); UdpManager.Instance.SendMessage(msg.ToJson()); } } }
public static byte[] WriteUdpMessage(this UdpMessage message) { using (var stream = new MemoryStream()) { using (var binaryWriter = new BinaryWriter(stream)) { binaryWriter.Write((byte)message.PacketType); binaryWriter.Write((byte)message.Flags); binaryWriter.Write(message.Session); binaryWriter.Write(message.Key); var multiPart = message as MultiPartUdpMessage; if (multiPart != null) { binaryWriter.Write(multiPart.PacketIndex); binaryWriter.Write(multiPart.TotalPackets); } } return(stream.ToArray()); } }
private void ProcessServerListRequest(UdpMessage message) { Logger.Info(string.Format("{0} ServerList", message.RemoteEndPoint)); //query server list and send results back var session = SessionHandler.GetSession(message.RemoteEndPoint); if (serverList.Any()) { var total = (ushort)serverList.Count; ushort packetIndex = 0; serverList.Values.ToList().ForEach(serverInfo => { var serverListResponse = new ServerListResponse(message.RemoteEndPoint); serverListResponse.AddSession(session); serverListResponse.PacketIndex = ++packetIndex; serverListResponse.TotalPackets = total; serverListResponse.Message = serverListResponse.WriteUdpMessage().Concat(serverInfo.WriteUdpMessage()).ToArray(); Send(serverListResponse); }); } else { var serverListResponse = new ServerListResponse(message.RemoteEndPoint); serverListResponse.AddSession(session); serverListResponse.PacketIndex = 1; serverListResponse.TotalPackets = 1; serverListResponse.Message = serverListResponse.WriteUdpMessage(); Send(serverListResponse); } }
protected virtual void ProcessReceiveResult(UdpReceiveResult udpReceiveResult) { UdpMessage message = null; try { //If all "before" callbacks return true we can proceed; logging, security etc if (MessageLifecycleCallbacks.All(handler => handler.BeforeUdpMessageReceived(udpReceiveResult))) { message = MessageHandler.ParseUdpReceiveResult(udpReceiveResult); MessageHandler.ProcessUdpMessage(message); MessageLifecycleCallbacks.ForEach( handler => handler.AfterUdpMessageReceived(udpReceiveResult)); } } catch (Exception e) { MessageHandler.OnUdpMessageReceivedError(udpReceiveResult, message, e); } }
/// <summary> /// 连接服务器 /// </summary> private void connectButton_Click(object sender, EventArgs e) { UdpMessage udpMessage = new UdpMessage("Connect", user.UserName); _sender.Send(udpMessage); if (receiver.GetListenStatus()) { receiver.StopListenning(); } Thread.Sleep(1000); if (_sender.Init()) { Console.WriteLine("客户端连接服务器初始化完成!"); } else { Console.WriteLine("失败"); } if (!receiver.GetListenStatus()) { receiver.StartListenning(); } Thread.Sleep(1000); }
private void ProcessUdpMessage(UdpMessage message) { MessageEntry removedEntry; // QOS1 - at least once if ((message.ControlFlags & MessageControlFlags.ACK) == MessageControlFlags.ACK && this.unAckedMessages.ContainsKey(message.SequenceId)) { this.unAckedMessages.TryRemove(message.SequenceId, out removedEntry); // QOS2 - at most once if ((message.ControlFlags & MessageControlFlags.QOS2) == MessageControlFlags.QOS2) { this.pendingAckMessages.Enqueue(message); } } // QOS2 - at most once if (message.ControlFlags == MessageControlFlags.ACK2 && this.unAckedMessages.ContainsKey(message.SequenceId)) { this.unAckedMessages.TryRemove(message.SequenceId, out removedEntry); } if ((message.ControlFlags & MessageControlFlags.COMMAND) == MessageControlFlags.COMMAND) { var cmdEnvelope = new ObjectCommandEnvelope(message); this.OnProcessCommandMessage(cmdEnvelope); // QOS 1 - at least once if ((message.ControlFlags & MessageControlFlags.QOS1) == MessageControlFlags.QOS1) { this.pendingAckMessages.Enqueue(message); } } this.MessageReceivedCount++; }
public ReadOnlyMemory <byte> DgramAlloc_MessagePack() { return(UdpMessage.Create(new SmallMessage(10), UdpMessagePackSerializer.Instance).ToDgram(UdpMessagePackSerializer.Instance).Data); }
//NOTE: 本当はprivate protectedがしたいが、そのためだけにC# 7.2使うのもアレなのでinternalでごまかします internal void SendMessage(UdpMessage message) => _sender.SendMessage(message);
/// <summary> /// 发送信息 /// </summary> /// <param name="message">待发送信息</param> /// <param name="iPEndPoint">接收方地址</param> public void Send(UdpMessage message, IPEndPoint iPEndPoint) { udpSender.Send(iPEndPoint, ServerIP, "17721", message.ToString()); }
/// <summary> /// 发送信息 /// </summary> /// <param name="message">待发送信息</param> /// <param name="name">接收用户名</param> /// <param name="iPEndPoint">接收方地址</param> public void Send(string message, string name, IPEndPoint iPEndPoint) { UdpMessage udpMessage = new UdpMessage(message, name, true); Send(udpMessage, iPEndPoint); }
/// <summary> /// 发送信息 /// </summary> /// <param name="message">待发送信息</param> /// <param name="name">接收用户名</param> /// <param name="ip">接收方地址</param> /// <param name="port">接收方地址</param> public void Send(string message, string name, string ip, string port) { UdpMessage udpMessage = new UdpMessage(message, name, true); Send(udpMessage, ip, port); }
public ReadOnlyMemory <byte> DgramAlloc_Newtonsoft() { return(UdpMessage.Create(new SmallMessage(10), UdpNewtonsoftJsonSerializer.Instance).ToDgram(UdpNewtonsoftJsonSerializer.Instance).Data); }
public UdpMessage UdpMessageAlloc_Utf8Json() { return(UdpMessage.Create(new SmallMessage(10), UdpUtf8JsonSerializer.Instance)); }
public UdpMessage UdpMessageAlloc_Newtonsoft() { return(UdpMessage.Create(new SmallMessage(10), UdpNewtonsoftJsonSerializer.Instance)); }
/// <summary> /// 发送信息 /// </summary> /// <param name="message">待发送信息</param> /// <param name="ip">接收方地址</param> /// <param name="port">接收方地址</param> public void Send(UdpMessage message, string ip, string port) { IPEndPoint iPEndPoint = new IPEndPoint(IPAddress.Parse(ip), int.Parse(port)); Send(message, iPEndPoint); }
public UdpMessage UdpMessageAlloc_MessagePack() { return(UdpMessage.Create(new SmallMessage(10), UdpMessagePackSerializer.Instance)); }