Example #1
0
 public override void Show(object param = null)
 {
     base.Show(param);
     MessageDispatcher.GetInstance().RegisterMessageHandler((uint)EUIMessage.UPDATE_CHAT_LIST, OnUpdateChatList);
     RefreshChatFrames();
 }
Example #2
0
 public override void Hide()
 {
     base.Hide();
     MessageDispatcher.GetInstance().UnRegisterMessageHandler((uint)EUIMessage.UPDATE_CHAT_LIST, OnUpdateChatList);
 }
 public override void OnHide()
 {
     base.OnHide();
     MessageDispatcher.GetInstance().UnRegisterMessageHandler((uint)EUIMessage.UPDATE_FRIEND_DETAIL, OnUpdateFriendDetail);
 }
Example #4
0
 public override void OnHide()
 {
     base.OnHide();
     MessageDispatcher.GetInstance().UnRegisterMessageHandler((uint)ENetworkMessage.GET_USERINFO_RSP, OnGetUserInfoRsp);
 }
Example #5
0
 public override void OnHide()
 {
     base.OnHide();
     MessageDispatcher.GetInstance().UnRegisterMessageHandler((uint)ENetworkMessage.LOGIN_RSP, OnLoginRsp);
     MessageDispatcher.GetInstance().UnRegisterMessageHandler((uint)EModelMessage.REQ_TIMEOUT, OnReqTimeOut);
 }
 public override void OnShow(object param = null)
 {
     base.OnShow(param);
     MessageDispatcher.GetInstance().RegisterMessageHandler((uint)EUIMessage.UPDATE_FRIEND_DETAIL, OnUpdateFriendDetail);
 }
        private void RemoveMsgID(string msgID)
        {
            _msgIDDict.Remove(msgID);

            MessageDispatcher.GetInstance().DispatchMessageAsync((uint)EModelMessage.REQ_FINISH, null);
        }
        private void EndReceivePacket(IAsyncResult ar)
        {
            int bytesRead = -1;

            try
            {
                if (IsConncted)
                {
                    lock (_socket)
                    {
                        bytesRead = _socket.EndReceive(ar);
                    }
                }

                if (bytesRead == -1)
                {
                    CloseConnection();
                    return;
                }
            }
            catch (ObjectDisposedException)
            {
                Log4U.LogInfo("Receive Closed");
            }
            catch (Exception ex)
            {
                Log4U.LogError(ex.Message + "\n " + ex.StackTrace + "\n" + ex.Source);
            }


            // Begin Read //
            int position = 0;

            while (position < bytesRead)
            {
                int             bufferSize     = MiniConverter.BytesToInt(_receiveBuffer, position + HEAD_SIZE * 0);
                ENetworkMessage networkMessage = (ENetworkMessage)MiniConverter.BytesToInt(_receiveBuffer, position + HEAD_SIZE * 1);

                byte[] msgIDBytes = new byte[HEAD_SIZE];
                for (int i = 0; i < HEAD_SIZE; i++)
                {
                    msgIDBytes[i] = _receiveBuffer[position + HEAD_SIZE * 2 + i];
                }
                string msgID = BitConverter.ToString(msgIDBytes);

                if (networkMessage != ENetworkMessage.KEEP_ALIVE_SYNC)
                {
                    Log4U.LogInfo("networkMessage : " + networkMessage, "msgID : " + msgID, "bufferSize : " + bufferSize);
                }

                if (position + bufferSize > bytesRead)
                {
                    Log4U.LogError("Error receive packet, packet is too long : " + bufferSize);
                    break;
                }

                IExtensible rspPacket = UnPackTool.UnPack(networkMessage, position + HEAD_SIZE * HEAD_NUM, bufferSize - HEAD_NUM * HEAD_SIZE, _receiveBuffer);
                if (rspPacket == null)
                {
                    continue;
                }

                MessageArgs args = new MessageArgs
                {
                    iMessageType = (uint)networkMessage,
                    kParam       = rspPacket,
                };

                NetworkMessageParam networkParam = new NetworkMessageParam
                {
                    rsp   = rspPacket,
                    msgID = msgID,
                };

                lock (_msgIDDict)
                {
                    if (_msgIDDict.ContainsKey(msgID))
                    {
                        networkParam.req = _msgIDDict[msgID];
                    }

                    if (_needReqMessageType.Contains(networkMessage))
                    {
                        args.kParam = networkParam;
                    }

                    if (_forcePushMessageType.Contains(networkMessage) || _msgIDDict.ContainsKey(msgID))
                    {
                        MessageDispatcher.GetInstance().DispatchMessageAsync(args.iMessageType, args.kParam);
                    }

                    if (_msgIDDict.ContainsKey(msgID))
                    {
                        RemoveMsgID(msgID);
                    }
                }

                //if (_forcePushMessageType.Contains(networkMessage))
                //{
                //    DoBeginSendPacket(networkMessage, msgIDBytes);
                //}

                position += bufferSize;
            }

            Array.Clear(_receiveBuffer, 0, _socket.ReceiveBufferSize);

            BeginReceivePacket();
        }
 public override void OnHide()
 {
     base.OnHide();
     MessageDispatcher.GetInstance().UnRegisterMessageHandler((uint)EUIMessage.TOGGLE_GROUP_MEMBER, OnToggleGroupMember);
     MessageDispatcher.GetInstance().UnRegisterMessageHandler((uint)ENetworkMessage.CREATE_GROUP_CHAT_RSP, OnCreateGroupRsp);
 }
 public override void Hide()
 {
     base.Hide();
     MessageDispatcher.GetInstance().UnRegisterMessageHandler((uint)EUIMessage.UPDATE_PERSONAL_DETAIL, OnUpdatePersonalDetail);
 }
 public override void Init()
 {
     base.Init();
     MessageDispatcher.GetInstance().RegisterMessageHandler((uint)EModelMessage.SOCKET_CONNECTED, OnSocketConnected);
     MessageDispatcher.GetInstance().RegisterMessageHandler((uint)EModelMessage.SOCKET_DISCONNECTED, OnSocketDisConnected);
 }