Example #1
0
    public void ReadMessage(int newDataAmount, Action <RequestCode, string> processDataCallback)
    {
        startIndex += newDataAmount;
        while (true)
        {
            if (startIndex <= COUNT_LEN)
            {
                return;
            }
            int count = BitConverter.ToInt32(data, 0);
            if (startIndex - COUNT_LEN >= count)
            {
                RequestCode requestCode = (RequestCode)BitConverter.ToInt32(data, 4);

                string s = Encoding.UTF8.GetString(data, COUNT_LEN + Request_code_len, count - Request_code_len);
                Console.WriteLine("Recevied: " + s);
                processDataCallback(requestCode, s);

                Array.Copy(data, COUNT_LEN + count, data, 0, startIndex - count - COUNT_LEN);
                startIndex = startIndex - count - COUNT_LEN;
            }
            else
            {
                break;
            }
        }
    }
Example #2
0
        /// <summary>
        /// 读取接收的消息。并做粘包处理
        /// </summary>
        /// <param name="newDataAmount"></param>
        public void ReadMessage(int newDataAmount, Action <RequestCode, ActionCode, string> processDataCallBack)
        {
            startIndex += newDataAmount;
            while (true)
            {
                if (startIndex <= 4)
                {
                    return;                  //消息长度都未解析出来
                }
                //获得消息的长度
                int count = BitConverter.ToInt32(data, 0); //从0开始解析4个字节.这是因为ToInt32默认是4个字节

                if ((startIndex - 4) >= count)
                {
                    //string s = Encoding.UTF8.GetString(data, 4, count); //从第四个字节开始解析count长度的数据

                    RequestCode requestCode = (RequestCode)BitConverter.ToInt32(data, 4);
                    ActionCode  actionCode  = (ActionCode)BitConverter.ToInt32(data, 8);

                    string s = Encoding.UTF8.GetString(data, 12, count - 8);

                    processDataCallBack(requestCode, actionCode, s);

                    Array.Copy(data, count + 4, data, 0, startIndex - (4 + count));

                    startIndex -= (count + 4);
                }
                else
                {
                    return;
                }
            }
        }
Example #3
0
    public void SendMessage(RequestCode reCode, ActionCode acCode, string data)
    {
        MessageData mdata = new MessageData(reCode, acCode, data);

        byte[] buffer = Message.PackData(mdata);
        clientSocket.Send(buffer);
    }
        public static void NavigateForResult <TActivity, TParameters, TResult>(
            [NotNull] this NavigationServiceBase navigationService,
            [NotNull] IAndroidView <IViewModelWithResultHandler> fromView,
            [CanBeNull] TParameters parameters,
            [CanBeNull] ForwardNavigationDelegate navigationStrategy = null)
            where TActivity : Activity, IActivityView <IViewModelWithParameters <TParameters> >, IActivityView <IViewModelWithResult <TResult> >
            where TParameters : ViewModelParametersBase
            where TResult : ViewModelResultBase
        {
            if (navigationService == null)
            {
                throw new ArgumentNullException(nameof(navigationService));
            }
            if (fromView == null)
            {
                throw new ArgumentNullException(nameof(fromView));
            }

            var activity           = fromView.GetActivity();
            var targetActivityType = typeof(TActivity);
            var intent             = new Intent(activity, targetActivityType);

            intent.PutViewModelParameters(parameters);
            var requestCode = RequestCode.Get <TResult>(activity, targetActivityType);

            (navigationStrategy ?? NavigationStrategy.Forward.Default()).Invoke(fromView, requestCode, intent);
        }
Example #5
0
        /// <summary>
        /// 读取消息
        /// </summary>
        /// <param name="newDataCount">新接收的消息的数量</param>
        /// <param name="onProcessMessage">传递的委托方法,响应外部事件</param>
        public void ReadMessage(int newDataCount, Action <RequestCode, ActionCode, string> onProcessMessage)
        {
            startIndex += newDataCount; // 初始地址也需要增加
            while (true)
            {
                // int类型4个字节
                if (startIndex - newDataCount <= 4)
                {
                    return;
                }

                int count = BitConverter.ToInt32(data, 0);
                if (startIndex - 4 >= count)
                {
                    RequestCode requestCode = (RequestCode)BitConverter.ToInt32(data, 4);
                    ActionCode  actionCode  = (ActionCode)BitConverter.ToInt32(data, 8);
                    string      s           = BitConverter.ToString(data, 12, count - 8);
                    onProcessMessage(requestCode, actionCode, s);

                    // Console.WriteLine("接收到数据" + s);
                    Array.Copy(data, count + 4, data, 0, startIndex - 4 - count);
                    startIndex -= count + 4;
                }
                else
                {
                    break;
                }
            }
        }
Example #6
0
        public BaseController()
        {
            requestCode = RequestCode.None;
            Assembly assembly = Assembly.GetExecutingAssembly();

            dbHelper = assembly.CreateInstance(Config.DbNameSpace + Config.DbType) as MysqlHelper;
        }
Example #7
0
        public void HandleRequest(RequestCode requestCode, ActionCode actionCode, string data, Client client, Server server)
        {
            BaseController controller;
            bool           isGet = controllerDict.TryGetValue(requestCode, out controller);

            if (isGet == false)
            {
                return;
            }
            string     methodName = Enum.GetName(typeof(ActionCode), actionCode);
            MethodInfo mi         = controller.GetType().GetMethod(methodName);

            if (mi == null)
            {
                Console.WriteLine("无法得到对应的controller");
                return;
            }
            object[] parameter = new object[] { data, server, client };
            object   o         = mi.Invoke(controller, parameter);

            if (o == null || string.IsNullOrEmpty(o as string))
            {
                Console.WriteLine("无法得到对应的方法");
                return;
            }
            server.SendResponse(client, actionCode, o as string);
        }
Example #8
0
        public void ReadMessage(int newDataAmount, Action <RequestCode, ActionCode, string> processDataCallBack)
        {
            startIndex += newDataAmount;
            while (true)
            {
                //最小数据长度大于4,前4位为数据头
                if (startIndex <= 4)
                {
                    return;
                }

                int count = BitConverter.ToInt32(data, 0);
                if ((startIndex - 4) >= count)                                            //如果当前消息是完整的
                {
                    RequestCode requestCode = (RequestCode)BitConverter.ToInt32(data, 4); //请求
                    ActionCode  actionCode  = (ActionCode)BitConverter.ToInt32(data, 8);  //处理
                    string      s           = Encoding.UTF8.GetString(data, 12, count - 8);
                    Console.WriteLine("解析数据:" + s);
                    processDataCallBack(requestCode, actionCode, s);//回调
                    Array.Copy(data, count + 4, data, 0, startIndex - count - 4);
                    startIndex -= (count + 4);
                }
                else
                {
                    break;
                }
            }
        }
Example #9
0
        public void HandleRequest(RequestCode requestCode, ActionCode actionCode, string data, Client client)
        {
            BaseController controller;
            bool           isGet = controllerDict.TryGetValue(requestCode, out controller);

            if (!isGet)
            {
                Console.WriteLine("Cant Get " + requestCode + " Handler");
                return;
            }
            string     methodName = Enum.GetName(typeof(ActionCode), actionCode);
            MethodInfo mi         = controller.GetType().GetMethod(methodName);

            if (mi == null)
            {
                Console.WriteLine("[warning]no method:<" + controller.GetType() + "." + methodName + ">");
            }
            object[] parameters = new object[] { data, client, server };
            object   o          = mi.Invoke(controller, parameters);

            if (o == null || string.IsNullOrEmpty(o as string))
            {
                return;
            }
            server.SendResponse(client, actionCode, o as string);
        }
Example #10
0
 //public void AddCount(int count)
 //{
 //    startIndex += count;
 //}
 /// <summary>
 /// 解析数据
 /// </summary>
 public void ReadMessage(int newDataAmount, Action <RequestCode, ActionCode, string> processDataCallBack)
 {
     startIndex += newDataAmount;
     while (true)
     {
         if (startIndex <= 4)
         {
             return;
         }
         int count = BitConverter.ToInt32(data, 0); //从数据中读取前4个字节,count的值就是包前端表示包中数据长度的值
         if (startIndex - 4 >= count)               //startIndex-4 表示的是接收到的真正的数据长度,该值大于等于count表示接收到的数据是完整的
         {
             //string s = Encoding.UTF8.GetString(data, 4, count);
             //Console.WriteLine("解析出来一条数据:" + s);
             RequestCode requestCode = (RequestCode)BitConverter.ToInt32(data, 4);
             ActionCode  actionCode  = (ActionCode)BitConverter.ToInt32(data, 8);
             string      s           = Encoding.UTF8.GetString(data, 12, count - 8); //requestCode和actionCode共占用了8个字节
             processDataCallBack(requestCode, actionCode, s);
             Array.Copy(data, count + 4, data, 0, startIndex - 4 - count);           //将未读取的数据前移
             startIndex -= (count + 4);
         }
         else
         {
             break;
         }
     }
 }
Example #11
0
        public void parseMessage(string message)
        {
            message = message.Substring(1, message.Length - 2);
            string[]    splitMessage = message.Split(';');
            RequestCode requestCode  = (RequestCode)Int32.Parse(splitMessage[1]);

            switch (requestCode)
            {
            case RequestCode.ALL:
                this.Temperature   = float.Parse(splitMessage[2]);
                this.Accelerometer = splitMessage[3];
                this.Magnetometer  = splitMessage[4];
                this.Light         = int.Parse(splitMessage[5]);
                break;

            case RequestCode.TEMPERATURE:
                this.Temperature = float.Parse(splitMessage[2]);
                break;

            case RequestCode.ACCELEROMETER:
                this.Accelerometer = splitMessage[2];
                break;

            case RequestCode.LIGHT:
                this.Light = int.Parse(splitMessage[2]);
                break;

            case RequestCode.MAGNETOMETER:
                this.Magnetometer = splitMessage[2];
                break;
            }
        }
Example #12
0
 // 用来处理消息的方法
 public void HandleRequest(RequestCode requestCode, ActionCode actionCode,
                           string data, Client client)
 {
     // 把方法的调用传递给CcontrollerManager
     // 通过sever中介,Manager与sercer交互 server与client交互
     controllerManager.HandleRequest(requestCode, actionCode, data, client);
 }
Example #13
0
 /// <summary>
 /// 解析数据
 /// </summary>
 public void ReadMessage(int newDataAmount, Action <RequestCode, ActionCode, string> processDataCallBack)
 {
     startIndex += newDataAmount;
     while (true)
     {
         if (startIndex <= 4)//当存储的数据小于四时说明里面的数据不足,等待下一次补充存储
         {
             return;
         }
         int count = BitConverter.ToInt32(data, 0); //将byte数组中的指定位置的四个字节转为int 转出的数字表示收到的消息字节长度
         if ((startIndex - 4) >= count)             //字节数组中剩余字节大于一次消息传送的字节。也就是字节数组中的数据必须要大于要解析的数据长度
         {
             //string s = Encoding.UTF8.GetString(data, 4, count);//从第四位字节以后开始解析,前四位代表数据长度
             //Console.WriteLine("解析出一条数据" + s);
             RequestCode requestCode = (RequestCode)BitConverter.ToInt32(data, 4);
             Console.WriteLine(requestCode.ToString());
             ActionCode actionCode = (ActionCode)BitConverter.ToInt32(data, 8);
             Console.WriteLine(actionCode.ToString());
             string s = Encoding.UTF8.GetString(data, 12, count - 8);
             Console.WriteLine(s);
             processDataCallBack(requestCode, actionCode, s);              //Message只负责解析消息,解析后的消息发送给服务端处理,由于Message中么有Server的引用,并且为了降低耦合度,发送消息交给客户端链接去做,所以这里回调调用方法。
             Array.Copy(data, count + 4, data, 0, startIndex - 4 - count); //将已经解析过的位置之后的数据移动到首位,移动的数据长度是减去已经解析过的数据。相当于覆盖已经解析过的数据,直到当前读取客户端消息的字节少于等于4也就是字节数组中没有有效数据了。
             startIndex -= (count + 4);
         }
         else
         {
             break;
         }
     }
 }
Example #14
0
        //处理请求,通过request获得对应的Controller,通过action取得Controller里面的方法
        public void HandleRequest(RequestCode request, ActionCode action, string data, Client client)
        {
            BaseController controller;
            //尝试在字典中获取对应的controler
            bool isGet = controllerDic.TryGetValue(request, out controller);

            if (isGet == false)
            {
                Console.WriteLine("无法得到RequestCode:[" + request + "]对应的Controller");
            }
            //通过反射获得相应对象中名为methodName的方法
            string methodName = Enum.GetName(typeof(ActionCode), action);

            Console.WriteLine("得到method: " + methodName);
            MethodInfo method = controller.GetType().GetMethod(methodName);

            Console.WriteLine("methodInfo:" + method.Name);
            if (method == null)
            {
                Console.WriteLine("Controller:[" + controller.GetType() + "]没有对应的方法:[" + methodName + "]");
            }
            object[] parameters = new object[] { data, client, server };
            //在controller对象中调用method,参数为parameters
            object o = method.Invoke(controller, parameters);

            //当返回值为空时,不需要服务器响应请求
            if (string.IsNullOrEmpty(o as string))
            {
                return;
            }
            //调用Server响应该请求
            server.ResponseMsg(client, action, o as string);
        }
Example #15
0
 public ChatRequest(ChatRequest request)
 {
     Id = request.Id;
     Code = request.Code;
     Arguments = request.Arguments; // !!! arguments not copied
     Status = request.Status;
 }
Example #16
0
 /// <summary>
 /// 解析数据
 /// </summary>
 public void ReadMessage(int newDataAmount, Action <RequestCode, ActionCode, string> processCodeCallBack)
 {
     startIndex += newDataAmount;
     while (true)
     {
         if (startIndex <= 4)
         {
             return;
         }
         int count = BitConverter.ToInt32(data, 0);
         if ((startIndex - 4) >= count)
         {
             RequestCode requestCode = (RequestCode)BitConverter.ToInt32(data, 4);
             ActionCode  actionCode  = (ActionCode)BitConverter.ToInt32(data, 8);
             string      s           = Encoding.UTF8.GetString(data, 12, count - 8);
             processCodeCallBack(requestCode, actionCode, s);
             Array.Copy(data, count + 4, data, 0, startIndex - 4 - count);
             startIndex -= (count + 4);
         }
         else
         {
             return;
         }
     }
 }
Example #17
0
 // 发送请求 在一些request类中进行调用
 public void SendRequest(RequestCode requestCode, ActionCode actionCode, string data)
 {
     // 先进行数据打包
     byte[] bytes = Message.PackData(requestCode, actionCode, data);
     // 将数据发送到服务器端
     clientSocket.Send(bytes);
 }
Example #18
0
 public ChatRequest(RequestCode code, List<object> arguments, int id = 0, ChatResultCode status = ChatResultCode.InProgress)
 {
     Id = id;
     Code = code;
     Arguments = arguments;
     Status = status;
 }
Example #19
0
        /// <summary>
        /// 根据RequestCode与ActionCode,来调用指定Controller中的指定处理方法
        /// </summary>
        /// <param name="data">请求中传递的数据</param>
        /// <param name="requestCode">请求编号</param>
        /// <param name="actionCode">请求的方法编号</param>
        /// <param name="client">客户端连接对象</param>
        public void HandleRequest(RequestCode requestCode, ActionCode actionCode, string data, Client client)
        {
            BaseController controller;
            bool           isGet = controllerDict.TryGetValue(requestCode, out controller); //通过RequestConde获取到对应的Controller对象,这里是父类对象指向子类引用

            if (isGet == false)                                                             //获取Controller失败
            {
                Console.WriteLine("无法获取[" + requestCode + "]所对应的Controller!"); return;
            }
            string methodName = Enum.GetName(typeof(ActionCode), actionCode);//通过枚举类型的值获取到对应值的名称

            //Console.WriteLine("客户端发起了["+ requestCode+"]类型的请求,请求的方法是["+methodName+"]。");
            MethodInfo methodInfo = controller.GetType().GetMethod(methodName);//利用反射机制,通过方法名称获取到Controller中对应的方法信息

            if (methodInfo == null)
            {
                Console.WriteLine("[警告]:在" + controller.GetType() + "中没有找到名为[" + methodName + "]的处理方法");
                return;
            }
            Object[] parameters = new object[] { data, client, server };

            //通过MethodInfo对象进行函数调用,第一个参数为调用函数的所属对象,第二个参数为要传递的函数形参,返回值为调用方法的返回值
            Object returnObject = methodInfo.Invoke(controller, parameters);

            if (returnObject == null || string.IsNullOrEmpty(returnObject as string))//判断anction方法响应请求以后的返回值是否为空,或者是否为空字符串
            {
                return;
            }
            server.SendResponse(client, actionCode, returnObject as string);//通过服务器端发送响应结果
        }
Example #20
0
 public void Response(Client client, RequestCode requestCode, byte[] dataBytes)
 {
     if (notifiers.ContainsKey(requestCode))
     {
         foreach (var func in notifiers[requestCode])
         {
             Type[] types = func.GetType().GetGenericArguments();
             if (types[1] == typeof(byte[]) && types[2] == types[1])
             {
                 client.Publish(requestCode, (func as Func <Client, byte[], byte[]>)?.Invoke(client, dataBytes));
             }
             else if (types[1] == typeof(string) && types[2] == typeof(byte[]))
             {
                 client.Publish(requestCode, (func as Func <Client, string, byte[]>)?.Invoke(client, Encoding.UTF8.GetString(dataBytes)));
             }
             else if (types[1] == typeof(byte[]) && types[2] == typeof(string))
             {
                 client.Publish(requestCode, (func as Func <Client, byte[], string>)?.Invoke(client, dataBytes));
             }
             else if (types[1] == typeof(string) && types[2] == types[1])
             {
                 client.Publish(requestCode, (func as Func <Client, string, string>)?.Invoke(client, Encoding.UTF8.GetString(dataBytes)));
             }
         }
     }
     else
     {
         ConsoleUtility.WriteLine("The notifier corresponding to " + requestCode + " could not be found.");
     }
 }
Example #21
0
        //public void AddCount(int c)
        //{
        //    startIndex += c;
        //}
        /// <summary>
        /// 解析读取到的数据
        /// </summary>
        public void ReadMessage(int dataAmount, Action <RequestCode, ActionCode, string> processDataCallBack)
        {
            startIndex += dataAmount;
            while (true)
            {
                if (startIndex <= 4)//长度不够,直接返回
                {
                    return;
                }

                int count = BitConverter.ToInt32(data, 0);
                if (startIndex - 4 >= count)
                {
                    //string s = Encoding.UTF8.GetString(data, 4, count);
                    //Console.WriteLine("解析出一条数据: " + s);

                    RequestCode requestCode = (RequestCode)BitConverter.ToInt32(data, 4); //解析出来requestcode,从4的位置开始解析。
                    ActionCode  actionCode  = (ActionCode)BitConverter.ToInt32(data, 8);  //而解析actioncode则从8的位置开始解析。

                    string s = Encoding.UTF8.GetString(data, 12, count - 8);

                    processDataCallBack(requestCode, actionCode, s);
                    Array.Copy(data, count + 4, data, 0, startIndex - 4 - count);
                    startIndex -= (count + 4);
                }
                else
                {
                    break;
                }
            }
        }
        public void HandleRequest(RequestCode requestCode, ActionCode actionCode, string data, Client client)
        {
            BaseController controller;
            bool           isGet = controllerDict.TryGetValue(requestCode, out controller);

            if (isGet == false)
            {
                Console.WriteLine("无法得到[" + requestCode + "]所对应的Controller,无法处理请求"); return;
            }
            string     methodName = Enum.GetName(typeof(ActionCode), actionCode);
            MethodInfo mi         = controller.GetType().GetMethod(methodName);

            if (mi == null)
            {
                Console.WriteLine("[警告]在Controller[" + controller.GetType() + "]中没有对应的处理方法:[" + methodName + "]"); return;
            }
            object[] parameters = new object[] { data, client, server };
            object   o          = mi.Invoke(controller, parameters);

            if (o == null || string.IsNullOrEmpty(o as string))
            {
                return;
            }
            server.SendResponse(client, actionCode, reasonCode, o as string);
        }
Example #23
0
 public ChatRequest(ChatRequest request)
 {
     Id        = request.Id;
     Code      = request.Code;
     Arguments = request.Arguments; // !!! arguments not copied
     Status    = request.Status;
 }
Example #24
0
        /// <summary>
        /// 处理客户端发来的请求
        /// </summary>
        /// <param name="requestCode">用来指定用那个Handle处理,这里不区别</param>
        /// <param name="actionCode">动作指令</param>
        /// <param name="data">参数</param>
        /// <param name="client"></param>
        public void HandleRequest(RequestCode requestCode, ActionCode actionCode, string data, Client client)
        {
            //BaseController controller;
            //bool isGet = controllerDict.TryGetValue(requestCode, out controller);
            //if (isGet == false)
            //{
            //    Console.WriteLine("无法得到[" + requestCode + "]所对应的Controller,无法处理请求"); return;
            //}
            string     methodName = Enum.GetName(typeof(ActionCode), actionCode);
            MethodInfo mi         = requestHandle.GetType().GetMethod(methodName);

            if (mi == null)
            {
                Console.WriteLine("[警告]在RequestHandle中没有对应的处理方法:[" + methodName + "]"); return;
            }
            //Console.WriteLine("mi name = " + mi.ToString());
            object[] parameters = new object[] { data, client, this };
            object   o          = mi.Invoke(requestHandle, parameters);

            if (o == null || string.IsNullOrEmpty(o as string))
            {
                return;
            }
            this.SendResponse(client, actionCode, o as string);
        }
Example #25
0
 /// <summary>
 /// 解析数据或者叫做读取数据
 /// </summary>
 public void ReadMessage(int newDataAmount, Action <RequestCode, ActionCode, string> processDataCallback)
 {
     startIndex += newDataAmount;
     while (true)
     {
         if (startIndex <= 4)
         {
             return;
         }
         int count = BitConverter.ToInt32(data, 0);
         if ((startIndex - 4) >= count)
         {
             //Console.WriteLine(startIndex);
             //Console.WriteLine(count);
             //string s = Encoding.UTF8.GetString(data, 4, count);
             //Console.WriteLine("解析出来一条数据:" + s);
             RequestCode requestCode = (RequestCode)BitConverter.ToInt32(data, 4);
             ActionCode  actionCode  = (ActionCode)BitConverter.ToInt32(data, 8);
             string      s           = Encoding.UTF8.GetString(data, 12, count - 8);
             processDataCallback(requestCode, actionCode, s);
             Array.Copy(data, count + 4, data, 0, startIndex - 4 - count);
             startIndex -= (count + 4);
         }
         else
         {
             break;
         }
     }
 }
Example #26
0
 public ChatRequest(RequestCode code, List <object> arguments, int id = 0, ChatResultCode status = ChatResultCode.InProgress)
 {
     Id        = id;
     Code      = code;
     Arguments = arguments;
     Status    = status;
 }
Example #27
0
        /// <summary>
        /// 处理请求
        /// </summary>
        /// <param name="request">请求类型</param>
        /// <param name="action">执行该请求所用的方法</param>
        /// <param name="pre">该方法的参数</param>
        /// <param name="client">负责接受数据的客户端</param>
        public void HeadleRequest(RequestCode request, ActionCode action, string pre, Client client)
        {
            BaseController con;

            if (!controllerDic.TryGetValue(request, out con))
            {
                this.LogError($"获取:{con}错误");
                return;
            }

            //var merodName = Enum.GetName(typeof(ActionCode), action);

            //var methodInfo = con.GetType().GetMethod(merodName);
            //if (methodInfo == null)
            //{
            //    this.LogError($"{methodInfo}为 null ");
            //    return;
            //}

            //var res = methodInfo.Invoke(con, new object[]{ pre, client, server});
            var res = con.ExecuteAction(action, pre, client, server);

            if (res != null || !string.IsNullOrEmpty(res))
            {
                server.SendRequest(client, action, res);
                this.Log($"请求: {action.ToString()} 客户端: {client.Name} 数据: {res}");
            }
        }
Example #28
0
 public void ReadMessage(int newDataAmount, Action <ControllerCode, RequestCode, string> processDataCallBack)
 {
     dynamicLength += newDataAmount;
     while (true)
     {
         if (dynamicLength <= 4)
         {
             return;
         }
         int count = BitConverter.ToInt32(data, 0);
         if (dynamicLength - 4 >= count)
         {
             ControllerCode controllerCode = (ControllerCode)BitConverter.ToInt32(data, 4);
             RequestCode    requestCode    = (RequestCode)BitConverter.ToInt32(data, 8);
             string         s = Encoding.UTF8.GetString(data, 12, count - 8);
             processDataCallBack(controllerCode, requestCode, s);
             Array.Copy(data, count + 4, data, 0, dynamicLength - 4 - count);
             dynamicLength -= count + 4;
         }
         else
         {
             return;
         }
     }
 }
        protected XE BuildBaseDocument(RequestCode requestCode)
        {
            // UNDOCUMENTED: example in POS API spec, Appendix II on Page 53
            // shows the presence of a timeout attribute which we could set to
            // equal the timeout period for HttpClient. The attribute isn't part
            // of the table on Page 30 so we ignore it. According to Oracle,
            // it's likely leftover from when backend was JBoss based.
            var traceId = new TraceId(Timestamp, TraceId.TransmissionKind.Normal, MessageId.SequenceNumber, MessageId.CheckNumber).ToString();

            return(new XE(C.SVCMessage,
                          new XA(C.version, new Version("1")),
                          new XA(C.posIntfcName, new PosInterfaceName("posInterfaceName")),
                          new XA(C.posIntfcVersion, new PosInterfaceVersion("1.00")),
                          new XA(C.language, new Language(Language.Kind.EnUs)),
                          new XA(C.currency, new Currency(Currency.Kind.DKK)),
                          new XA(C.sequence, MessageId.SequenceNumber),
                          new XA(C.retransmit, new Transmission(Transmission.Kind.Normal)),
                          new XE(C.RequestCode, requestCode),
                          new XE(C.TraceID, traceId),
                          new XE(C.TerminalID, MessageId.TerminalId),
                          new XE(C.TerminalType, new TerminalType("Service")),
                          new XE(C.LocalDate, new LocalDate(Timestamp)),
                          new XE(C.LocalTime, new LocalTime(Timestamp)),
                          new XE(C.Amount, new Amount(0.00m)),
                          new XE(C.LocalCurrency, new Currency(Currency.Kind.DKK)),
                          new XE(C.BusinessDate, new BusinessDate(Timestamp)),
                          new XE(C.TransactionEmployee, new TransactionEmployee(0)),
                          new XE(C.RevenueCenter, new RevenueCenter(0)),
                          new XE(C.CheckNumber, MessageId.CheckNumber),
                          new XE(C.SVAN, AccountNumber)));
        }
Example #30
0
        /// <summary>
        /// 解析/读取数据,处理粘包分包问题.
        /// </summary>
        /// <param name="newDataAmount">接收到的原始数据</param>
        /// <param name="processDataCallback">处理解析数据的回调方法</param>
        public void ReadMessage(int newDataAmount, Action <RequestCode, ActionCode, string> processDataCallback)
        {
            startIndex += newDataAmount;
            while (true)
            {
                if (startIndex <= 4)
                {
                    return;                   //数据头不完整 或 粘包的所有数据处理完毕且数据缓存为空.
                }
                int count = BitConverter.ToInt32(data, 0);

                if ((startIndex - 4) >= count)
                {
                    //==时表示实际数据和数据头count是一致的,循环只执行一次.
                    //>时表示可能发生了粘包,此时循环体尝试区分各个包的实际内容.

                    RequestCode requestCode = (RequestCode)BitConverter.ToInt32(data, 4);
                    ActionCode  actionCode  = (ActionCode)BitConverter.ToInt32(data, 8);
                    string      strData     = Encoding.UTF8.GetString(data, 12, count - 8);
                    processDataCallback(requestCode, actionCode, strData);
                    Array.Copy(data, count + 4, data, 0, startIndex - 4 - count);
                    startIndex -= count + 4;
                }
                else  //当前数据不完整.
                {
                    break;
                }
            }
        }
 public RequestActionBase(RequestCode requestCode, ActionCode action, Action <string> onResponse)
 {
     RequestCode = requestCode;
     ActionCode  = action;
     OnResponse += onResponse;
     GameFacade.Instance.AddRequest(ActionCode, this);
 }
        public void RequestHander(RequestCode requestCode, ActionCode actionCode, string data, Client client)//data为传递进controller中的参数
        {
            BaseController baseController;
            bool           isGet = controllerDict.TryGetValue(requestCode, out baseController);

            if (isGet == false)
            {
                Console.WriteLine("无法得到[" + requestCode + "]所对应的Conrtoller,无法处理"); return;
            }
            string     methodName = Enum.GetName(typeof(ActionCode), actionCode);
            MethodInfo mi         = baseController.GetType().GetMethod(methodName); //反射出方法名,利用方法名执行方法

            if (mi == null)
            {
                Console.WriteLine("[警告]在Controller[" + baseController + "]中没有找到对应的[" + methodName + "]方法"); return;
            }
            object[] parameters = new object[] { data, client, server }; //函数的参数
            object   o          = mi.Invoke(baseController, parameters); //返回的值

            if (o == null || string.IsNullOrEmpty(o as string))
            {
                return;
            }
            server.SendResponse(actionCode, client, o as string);
        }
Example #33
0
	//通知をスケジューリングする(Android)
	private void ScheduleLocalNotification (string message, double addSeconds, RequestCode requestCode) {
		long secondsFromNow = (long)addSeconds;
		string title = "アイプロ";
		string subTitle = message;
		string tickerText = message;
		string extraData = "extraData";
		EtceteraAndroid.scheduleNotification (secondsFromNow, title, subTitle, tickerText, extraData, (int)requestCode);
	}