public void Start()
{
_socketServer.Start(20310);
_storageSaver.Start();
Running = true;
OnMessageRecived?.Invoke("Server started");
}
public void Stop()
{
_socketServer.Stop();
_ahemClientManager.Dispose();
_storageSaver.Stop();
Running = false;
OnMessageRecived?.Invoke("Server stopped");
}
private void SocketServer_OnClientDataRecived(ClientSocket client, string msg)
{
OnMessageRecived?.Invoke(string.Format("SocketServer_OnClientDataRecived {0}", msg));
JObject jObject = JObject.Parse(msg);
PacketType packetType = (PacketType)Enum.Parse(typeof(PacketType), jObject.ToObject <Packet>().PacketType);
if (packetType == PacketType.ClientConnected)
{
if (!ChatClientManager.ReadOnlyChatClients.ContainsKey(client.IPAddress))
{
ChatClient chatClient = ChatClientManager.AddClient(client, jObject.ToObject <ClientConnected>());
OnMessageRecived?.Invoke(string.Format("Client {0} authenticized", client.IPAddress.ToString()));
OnClientConnected?.Invoke(chatClient);
}
else
{
OnErrMessageRecived?.Invoke(string.Format("Client {0} trying authenticize mulitiple times!", client.IPAddress.ToString()));
}
return;
}
if (ChatClientManager.ReadOnlyChatClients.ContainsKey(client.IPAddress) == false)
{
OnErrMessageRecived?.Invoke(string.Format("Unauthenticized or Disposed client {0} trying send data!", client.IPAddress.ToString()));
return;
}
ChatClient indexedClient = ChatClientManager.ReadOnlyChatClients[client.IPAddress];
switch (packetType)
{
case PacketType.ClientDisConnect:
if (SocketServer.ClientSockets.ContainsKey(client.IPAddress))
{
indexedClient.ClientSocket.Dispose();
OnMessageRecived?.Invoke(string.Format("client {0} disposed", client.IPAddress.ToString()));
}
break;
case PacketType.Message:
indexedClient.OnRootMessageRecived(jObject.ToObject <Message>());
OnMessageRecived?.Invoke(string.Format("Message recived from client {0}", client.IPAddress.ToString()));
OnClientDataRecived?.Invoke(indexedClient, jObject);
break;
case PacketType.GPS:
indexedClient.GPSdata = new GPSdata(jObject.ToObject <GPS>().GPSdata);
OnMessageRecived?.Invoke(string.Format("GPS value recived from client {0}", client.IPAddress.ToString()));
OnClientDataRecived?.Invoke(indexedClient, jObject);
break;
default:
OnErrMessageRecived?.Invoke(string.Format("Unidentified packet {0} recived from client {1}", ((int)packetType).ToString(), client.IPAddress.ToString()));
break;
}
}
public void StartReading()
{
//wrap with try and catch
new Task(() =>
{
while (Connection)
{
string res = m_reader.ReadString();
if (res != null)
{
OnMessageRecived?.Invoke(this, res);
}
}
}).Start();
}
private void SocketServer_OnClientByteStreamDataRecived(ClientSocket client, byte[] content)
{
OnMessageRecived?.Invoke($"SocketServer_OnClientByteStreamDataRecived Length:{content.Length}");
if (_ahemClientManager.ReadOnlyAhemClients.TryGetValue(client.IPAddress, out AhemClient indexedClient) == false)
{
OnErrMessageRecived?.Invoke($"Unauthenticized or Disposed client {client.IPAddress} trying send data!");
return;
}
AhemClient ahemClient = _ahemClientManager.ClientStreamDequeue(client, content);
if (ahemClient != null)
{
OnClientStreamRecived?.Invoke(ahemClient, content);
}
}
private void StartListening()
{
_isListening = true;
_listeningThread = new Thread(() =>
{
while (_isListening)
{
byte[] data = new byte[256];
Int32 bytes = _stream.Read(data, 0, data.Length);
string message = System.Text.Encoding.ASCII.GetString(data, 0, bytes);
OnMessageRecived?.Invoke(message);
}
});
_listeningThread.Start();
}
public Client()
{
_client = new CommClient()
{
Configuration =
{
Ssl = false,
CheckCertificateRevocation = false,
RequireClientCertificate = false
}
};
_client.Configuration.Protocol = new ProtocolHandler(_client, (m) =>
{
OnMessageRecived?.Invoke(m);
});
}
public void StartReading()
{
//wrap with try and catch
try
{
new Task(() =>
{
while (m_client.Connected)
{
string res = m_reader.ReadString();
if (res != null)
{
OnMessageRecived?.Invoke(this, res);
}
else
{
Debug.Write("hii prob");
}
}
}).Start();
}
catch { };
}
private void SocketServer_OnClientConnected(ClientSocket client)
{
OnMessageRecived?.Invoke(string.Format("SocketServer_OnClientConnected {0}", client.IPAddress.ToString()));
}
private void SocketServer_OnMessageRecived(string msg) => OnMessageRecived?.Invoke(msg);
public void Stop()
{
SocketServer.Stop();
ChatClientManager.Dispose();
OnMessageRecived?.Invoke("Server stopped");
}
public void Start()
{
SocketServer.Start(20310);
OnMessageRecived?.Invoke("Server started");
}
private void SocketListener_AsyncOnMessageRecived(string msg) => ActionsConcurrentQueue.Enqueue(() => OnMessageRecived?.Invoke(msg));
public void SendMessage(Hashtable parameters)
{
OnMessageRecived?.Invoke(parameters);
}
private void SocketServer_OnClientJsonDataRecived(ClientSocket client, string msg)
{
OnMessageRecived?.Invoke($"SocketServer_OnClientDataRecived {msg}");
JObject jObject = JObject.Parse(msg);
//Model.PacketType packetType = (Model.PacketType)Enum.Parse(typeof(Model.PacketType), jObject.ToObject<Packet>().PacketType);
Model.PacketType packetType = jObject.ToObject <Packet>().PacketType;
if (packetType == Model.PacketType.ClientConnected)
{
if (!_ahemClientManager.ReadOnlyAhemClients.ContainsKey(client.IPAddress))
{
ClientConnected clientConnected = jObject.ToObject <ClientConnected>();
AhemClient chatClient = _ahemClientManager.AddClient(client, clientConnected);
OnMessageRecived?.Invoke($"Client {client.IPAddress} authenticized");
OnClientConnected?.Invoke(chatClient);
OnClientPacketRecived?.Invoke(chatClient, clientConnected);
}
else
{
OnErrMessageRecived?.Invoke($"Client {client.IPAddress} trying authenticize mulitiple times!");
}
return;
}
AhemClient indexedClient;
if (_ahemClientManager.ReadOnlyAhemClients.TryGetValue(client.IPAddress, out indexedClient) == false)
{
OnErrMessageRecived?.Invoke($"Unauthenticized or Disposed client {client.IPAddress} trying send data!");
return;
}
switch (packetType)
{
case Model.PacketType.ClientDisConnect:
if (_socketServer.ClientSockets.ContainsKey(client.IPAddress))
{
indexedClient.ClientSocket.Dispose();
OnMessageRecived?.Invoke($"client {client.IPAddress} disposed");
OnClientPacketRecived?.Invoke(indexedClient, jObject.ToObject <ClientDisConnect>());
}
break;
case Model.PacketType.UploadDocument:
_ahemStorage.TryAddDoc(jObject.ToObject <UploadDocument>().Doc);
break;
case Model.PacketType.RemoveDocument:
RemoveDocument removeDocument = jObject.ToObject <RemoveDocument>();
_ahemStorage.RemoveDoc(removeDocument.Theme, indexedClient?.User.Id, removeDocument.DocName);
break;
case Model.PacketType.UploadPrivateDocument:
UploadPrivateDocument uploadPrivateDocument = jObject.ToObject <UploadPrivateDocument>();
_ahemStorage.TryAddPrivateDoc(uploadPrivateDocument.Doc);
break;
case Model.PacketType.RemovePrivateDocument:
RemovePrivateDocument removePrivateDocument = jObject.ToObject <RemovePrivateDocument>();
_ahemStorage.RemovePrivateDoc(indexedClient.User.Id, removePrivateDocument.DocName);
break;
case Model.PacketType.Like:
Like like = jObject.ToObject <Like>();
_ahemStorage.TryLike(like.Theme, like.DocName);
break;
case Model.PacketType.Unlike:
UnLike unlike = jObject.ToObject <UnLike>();
_ahemStorage.TryUnlike(unlike.Theme, unlike.DocName);
break;
case Model.PacketType.Follow:
Follow follow = jObject.ToObject <Follow>();
_ahemStorage.AddFollower(follow.Target.Id, indexedClient.User.Id);
break;
case Model.PacketType.UnFollow:
UnFollow unFollow = jObject.ToObject <UnFollow>();
_ahemStorage.RemoveFollower(unFollow.Target.Id, indexedClient.User.Id);
break;
case Model.PacketType.ReqPageData:
ReqPageData reqPageData = jObject.ToObject <ReqPageData>();
List <DocThumbnail> publicDocThumbs = _ahemStorage.GetPublicDocThumb(reqPageData.Theme, reqPageData.StartIndex, reqPageData.Count, reqPageData.DocOrder);
indexedClient.SendData(new PageData(publicDocThumbs));
break;
case Model.PacketType.ReqPrivatePageData:
ReqPrivatePageData reqPrivatePageData = jObject.ToObject <ReqPrivatePageData>();
List <DocThumbnail> privateDocThumbs = _ahemStorage.GetPrivateDocThumb(indexedClient.User.Id, reqPrivatePageData.StartIndex, reqPrivatePageData.Count);
indexedClient.SendData(new PrivatePageData(privateDocThumbs));
break;
case Model.PacketType.ReqDoc:
ReqDoc reqDoc = jObject.ToObject <ReqDoc>();
indexedClient.SendData(new PDoc(_ahemStorage.GetUserDoc(reqDoc.Author.Id, reqDoc.DocName)));
break;
case Model.PacketType.ReqThemes:
indexedClient.SendData(new Themes(_ahemStorage.GetTheme()));
break;
case Model.PacketType.StreamHeader:
switch (jObject.ToObject <StreamHeader>().StreamPacketType)
{
case StreamPacketType.Image:
ImageStream imageStream = jObject.ToObject <ImageStream>();
_ahemClientManager.ClientStreamEnqueue(client, jObject.ToObject <ImageStream>());
OnClientPacketRecived?.Invoke(indexedClient, imageStream);
break;
default:
break;
}
break;
default:
OnErrMessageRecived?.Invoke($"Unidentified packet {(int)packetType} recived from client {client.IPAddress}");
break;
}
}
private void SocketServer_OnClientConnected(ClientSocket client) => OnMessageRecived?.Invoke($"SocketServer_OnClientConnected {client.IPAddress}");
