protected override void OnReceived(byte[] data)
{
((RCoder)UserToken.Coder).Unpack(data, (r) =>
{
OnMsg?.Invoke(r);
});
}
protected override void OnReceiveBytes(IUserToken userToken, byte[] data)
{
((RCoder)userToken.Unpacker).Unpack(data, (r) =>
{
OnMsg.Invoke(userToken, r);
});
}
private void _server_OnReceive(object currentObj, byte[] data)
{
var userToken = (IUserToken)currentObj;
((RUnpacker)(userToken.Unpacker)).Unpack(data, (r) =>
{
OnMsg.Invoke(userToken, r);
});
}
private void pictureBox1_MouseMove(object sender, MouseEventArgs e)
{
this.Focus();
if (this._mClient != null && this._isConnected)
{
try
{
var transferStr = "mousemove:" + e.X + "@" + e.Y + "@" + this.Height;
OnMsg?.Invoke(transferStr.ToString());
_mClient.SendMessage(Remote, transferStr);
}
catch
{
}
}
}
/// <summary>
/// Среди зарегистророванных методов находит подходящий по типу сообщения и вызывает его.
/// </summary>
public bool CallReader(ReceivedMsg msg)
{
Delegate reader;
if (OnMsg != null)
{
OnMsg.Invoke(msg.Msg);
}
if (_msgReaders.TryGetValue(msg.Msg.GetType(), out reader))
{
reader.DynamicInvoke(msg, msg.Msg);
return(true);
}
else
{
return(false);
}
}
public void Start()
{
Running = true;
Connect().Wait();
Task.Run(async() =>
{
while (Running)
{
try
{
await SendMsg(new JObject
{
["action"] = "heartbeat",
["data"] = new JObject
{
["client"] = "喵喵喵"
}
});
}
catch { }
Thread.Sleep(10000);
}
});
Task.Run(async() =>
{
byte[] buffer = new byte[1 << 16];
while (Running)
{
try
{
using (MemoryStream ms = new MemoryStream())
{
WebSocketReceiveResult result = null;
while (true)
{
while (result == null)
{
try
{
result = client.ReceiveAsync(new ArraySegment <byte>(buffer), CancellationToken.None).Result;
}
catch (AggregateException)
{
Active = false;
if (Running)
{
await Connect();
}
}
}
if (result.Count == 0)
{
result = null;
continue;
}
ms.Write(buffer, 0, result.Count);
if (result.EndOfMessage)
{
break;
}
}
OnMsg?.Invoke(JObject.Parse(Encoding.UTF8.GetString(ms.ToArray())));
}
}
catch (Exception e)
{
this.Log(LoggerLevel.Warn, "Uncaught exception : " + e.ToString());
}
}
});
}
/// <summary>
/// Tries to connect to a server, and then start a listing loop.
/// </summary>
private void Connect()
{
if (String.IsNullOrEmpty(Address))
{
return;
}
IPAddress [] addresses;
if (Address == "localhost")
{
addresses = Dns.GetHostAddresses(Dns.GetHostName());
}
else
{
addresses = Dns.GetHostAddresses(Address);
}
// Loop through the AddressList to obtain the supported AddressFamily. This is to avoid
// an exception that occurs when the host IP Address is not compatible with the address family
// (typical in the IPv6 case).
foreach (IPAddress curAddr in addresses)
{
try {
IPEndPoint ipe = new IPEndPoint(curAddr, Port);
connection = new Socket(ipe.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
connection.Connect(ipe);
//If we connect, start a simple listining loop.
if (connection.Connected)
{
OnConnection?.Invoke(Address + ":" + Port, ConnectionStatus.Succes);
Listner = new Thread(() => {
while (true)
{
byte[] buffer = new byte[MsgSize];
int size = 0;
try {
size = connection.Receive(buffer);
} catch (SocketException) {
KillConnection = true;
size = 0;
}
if (size == 0 && KillConnection)
{
OnBadThing?.Invoke();
connection.Close();
connection.Dispose();
break;
}
//connection.Send(buffer);
String temp = Util.BtoS(buffer);
OnMsg?.Invoke(connection, temp);
Thread.Sleep(100);
}
});
Listner.Start();
return;
}
else
{
continue;
}
} catch (SocketException) {
//something mesed up during our connection attempt.
//Wont crash out of the loop since we might have more IPs to try
continue;
}
}
OnConnection?.Invoke(Address + ":" + Port, ConnectionStatus.Failure);
connection = null;
}
/// <summary>
/// As a server, we will listen on the main socket
/// and spawn of other sockets for incomming connetions.
///
/// Those connections will be maintined untill the die
/// </summary>
private void Listen()
{
IPAddress [] addresses = Dns.GetHostAddresses(Dns.GetHostName());
// Create a TCP/IP socket.
foreach (IPAddress curAddr in addresses)
{
try {
IPEndPoint ipe = new IPEndPoint(curAddr, Port);
connection = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
connection.Bind(ipe);
connection.Blocking = false;
connection.Listen(10);
IsListining = true;
break;
} catch (SocketException) {
//something mesed up during our connection attempt.
//Wont crash out of the loop since we might have more IPs to try
continue;
}
}
if (!IsListining)
{
OnConnection?.Invoke("listen", ConnectionStatus.Failure);
}
else
{
OnConnection?.Invoke("listen", ConnectionStatus.Succes);
Listner = new Thread(() => {
while (true)
{
if (!KillConnection)
{
try {
Socket tempListener = connection.Accept();
OnConnection?.Invoke(Address + ":" + Port, ConnectionStatus.Succes);
new Thread((soc) => {
Socket tempSocket = soc as Socket;
while (true)
{
byte[] buffer = new byte[MsgSize];
if (KillConnection)
{
tempSocket.Shutdown(SocketShutdown.Both);
}
int size = 0;
try {
size = tempSocket.Receive(buffer);
String temp = Util.BtoS(buffer);
OnMsg?.Invoke(tempSocket, temp);
} catch (SocketException e) {
if (e.ErrorCode == (int)SocketError.ConnectionAborted || e.ErrorCode != (int)SocketError.WouldBlock)
{
KillConnection = true;
size = 0;
}
} catch (ObjectDisposedException) {
break;
}
if (size == 0 && KillConnection)
{
OnBadThing?.Invoke();
tempSocket.Close();
tempSocket.Dispose();
break;
}
Thread.Sleep(100);
}
OnConnection?.Invoke(Address + ":" + Port, ConnectionStatus.Failure);
}).Start(tempListener);
} catch (SocketException e) {
//If the accept call has nothing to accept, this will do nothing
//All other errors are re-thrown.
if (e.ErrorCode != (int)SocketError.WouldBlock)
{
throw e;
}
}
}
else
{
try {
connection.Shutdown(SocketShutdown.Both);
} catch (SocketException) {
//The socket was not connected/listening.
}
connection.Close();
connection.Dispose();
break;
}
Thread.Sleep(100);
}
});
Listner.Start();
}
}
/// <summary>
/// 日志消息
/// </summary>
/// <param name="ex"></param>
/// <param name="msg"></param>
private void onMsg(string msg)
{
OnMsg?.Invoke(msg);
}