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