Exemplo n.º 1
0
        public void TestLife(float deltaTime)
        {
            List <uint> list = new List <uint>();

            foreach (uint num in this.seqMessageCollection.Keys)
            {
                ApolloMessage message = this.seqMessageCollection[num];
                if (message != null)
                {
                    message.Life -= deltaTime;
                    if (message.Life <= 0f)
                    {
                        list.Add(num);
                        if (message.Handler != null)
                        {
                            TalkerEventArgs e = new TalkerEventArgs(ApolloResult.Timeout)
                            {
                                Context  = message.Context,
                                Response = null
                            };
                            message.Handler(message.Request, e);
                        }
                    }
                }
            }
            foreach (uint num2 in list)
            {
                this.seqMessageCollection.Remove(num2);
            }
        }
Exemplo n.º 2
0
 private void pushApolloMessage(ApolloMessage msg)
 {
     if (msg != null)
     {
         this.apolloMessageCollections.Add(msg);
     }
 }
Exemplo n.º 3
0
 private void onRecvedData()
 {
     ADebug.Log("onRecvedData OnDataRecvedProc");
     while (true)
     {
         int    num;
         byte[] buffer = null;
         if (this.connector.ReadData(out buffer, out num) != ApolloResult.Success)
         {
             return;
         }
         try
         {
             ApolloMessage message = ApolloMessageManager.Instance.UnpackResponseData(buffer, num);
             if (message != null)
             {
                 ADebug.Log(string.Concat(new object[] { "Recved:", message.Command, " and resp is:", message.Response }));
                 ADebug.Log(string.Concat(new object[] { "OnDataRecvedProc: apolloMessage.Handler != null?: ", message.Handler != null, " apolloMessage.HandlerWithReceipt != null?: ", message.HandlerWithReceipt != null, " apolloMessage.HandlerWithoutReceipt != null?: ", message.HandlerWithoutReceipt != null }));
                 message.HandleMessage();
             }
             else
             {
                 ADebug.LogError("OnDataRecvedProc UnpackResponseData error");
             }
         }
         catch (Exception exception)
         {
             ADebug.LogException(exception);
         }
     }
 }
Exemplo n.º 4
0
 public ApolloResult Send(TalkerMessageType type, TalkerCommand command, byte[] bodyData, int usedSize, ApolloMessage message)
 {
     if (command == null || bodyData == null || usedSize <= 0)
     {
         return(ApolloResult.InvalidArgument);
     }
     byte[] array = null;
     if (message == null)
     {
         message = new ApolloMessage();
     }
     if (message.PackRequestData(command, bodyData, usedSize, out array, type))
     {
         ADebug.Log(string.Concat(new object[]
         {
             "Sending:",
             command,
             " data size:",
             array.Length
         }));
         return(this.connector.WriteData(array, -1));
     }
     ADebug.LogError("Send: " + command + " msg.PackRequestData error");
     return(ApolloResult.InnerError);
 }
Exemplo n.º 5
0
        private ApolloResult SendNotice(IPackable request)
        {
            ADebug.Log("SendNotice:" + request);
            ApolloMessage message = new ApolloMessage();

            return(this.Send(TalkerMessageType.Notice, new TalkerCommand(TalkerCommand.CommandDomain.App, request), request, message));
        }
Exemplo n.º 6
0
        internal ApolloResult SendNotice(TalkerCommand command, IPackable request)
        {
            ADebug.Log("SendNotice:" + request);
            ApolloMessage message = new ApolloMessage();

            return(this.Send(TalkerMessageType.Notice, command, request, message));
        }
Exemplo n.º 7
0
        internal ApolloResult SendReceipt <TResp>(IPackable request, uint asyncFlag) where TResp : IUnpackable
        {
            ApolloMessage apolloMessage = new ApolloMessage();

            apolloMessage.AsyncFlag = asyncFlag;
            return(this.Send(TalkerMessageType.Response, new TalkerCommand(TalkerCommand.CommandDomain.App, request), request, apolloMessage));
        }
Exemplo n.º 8
0
 public ApolloResult Send(TalkerMessageType type, TalkerCommand command, IPackable request, ApolloMessage message)
 {
     if (command == null || request == null)
     {
         return(ApolloResult.InvalidArgument);
     }
     byte[] array = null;
     if (message == null)
     {
         message = new ApolloMessage();
     }
     if (message.PackRequestData(command, request, out array, type))
     {
         ADebug.Log(string.Concat(new object[]
         {
             "Sending:",
             command,
             " data size:",
             array.Length
         }));
         ApolloResult apolloResult = this.connector.WriteData(array, -1);
         if (apolloResult == ApolloResult.Success && message.Handler != null)
         {
             ApolloMessageManager.Instance.SeqMessageCollection.Add(message.SeqNum, message);
         }
         return(apolloResult);
     }
     ADebug.LogError("Send: " + command + " msg.PackRequestDat error");
     return(ApolloResult.InnerError);
 }
Exemplo n.º 9
0
 public void RemoveMessage(ApolloMessage msg)
 {
     if (ApolloMessageManager.Instance.SeqMessageCollection.ContainsKey(msg.SeqNum))
     {
         ApolloMessageManager.Instance.Remove(msg.SeqNum);
     }
     else if (ApolloMessageManager.Instance.Exist(msg.Command))
     {
         ApolloMessageManager.Instance.Remove(msg.Command);
     }
 }
Exemplo n.º 10
0
 public ApolloResult Register(TalkerCommand command, RawMessageHandler handler)
 {
     if (command != null && handler != null)
     {
         if (ApolloMessageManager.Instance.Exist(command))
         {
         }
         ApolloMessage apolloMessage = new ApolloMessage(command);
         apolloMessage.RawMessageHandler = handler;
         ApolloMessageManager.Instance.Add(apolloMessage);
         return(ApolloResult.Success);
     }
     return(ApolloResult.InvalidArgument);
 }
Exemplo n.º 11
0
        public ApolloResult Register(TalkerCommand command, RawMessageHandler handler)
        {
            if ((command == null) || (handler == null))
            {
                return(ApolloResult.InvalidArgument);
            }
            if (ApolloMessageManager.Instance.Exist(command))
            {
            }
            ApolloMessage message = new ApolloMessage(command)
            {
                RawMessageHandler = handler
            };

            ApolloMessageManager.Instance.Add(message);
            return(ApolloResult.Success);
        }
Exemplo n.º 12
0
 private void onRecvedData()
 {
     ADebug.Log("onRecvedData OnDataRecvedProc");
     while (true)
     {
         byte[]       data = null;
         int          realSize;
         ApolloResult apolloResult = this.connector.ReadData(out data, out realSize);
         if (apolloResult != ApolloResult.Success)
         {
             break;
         }
         try
         {
             ApolloMessage apolloMessage = ApolloMessageManager.Instance.UnpackResponseData(data, realSize);
             if (apolloMessage != null)
             {
                 ADebug.Log(string.Concat(new object[]
                 {
                     "Recved:",
                     apolloMessage.Command,
                     " and resp is:",
                     apolloMessage.Response
                 }));
                 ADebug.Log(string.Concat(new object[]
                 {
                     "OnDataRecvedProc: apolloMessage.Handler != null?: ",
                     apolloMessage.Handler != null,
                     " apolloMessage.HandlerWithReceipt != null?: ",
                     apolloMessage.HandlerWithReceipt != null,
                     " apolloMessage.HandlerWithoutReceipt != null?: ",
                     apolloMessage.HandlerWithoutReceipt != null
                 }));
                 apolloMessage.HandleMessage();
             }
             else
             {
                 ADebug.LogError("OnDataRecvedProc UnpackResponseData error");
             }
         }
         catch (Exception exception)
         {
             ADebug.LogException(exception);
         }
     }
 }
Exemplo n.º 13
0
 public void Add(ApolloMessage message)
 {
     if (message != null)
     {
         if (message.IsRequest)
         {
             this.SeqMessageCollection.Add(message.SeqNum, message);
         }
         else if (this.CmdMessageCollection.ContainsKey(message.Command))
         {
             this.CmdMessageCollection[message.Command] = message;
         }
         else
         {
             this.CmdMessageCollection.Add(message.Command, message);
         }
     }
 }
Exemplo n.º 14
0
 public ApolloResult Register <TResp>(TalkerCommand command, TalkerMessageWithoutReceiptHandler <TResp> handler) where TResp : IUnpackable
 {
     if (command != null && handler != null)
     {
         ADebug.Log("Register:" + command);
         if (ApolloMessageManager.Instance.Exist(command))
         {
         }
         ApolloMessage apolloMessage = new ApolloMessage(command);
         apolloMessage.RespType = typeof(TResp);
         apolloMessage.HandlerWithoutReceipt = delegate(IUnpackable resp)
         {
             handler((TResp)((object)resp));
         };
         ApolloMessageManager.Instance.Add(apolloMessage);
         return(ApolloResult.Success);
     }
     return(ApolloResult.InvalidArgument);
 }
Exemplo n.º 15
0
        public ApolloResult Send <TResp>(TalkerMessageType type, TalkerCommand command, IPackable request, TalkerMessageHandler <TResp> handler, object context, float timeout) where TResp : IUnpackable
        {
            ApolloMessage apolloMessage = new ApolloMessage();

            apolloMessage.RespType = typeof(TResp);
            apolloMessage.Context  = context;
            apolloMessage.Life     = timeout;
            if (handler != null)
            {
                apolloMessage.Handler = delegate(object req, TalkerEventArgs loginInfo)
                {
                    if (handler != null)
                    {
                        TalkerEventArgs <TResp> talkerEventArgs = new TalkerEventArgs <TResp>(loginInfo.Result, loginInfo.ErrorMessage);
                        talkerEventArgs.Response = (TResp)((object)loginInfo.Response);
                        talkerEventArgs.Context  = loginInfo.Context;
                        handler(req, talkerEventArgs);
                    }
                };
            }
            return(this.Send(type, command, request, apolloMessage));
        }
Exemplo n.º 16
0
 internal ApolloResult Register <TResp, TReceipt>(TalkerCommand command, TalkerMessageWithReceiptHandler <TResp, TReceipt> handler) where TResp : IUnpackable where TReceipt : IPackable
 {
     if (command != null && handler != null)
     {
         if (ApolloMessageManager.Instance.Exist(command))
         {
         }
         ApolloMessage apolloMessage = new ApolloMessage(command);
         apolloMessage.RespType           = typeof(TResp);
         apolloMessage.ReceiptType        = typeof(TReceipt);
         apolloMessage.Talker             = this;
         apolloMessage.HandlerWithReceipt = delegate(IUnpackable resp, ref IPackable receipt)
         {
             TReceipt tReceipt = default(TReceipt);
             handler((TResp)((object)resp), ref tReceipt);
             receipt = tReceipt;
             ADebug.Log("Register receipt:" + (receipt != null));
         };
         ApolloMessageManager.Instance.Add(apolloMessage);
         return(ApolloResult.Success);
     }
     return(ApolloResult.InvalidArgument);
 }
Exemplo n.º 17
0
        private bool popAndHandleApolloMessage()
        {
            if (this.apolloMessageCollections.Count == 0)
            {
                return(false);
            }
            ADebug.Log("popAndHandleApolloMessage: " + this.apolloMessageCollections.Count);
            ApolloMessage next = this.apolloMessageCollections.Next;

            if (next != null)
            {
                if (next.Handler != null)
                {
                    TalkerEventArgs e = new TalkerEventArgs(next.Response, next.Context);
                    next.Handler(next.Request, e);
                }
                if (next.HandlerWithoutReceipt != null)
                {
                    next.HandlerWithoutReceipt(next.Response);
                }
                if (next.HandlerWithReceipt != null)
                {
                    IPackable receipt = null;
                    next.HandlerWithReceipt(next.Response, ref receipt);
                    if (receipt != null)
                    {
                        ADebug.Log("HandlerWithReceipt receipt:" + receipt);
                        this.SendReceipt <NullResponse>(receipt, next.AsyncFlag);
                    }
                }
                if (next.IsRequest)
                {
                    ApolloMessageManager.Instance.RemoveMessage(next);
                }
            }
            return(true);
        }
Exemplo n.º 18
0
        public void TestLife(float deltaTime)
        {
            List <uint> list = new List <uint>();

            using (Dictionary <uint, object> .KeyCollection.Enumerator enumerator = this.seqMessageCollection.Keys.GetEnumerator())
            {
                while (enumerator.MoveNext())
                {
                    uint          current       = enumerator.get_Current();
                    ApolloMessage apolloMessage = this.seqMessageCollection[current];
                    if (apolloMessage != null)
                    {
                        apolloMessage.Life -= deltaTime;
                        if (apolloMessage.Life <= 0f)
                        {
                            list.Add(current);
                            if (apolloMessage.Handler != null)
                            {
                                TalkerEventArgs talkerEventArgs = new TalkerEventArgs(ApolloResult.Timeout);
                                talkerEventArgs.Context  = apolloMessage.Context;
                                talkerEventArgs.Response = null;
                                apolloMessage.Handler(apolloMessage.Request, talkerEventArgs);
                            }
                        }
                    }
                }
            }
            using (List <uint> .Enumerator enumerator2 = list.GetEnumerator())
            {
                while (enumerator2.MoveNext())
                {
                    uint current2 = enumerator2.get_Current();
                    this.seqMessageCollection.Remove(current2);
                }
            }
        }
Exemplo n.º 19
0
        public ApolloMessage UnpackResponseData(byte[] data, int realSize)
        {
            int        num2;
            TalkerHead head = new TalkerHead();
            int        used = 0;

            TdrError.ErrorType type = head.unpackTLV(ref data, realSize, ref used);
            if (type != TdrError.ErrorType.TDR_NO_ERROR)
            {
                ADebug.LogError("UnpackResponseData head.unpack error:" + type);
                return(null);
            }
            TalkerCommand.CommandDomain bDomain = (TalkerCommand.CommandDomain)head.bDomain;
            TalkerCommand command = null;

            switch (((CMD_FMT)head.bCmdFmt))
            {
            case CMD_FMT.CMD_FMT_INT:
                if (head.stCommand != null)
                {
                    command = new TalkerCommand(bDomain, (uint)head.stCommand.iIntCmd);
                }
                goto Label_0103;

            case CMD_FMT.CMD_FMT_NIL:
                command = new TalkerCommand(bDomain, TalkerCommand.CommandValueType.Raw);
                goto Label_0103;

            default:
                if ((head.stCommand == null) || (head.stCommand.szStrCmd == null))
                {
                    goto Label_0103;
                }
                num2 = 0;
                for (int i = 0; i < head.stCommand.szStrCmd.Length; i++)
                {
                    num2 = i;
                    if (head.stCommand.szStrCmd[i] == 0)
                    {
                        break;
                    }
                }
                break;
            }
            string str = Encoding.UTF8.GetString(head.stCommand.szStrCmd, 0, num2);

            command = new TalkerCommand(bDomain, str);
Label_0103:
            if (command == null)
            {
                ADebug.LogError("With command is null");
                return(null);
            }
            ApolloMessage message = null;

            if (ApolloMessage.GetMessageType(head.bFlag) == TalkerMessageType.Response)
            {
                if (Instance.SeqMessageCollection.ContainsKey(head.dwAsync))
                {
                    message = Instance.SeqMessageCollection[head.dwAsync];
                }
                if (message != null)
                {
                    message.AsyncFlag = head.dwAsync;
                    if (message.IsRequest && (head.dwAsync != message.SeqNum))
                    {
                        if (head.dwAsync != message.SeqNum)
                        {
                            ADebug.Log(string.Format("UnpackResponseData error: if(head.dwSeqNum({0}) != seqNum({1})", head.dwAsync, message.SeqNum));
                        }
                        else
                        {
                            ADebug.Log(string.Concat(new object[] { "UnpackResponseData error compare result:", command.Equals(message.Command), " msg.command:", message.Command, " cmd:", command }));
                        }
                        return(null);
                    }
                }
            }
            else
            {
                message = this.Get(command);
                if (message != null)
                {
                    ADebug.Log(string.Concat(new object[] { "cmd:", command, " msg receipt handler:", message.HandlerWithReceipt != null, " without receipt handler:", message.HandlerWithoutReceipt != null }));
                }
            }
            if (message == null)
            {
                ADebug.LogError(string.Concat(new object[] { "UnpackResponseData error: msg == null while seq:", head.dwAsync, " cmd:", command, " type:", ApolloMessage.GetMessageType(head.bFlag) }));
                return(null);
            }
            ADebug.Log(string.Concat(new object[] { "UnpackResponseData msg.Command:", message.Command, " type:", ApolloMessage.GetMessageType(head.bFlag) }));
            if (realSize < used)
            {
                ADebug.LogError(string.Format("realSize{0} < usedSize({1})", realSize, used));
                return(null);
            }
            byte[] destinationArray = new byte[realSize - used];
            Array.Copy(data, used, destinationArray, 0, destinationArray.Length);
            if (message.RespType != null)
            {
                message.Response = Activator.CreateInstance(message.RespType) as IUnpackable;
                if (message.Response != null)
                {
                    type = message.Response.unpackTLV(ref destinationArray, destinationArray.Length, ref used);
                    if (type != TdrError.ErrorType.TDR_NO_ERROR)
                    {
                        ADebug.Log("UnpackResponseData resp.unpack error:" + type);
                        return(null);
                    }
                }
                return(message);
            }
            message.RawData = destinationArray;
            return(message);
        }
Exemplo n.º 20
0
        public ApolloMessage UnpackResponseData(byte[] data, int realSize)
        {
            TalkerHead talkerHead = new TalkerHead();
            int        num        = 0;

            TdrError.ErrorType errorType = talkerHead.unpackTLV(ref data, realSize, ref num);
            if (errorType != TdrError.ErrorType.TDR_NO_ERROR)
            {
                ADebug.LogError("UnpackResponseData head.unpack error:" + errorType);
                return(null);
            }
            TalkerCommand.CommandDomain bDomain = (TalkerCommand.CommandDomain)talkerHead.bDomain;
            TalkerCommand talkerCommand         = null;
            CMD_FMT       bCmdFmt = (CMD_FMT)talkerHead.bCmdFmt;

            if (bCmdFmt == CMD_FMT.CMD_FMT_INT)
            {
                if (talkerHead.stCommand != null)
                {
                    talkerCommand = new TalkerCommand(bDomain, (uint)talkerHead.stCommand.iIntCmd);
                }
            }
            else if (bCmdFmt == CMD_FMT.CMD_FMT_NIL)
            {
                talkerCommand = new TalkerCommand(bDomain, TalkerCommand.CommandValueType.Raw);
            }
            else if (talkerHead.stCommand != null && talkerHead.stCommand.szStrCmd != null)
            {
                int num2 = 0;
                for (int i = 0; i < talkerHead.stCommand.szStrCmd.Length; i++)
                {
                    num2 = i;
                    if (talkerHead.stCommand.szStrCmd[i] == 0)
                    {
                        break;
                    }
                }
                string @string = Encoding.get_UTF8().GetString(talkerHead.stCommand.szStrCmd, 0, num2);
                talkerCommand = new TalkerCommand(bDomain, @string);
            }
            if (talkerCommand == null)
            {
                ADebug.LogError("With command is null");
                return(null);
            }
            ApolloMessage     apolloMessage = null;
            TalkerMessageType messageType   = ApolloMessage.GetMessageType((int)talkerHead.bFlag);

            if (messageType == TalkerMessageType.Response)
            {
                if (ApolloMessageManager.Instance.SeqMessageCollection.ContainsKey(talkerHead.dwAsync))
                {
                    apolloMessage = ApolloMessageManager.Instance.SeqMessageCollection[talkerHead.dwAsync];
                }
                if (apolloMessage != null)
                {
                    apolloMessage.AsyncFlag = talkerHead.dwAsync;
                    if (apolloMessage.IsRequest && talkerHead.dwAsync != apolloMessage.SeqNum)
                    {
                        if (talkerHead.dwAsync != apolloMessage.SeqNum)
                        {
                            ADebug.Log(string.Format("UnpackResponseData error: if(head.dwSeqNum({0}) != seqNum({1})", talkerHead.dwAsync, apolloMessage.SeqNum));
                        }
                        else
                        {
                            ADebug.Log(string.Concat(new object[]
                            {
                                "UnpackResponseData error compare result:",
                                talkerCommand.Equals(apolloMessage.Command),
                                " msg.command:",
                                apolloMessage.Command,
                                " cmd:",
                                talkerCommand
                            }));
                        }
                        return(null);
                    }
                }
            }
            else
            {
                apolloMessage = this.Get(talkerCommand);
                if (apolloMessage != null)
                {
                    ADebug.Log(string.Concat(new object[]
                    {
                        "cmd:",
                        talkerCommand,
                        " msg receipt handler:",
                        apolloMessage.HandlerWithReceipt != null,
                        " without receipt handler:",
                        apolloMessage.HandlerWithoutReceipt != null
                    }));
                }
            }
            if (apolloMessage == null)
            {
                ADebug.LogError(string.Concat(new object[]
                {
                    "UnpackResponseData error: msg == null while seq:",
                    talkerHead.dwAsync,
                    " cmd:",
                    talkerCommand,
                    " type:",
                    ApolloMessage.GetMessageType((int)talkerHead.bFlag)
                }));
                return(null);
            }
            ADebug.Log(string.Concat(new object[]
            {
                "UnpackResponseData msg.Command:",
                apolloMessage.Command,
                " type:",
                ApolloMessage.GetMessageType((int)talkerHead.bFlag)
            }));
            if (realSize < num)
            {
                ADebug.LogError(string.Format("realSize{0} < usedSize({1})", realSize, num));
                return(null);
            }
            byte[] array = new byte[realSize - num];
            Array.Copy(data, num, array, 0, array.Length);
            if (apolloMessage.RespType != null)
            {
                apolloMessage.Response = (Activator.CreateInstance(apolloMessage.RespType) as IUnpackable);
                if (apolloMessage.Response != null)
                {
                    errorType = apolloMessage.Response.unpackTLV(ref array, array.Length, ref num);
                    if (errorType != TdrError.ErrorType.TDR_NO_ERROR)
                    {
                        ADebug.Log("UnpackResponseData resp.unpack error:" + errorType);
                        return(null);
                    }
                    return(apolloMessage);
                }
            }
            else
            {
                apolloMessage.RawData = array;
            }
            return(apolloMessage);
        }