void EndFightMessage_Reader(ReceivedMsg receivedMsg, EndFightMessage msg)
{
if (FightEnd != null)
{
FightEnd.Invoke(msg.WinnerKnifeIndex);
}
}
private void WaitforData()
{
byte[] data = new byte[512];
running = true;
while (running)
{
try // when the connection is forced close --> then here comes an exception (the connection. receive still wait for the data even though the client is not connected)
{
int byteRead = connection.Receive(data); // save received data in the buffer
string msg = System.Text.Encoding.UTF8.GetString(data, 0, byteRead);
if (msg.StartsWith("@quit"))
{
Close();
}
else
{
int split = msg.IndexOf(":");
Username = msg.Substring(0, split);
string msgText = msg.Substring(split + 1).Trim();
ReceivedMsg?.Invoke(this, msgText);
}
}
catch (Exception)
{
}
}
}
//---readers
void StartFightMessage_Reader(ReceivedMsg receivedMsg, StartFightMessage msg)
{
if (FightStart != null)
{
FightStart.Invoke();
}
}
//---readers
void FightCteated_Reader(ReceivedMsg receivedMsg, FightCteatedMessage msg)
{
FightController fightController = new FightController(_client, msg.KnifeIndex);
EnemyDef enemyDef = new EnemyDef(msg.EnemyUserName, msg.EnemyKnifeName, msg.EnemyKnifeMode);
FigthCreated?.Invoke(this, fightController, enemyDef);
}
//---msg readers
private void AuthenticationMsgReader(ReceivedMsg receivedMsg, AuthenticationMessage msg)
{
UserAuthenticationState autState;
if (_authenticationStates.TryGetValue((IScsServerClient)receivedMsg.Sender, out autState))
{
autState.Step1_MsgReader(receivedMsg, msg);
if (autState.State == UserAuthenticationState.AuthenticationState.Success)
{
// Удаляем аутентификатор
_authenticationStates.Remove(autState.ScsClient);
//Сначала добавляем потом удаляем, чтобы не бьыло ни наносекунды, когда никто не слушает клиента
//_msgQueue.AddMessenger(autState.ScsClient);
//_msgQueueForAutentification.RemoveMessenger(autState.ScsClient);
_authenticatedUsers.Add(autState.ScsClient, autState.User);
autState.ScsClient.SendMessage(new AuthenticationSuccesMessage());
OnUserLogin?.Invoke(this, new UserEventArgs(autState.User));
}
}
else
{
Console.WriteLine(GetType().Name + " :AuthenticationMsgReader error login=" + msg.login);
}
}
// make object from json sent from watch
void MakeObjectFromJson()
{
DataArrayModel dataArrayModel;
// filter the received watch json empty 8888 to *
string filterEmpty = ReceivedMsg.Replace("8888", "*");
dataArrayModel = JsonConvert.DeserializeObject <DataArrayModel>(filterEmpty);
// get workout name and reps then removes from DataArrayModel
List <string> watchWorkoutTitle = dataArrayModel.DataArray[dataArrayModel.DataArray.Count - 1];
dataArrayModel.DataArray.RemoveAt(dataArrayModel.DataArray.Count - 1);
List <string> watchReps = dataArrayModel.DataArray[dataArrayModel.DataArray.Count - 1];
dataArrayModel.DataArray.RemoveAt(dataArrayModel.DataArray.Count - 1);
WatchModel watchModel = ConvertWatchJsonToWatchModel(watchWorkoutTitle, watchReps, dataArrayModel.DataArray);
globalWatchModelHold = watchModel;
ListViewWorkouts(watchModel);
UploadButtonBool = true;
}
//---msg readers
void OnTestMessage(ReceivedMsg receivedMsg, TestMessage msg)
{
if (msg._state == TestMessage.State.Step_SendMsg_And_GetResponse_FromAllClients_UsingConcurrentEventQueue_And_MsgReadersCollection_2)
{
ScsServiseTest.Step_SendMsg_And_GetResponse_FromAllClients_UsingConcurrentEventQueue_And_MsgReadersCollection.IncrimentCounter(GetUser(receivedMsg).Login);
}
}
//---readers
void UserThroKnife_Reader(ReceivedMsg receivedMsg, ThrowKnifeMessage msg)
{
if (_fight.CanThrow(_knifeIndex))
{
_fight.ThrowKnife(_knifeIndex, msg.Input);
}
}
void Messenger_MessageReceived(object sender, MessageEventArgs e)
{
ReceivedMsg msg = new ReceivedMsg((IMessenger)sender, e.Message);
lock (_lockObject)
{
_msgQueue.Enqueue(msg);
}
}
public void Stem1_MsgReader(ReceivedMsg msg, AuthenticationSuccesMessage authenticationMessage)
{
if (State == AuthenticationState.Processing)
{
State = AuthenticationState.Success;
}
Stop();
}
public void UpdateRoom(string strMsgId, string strSenderSid, string strMsgSid, IList <string> arActiveMemberSids, string strSid, int nUnReadMsgCount,
ContentType contentType, string strContent, long lLastMsgDate, string strThumbnailPath)
{
var FindedRoom = this.m_Rooms.FirstOrDefault(r => r.Sid == strSid);
if (null != FindedRoom)
{
var RoomCollection = ConnectionHelper.DB.GetCollection <RoomEntity>("RoomEntity");
var FindRoomQuery = Query <RoomEntity> .EQ(r => r.Sid, strSid);
RoomEntity FindedRoomEntity = RoomCollection.FindOne(FindRoomQuery);
if (null != FindedRoomEntity)
{
int nNewUnReadMsgCount = (FindedRoom.UnReadMsgCount + nUnReadMsgCount);
Application.Current.Dispatcher.BeginInvoke(DispatcherPriority.Send, new ThreadStart(() =>
{
FindedRoom.UnReadMsgCount = nNewUnReadMsgCount;
FindedRoom.LastMsgSummary = strContent;
FindedRoom.LastMsgDate = lLastMsgDate;
FindedRoom.ThumbnailPath = strThumbnailPath;
}));
var UpdateRoomQuery = Update <RoomEntity>
.Set(r => r.ActiveMemberSids, arActiveMemberSids)
.Set(r => r.UnReadMsgCount, nNewUnReadMsgCount)
.Set(r => r.LastMsgSummary, strContent)
.Set(r => r.LastMsgDate, lLastMsgDate)
.Set(r => r.ThumbnailPath, strThumbnailPath);
RoomCollection.Update(FindRoomQuery, UpdateRoomQuery);
if (true == this.m_ChattingRoomsDictionary.DoesExist(strSid))
{
var FindedChattingRoom = this.m_ChattingRoomsDictionary.GetValue(strSid);
if (null != FindedChattingRoom)
{
Application.Current.Dispatcher.BeginInvoke(DispatcherPriority.Send, new ThreadStart(() =>
{
bool bIsActivatedView = FindedChattingRoom.IsActiveChattingShellView();
ReceivedMsg rcvMsg = new ReceivedMsg(strMsgId, strSenderSid, strSid, strMsgSid, contentType, strContent,
lLastMsgDate, 0, strThumbnailPath, bIsActivatedView);
FindedChattingRoom.ChattingViewModel.ReceiveChatMsgCommand.Execute(rcvMsg);
if (true == bIsActivatedView)
{
this.ResetUnReadCountForRoom(strSid);
}
}));
}
}
}
}
}
void Messenger_MessageReceived(object sender, MessageEventArgs e)
{
ReceivedMsg msg = new ReceivedMsg((IMessenger)sender, e.Message);
Entry entry = new Entry()
{
msg = msg,
};
_entryQueue.Enqueue(entry);
Console.WriteLine(GetType().Name + " :Enqueue Mgg " + e.Message.GetType().Name);
}
void UserReadyToFight_Reader(ReceivedMsg receivedMsg, ReadyToFightMessage msg)
{
if (_waitForReady)
{
_waitForReady = false;
if (_fight.WaitForReady)
{
_fight.SetOneKnifeReady(_knifeIndex);
}
}
}
static public isaCommand OnMsgReceived(isaCommand cmd)
{
isaCommand retcmd = new Command {
command = cmd.command
};
//this routes back out to the client callback
if (ReceivedMsg != null)
{
retcmd = (isaCommand)ReceivedMsg?.Invoke(cmd);
}
return(retcmd);
}
void ThrowKnifeMessage_Reader(ReceivedMsg receivedMsg, ThrowKnifeMessage msg)
{
KnifeThrowEventArg arg = new KnifeThrowEventArg(
msg.KnifeId,
msg.Input,
msg.TimeNextThrow,
msg.TimeThrow);
if (KnifeThrow != null)
{
KnifeThrow.Invoke(arg);
}
}
private void TestMetgod(ReceivedMsg receivedMsg, TestMessage msg)
{
Console.WriteLine("TestMetgod");
if (msg._state == TestMessage.State.Step_SendMsg_And_GetResponse_FromAllClients_UsingConcurrentEventQueue_And_MsgReadersCollection_1)
{
receivedMsg.Sender.SendMessage(new TestMessage(
TestMessage.State.Step_SendMsg_And_GetResponse_FromAllClients_UsingConcurrentEventQueue_And_MsgReadersCollection_2
, "test msg"
));
}
Disconnect();
}
//--- msg readers
private void AuthenticationSuccessMsgReader(ReceivedMsg receivedMsg, AuthenticationSuccesMessage msg)
{
_authenticationState.Stem1_MsgReader(receivedMsg, msg);
if (_authenticationState.State == UserAuthenticationState.AuthenticationState.Success)
{
_authenticationState = null;
IsConnected = true;
if (OnUserLogin != null)
{
OnUserLogin();
}
}
}
public void Step1_MsgReader(ReceivedMsg receivedMsg, AuthenticationMessage authenticationMessage)
{
if (receivedMsg.Sender == ScsClient)
{
Console.WriteLine(GetType().Name + " :Get AuthenticationMessage " + authenticationMessage.login);
if (State == AuthenticationState.Processing)
{
User = new User(authenticationMessage.login, ScsClient);
State = AuthenticationState.Success;
//Console.WriteLine("Authentication Success login=" + authenticationMessage.login);
}
Stop();
}
}
void ReceiveAction(IAsyncResult ar)
{
int size = 0;
try
{
size = server.EndReceive(ar);
}
catch
{
if (Disconnected != null)
{
Disconnected.Invoke(server);
}
server.Close();
return;
}
if (size == 0)
{
if (Disconnected != null)
{
Disconnected.Invoke(server);
}
server.Close();
}
else
{
if (ReceivedMsg != null)
{
ReceivedMsg.Invoke(Server, buffer, size);
}
try
{
server.BeginReceive(buffer, 0, buffer.Length, SocketFlags.None, new AsyncCallback(ReceiveAction), null);
}
catch
{
if (Disconnected != null)
{
Disconnected.Invoke(server);
}
}
}
}
private void E_ReceivedMsg(object sender, string e)
{
if (e.StartsWith("@quit"))
{
var client = sender as ClientHandler;
ConnectedUsers.Remove(client.Username); // remove username
}
else
{
App.Current.Dispatcher.Invoke(() =>
{
var client = sender as ClientHandler;
ReceivedMsg.Add(client.Username + ":" + e);
RaisePropertyChanged(nameof(CountMsg));
if (!ConnectedUsers.Contains(client.Username))
{
ConnectedUsers.Add(client.Username);
}
});
}
}
private void ExecuteReceiveChatMsgCommand(ReceivedMsg rcvMsg)
{
var MessageCollection = ConnectionHelper.DB.GetCollection <MessageEntity>("MessageEntity");
var FindMessageQuery = Query <MessageEntity> .EQ(m => m.Id, new ObjectId(rcvMsg.Id));
var FindedMessage = MessageCollection.FindOne(FindMessageQuery);
var UserCollection = ConnectionHelper.DB.GetCollection <UserEntity>("UserEntity");
var FindUserQuery = Query <UserEntity> .EQ(u => u.Sid, rcvMsg.SenderSid);
var FindedUser = UserCollection.FindOne(FindUserQuery);
if (null != FindedUser && null != FindedMessage)
{
string strFindedUserSid = FindedUser.Sid;
if (string.IsNullOrEmpty(rcvMsg.ThumbnailPath))
{
if (false == this.m_AnonymousThumbnailDictionary.ContainsKey(strFindedUserSid))
{
this.m_AnonymousThumbnailDictionary.Add(strFindedUserSid, ColorGenerator.Instance.GetRandomBrush());
}
}
var RcvMessage = new OpponentMsg(rcvMsg.Id, rcvMsg.Sid, rcvMsg.RoomSid, rcvMsg.Content, rcvMsg.ContentType,
rcvMsg.SendTime, MsgStatus.Received, rcvMsg.ReadMembersCount, FindedUser.NickName, rcvMsg.ThumbnailPath,
this.m_AnonymousThumbnailDictionary[strFindedUserSid]);
this.Messages.Add(RcvMessage);
this.EndReceiveMsgCommand(RcvMessage);
var WillAddUnReadMsg = new UnReadMsg(FindedMessage.Id, FindedMessage.ReadMembers, rcvMsg.Sid, rcvMsg.RoomSid, AuthRepository.MQKeyInfo.UserSid);
this.m_UnReadMessages.Add(WillAddUnReadMsg);
if (true == rcvMsg.IsActivatedView)
{
this.RequestReadMsgs();
}
}
}
/// <summary>
/// 接受操作
/// </summary>
/// <param name="ar">Sokcet连接异步结果</param>
private void ReceiveAction()
{
try
{
while (true)
{
byte[] vs = new byte[8];
server.Receive(vs);
BinaryReader br = new BinaryReader(new MemoryStream(vs));
int head = br.ReadInt32();
int len = br.ReadInt32();
br.Dispose();
if (head == 0x544F4332)
{
byte[] vs1 = new byte[0];
Array.Resize(ref vs1, len);
server.Receive(vs1);
try //控制异常范围
{
ReceivedMsg.Invoke(this, server, vs1, len);
}
catch
{
}
}
else
{
throw new Exception(); //抛出异常实现什么都不做
}
}
}
catch
{
Disconnected.Invoke(this, server);
server.Dispose();
}
}
public void WaitToRecieveData()
{
byte[] data = new byte[512];
running = true;
while (running)
{
try
{
int byteRead = connection.Receive(data);
string msg = System.Text.Encoding.UTF8.GetString(data, 0, byteRead);
if (msg.StartsWith("@quit"))
{
Disconnect();
}
else
{
ReceivedMsg?.Invoke(this, msg);
}
}
catch (Exception)
{
}
}
}
int GetUserIndex(ReceivedMsg msg)
{
return(ScsServiseTest.GetUserIndexFromLogin(GetUser(msg).Login));
}
//---Users
User GetUser(ReceivedMsg msg)
{
return(_users[msg.Sender]);
}
//---msg readrs
void FightQueueMessage_Reader(ReceivedMsg receivedMsg, FightQueueMessage msg)
{
// TODO проверку чтобы 2 раза в очередь нельзя было вставать
UserFightQueue.Entry entry = new UserFightQueue.Entry(_controllersFactory, msg.KnifeName, msg.KnifeMode);
_userFightQueue.Enqueue(entry);
}
private void OnSessionReceived(HcToolInfo info, Command cmd, int addr, int[] values)
{
ReceivedMsg?.Invoke(info, cmd, addr, values);
}
private void ClearMsg(object sender, RoutedEventArgs e)
{
ReceivedMsg.Clear();
}
//private void AppendTextBox(string appendix)
//{
// if (ReceivedMsg.Text.Trim().Length <= 0)
// {
// ReceivedMsg.AppendText(DateTime.Now.ToString("hh:mm:ss") + " : " + appendix);
// ReceivedMsg.ScrollToEnd();
// }
// else
// {
// ReceivedMsg.AppendText("\n" + DateTime.Now.ToString("hh:mm:ss") + " : " + appendix);
// ReceivedMsg.ScrollToEnd();
// }
//}
private void AppendTextBox(string appendix)
{
ReceivedMsg.AppendText(appendix);
ReceivedMsg.ScrollToEnd();
}
