cmppclient.cs

cmpp3.0网关开发

            cn.SourceAdd = SystemID.Trim();
            tcp.Send(cn.ToBytes());
        }


        private byte[] prepairPKs(QueueItem outitem)//将QueueItem发送出去
        {
            uint seq = outitem.Sequence;
            uint msgtype = outitem.MsgType;
            switch (msgtype)
            {
                case (uint)MSG.CMPP_COMMAND_ID.CMPP_ACTIVE_TEST:
                    MSG.CMPP_MSG_TEST test = (MSG.CMPP_MSG_TEST)outitem.getMsgObj(); //发送队列中取出
                    lock (this)
                    {
                        outitem.MsgState = (int)MSG_STATE.SENDING;
                        this.delFromOutQueue(seq);
                        this.addToWaitingQueue(outitem);    //等待服务器的active_TEST_resp 
                    }
                    outitem.MsgState = (int)MSG_STATE.SENDED_WAITTING;
                    return (test.toBytes());


                case (uint)MSG.CMPP_COMMAND_ID.CMPP_ACTIVE_TEST_RESP:
                    MSG.CMPP_MSG_TEST_RESP test_reply = (MSG.CMPP_MSG_TEST_RESP)outitem.getMsgObj(); //发送队列中取出//取出需要发送的具体消息
                    lock (this)
                    {
                        outitem.MsgState = (int)MSG_STATE.SENDING;
                        this.delFromOutQueue(seq);
                    }
                    outitem.MsgState = (int)MSG_STATE.SENDING_FINISHED;  //完成
                    return (test_reply.toBytes());



                case (uint)MSG.CMPP_COMMAND_ID.CMPP_CANCEL:
                    MSG.CMPP_MSG_CANCEL cancel = (MSG.CMPP_MSG_CANCEL)outitem.getMsgObj();    //还原成消息类
                    lock (this)
                    {
                        outitem.MsgState = (int)MSG_STATE.SENDING;
                        this.delFromOutQueue(seq);
                        this.addToWaitingQueue(outitem);    //等待回应
                    }
                    outitem.MsgState = (int)MSG_STATE.SENDED_WAITTING;
                    return (cancel.toBytes());

                case (uint)MSG.CMPP_COMMAND_ID.CMPP_DELIVER_RESP:
                    MSG.CMPP_MSG_DELIVER_RESP deliver_resp = (MSG.CMPP_MSG_DELIVER_RESP)outitem.getMsgObj(); //发送队列中取出;
                    lock (this)
                    {
                        outitem.MsgState = (int)MSG_STATE.SENDING;
                        this.delFromOutQueue(seq);
                    }
                    outitem.MsgState = (int)MSG_STATE.SENDING_FINISHED;  //完成
                    return (deliver_resp.toBytes());


                case (uint)MSG.CMPP_COMMAND_ID.CMPP_QUERY:
                    MSG.CMPP_MSG_QUERY query = (MSG.CMPP_MSG_QUERY)outitem.getMsgObj(); //发送队列中取出;
                    lock (this)
                    {
                        outitem.MsgState = (int)MSG_STATE.SENDING;
                        this.delFromOutQueue(seq);
                        this.addToWaitingQueue(outitem);
                    }
                    outitem.MsgState = (int)MSG_STATE.SENDED_WAITTING; //等待回应
                    return (query.toBytes());

                case (uint)MSG.CMPP_COMMAND_ID.CMPP_SUBMIT:
                    MSG.CMPP_MSG_SUBMIT submit = (MSG.CMPP_MSG_SUBMIT)outitem.getMsgObj(); //发送队列中取出;
                    lock (this)
                    {
                        outitem.MsgState = (int)MSG_STATE.SENDING;
                        this.delFromOutQueue(seq);
                        this.addToWaitingQueue(outitem);
                    }
                    outitem.MsgState = (int)MSG_STATE.SENDING_FINISHED;
                    return (submit.toBytes());

                case (uint)MSG.CMPP_COMMAND_ID.CMPP_TERMINATE:
                    MSG.CMPP_MSG_TERMINATE terminate = (MSG.CMPP_MSG_TERMINATE)outitem.getMsgObj(); //发送队列中取出;
                    lock (this)
                    {
                        outitem.MsgState = (int)MSG_STATE.SENDING;
                        this.delFromOutQueue(seq);
                        this.addToWaitingQueue(outitem);
                    }
                    outitem.MsgState = (int)MSG_STATE.SENDED_WAITTING;
                    return (terminate.toBytes());

                case (uint)MSG.CMPP_COMMAND_ID.CMPP_TERMINATE_RESP:
                    MSG.CMPP_MSG_TERMINATE_RESP terminate_resp = (MSG.CMPP_MSG_TERMINATE_RESP)outitem.getMsgObj(); //发送队列中取出;
                    lock (this)
                    {
                        outitem.MsgState = (int)MSG_STATE.SENDING;
                        this.delFromOutQueue(seq);
                    }
                    outitem.MsgState = (int)MSG_STATE.SENDING_FINISHED;
                    return (terminate_resp.toBytes());

                default:
                    test = (MSG.CMPP_MSG_TEST)outitem.getMsgObj(); //发送队列中取出
                    lock (this)
                    {
                        outitem.MsgState = (int)MSG_STATE.SENDING;
                        this.delFromOutQueue(seq);
                        this.addToWaitingQueue(outitem);    //等待服务器的active_TEST_resp 
                    }
                    outitem.MsgState = (int)MSG_STATE.SENDED_WAITTING;
                    return (test.toBytes());
            }
        }

        private void sendQueueItem(QueueItem outitem)//将QueueItem发送出去
        {
            uint seq = outitem.Sequence;
            uint msgtype = outitem.MsgType;
            try
            {
                switch (msgtype)
                {
                    case (uint)MSG.CMPP_COMMAND_ID.CMPP_ACTIVE_TEST:
                        MSG.CMPP_MSG_TEST test = (MSG.CMPP_MSG_TEST)outitem.getMsgObj(); //发送队列中取出
                        lock (this)
                        {
                            outitem.MsgState = (int)MSG_STATE.SENDING;
                            this.delFromOutQueue(seq);
                            this.addToWaitingQueue(outitem);    //等待服务器的active_TEST_resp 
                        }
                        tcp.Send(test.toBytes());
                        outitem.MsgState = (int)MSG_STATE.SENDED_WAITTING;
                        break;

                    case (uint)MSG.CMPP_COMMAND_ID.CMPP_ACTIVE_TEST_RESP:
                        MSG.CMPP_MSG_TEST_RESP test_reply = (MSG.CMPP_MSG_TEST_RESP)outitem.getMsgObj(); //发送队列中取出//取出需要发送的具体消息
                        lock (this)
                        {
                            outitem.MsgState = (int)MSG_STATE.SENDING;
                            this.delFromOutQueue(seq);
                        }
                        tcp.Send(test_reply.toBytes());
                        outitem.MsgState = (int)MSG_STATE.SENDING_FINISHED;  //完成
                        break;

                    case (uint)MSG.CMPP_COMMAND_ID.CMPP_CANCEL:
                        MSG.CMPP_MSG_CANCEL cancel = (MSG.CMPP_MSG_CANCEL)outitem.getMsgObj();    //还原成消息类
                        lock (this)
                        {
                            outitem.MsgState = (int)MSG_STATE.SENDING;
                            this.delFromOutQueue(seq);
                            this.addToWaitingQueue(outitem);    //等待回应
                        }
                        tcp.Send(cancel.toBytes());
                        outitem.MsgState = (int)MSG_STATE.SENDED_WAITTING;
                        break;

                    case (uint)MSG.CMPP_COMMAND_ID.CMPP_DELIVER_RESP:
                        MSG.CMPP_MSG_DELIVER_RESP deliver_resp = (MSG.CMPP_MSG_DELIVER_RESP)outitem.getMsgObj(); //发送队列中取出;
                        lock (this)
                        {
                            outitem.MsgState = (int)MSG_STATE.SENDING;
                            this.delFromOutQueue(seq);
                        }
                        tcp.Send(deliver_resp.toBytes());
                        outitem.MsgState = (int)MSG_STATE.SENDING_FINISHED;  //完成
                        break;

                    case (uint)MSG.CMPP_COMMAND_ID.CMPP_QUERY:
                        MSG.CMPP_MSG_QUERY query = (MSG.CMPP_MSG_QUERY)outitem.getMsgObj(); //发送队列中取出;
                        lock (this)
                        {
                            outitem.MsgState = (int)MSG_STATE.SENDING;
                            this.delFromOutQueue(seq);
                            this.addToWaitingQueue(outitem);
                        }
                        tcp.Send(query.toBytes());
                        outitem.MsgState = (int)MSG_STATE.SENDED_WAITTING; //等待回应
                        break;

                    case (uint)MSG.CMPP_COMMAND_ID.CMPP_SUBMIT:
                        MSG.CMPP_MSG_SUBMIT submit = (MSG.CMPP_MSG_SUBMIT)outitem.getMsgObj(); //发送队列中取出;
                        lock (this)
                        {
                            outitem.MsgState = (int)MSG_STATE.SENDING;
                            this.delFromOutQueue(seq);
                            this.addToWaitingQueue(outitem);
                        }
                        tcp.Send(submit.toBytes());
                        outitem.MsgState = (int)MSG_STATE.SENDING_FINISHED;
                        break;

                    case (uint)MSG.CMPP_COMMAND_ID.CMPP_TERMINATE:
                        MSG.CMPP_MSG_TERMINATE terminate = (MSG.CMPP_MSG_TERMINATE)outitem.getMsgObj(); //发送队列中取出;
                        lock (this)
                        {
                            outitem.MsgState = (int)MSG_STATE.SENDING;
                            this.delFromOutQueue(seq);
                            this.addToWaitingQueue(outitem);
                        }
                        if (this.tcpIsCanUse())
                        {
                            tcp.Send(terminate.toBytes());
                            outitem.MsgState = (int)MSG_STATE.SENDED_WAITTING;
                        }
                        this.isStop = true;     //通知其他线程可以退出了 
                        break;

                    case (uint)MSG.CMPP_COMMAND_ID.CMPP_TERMINATE_RESP:
                        MSG.CMPP_MSG_TERMINATE_RESP terminate_resp = (MSG.CMPP_MSG_TERMINATE_RESP)outitem.getMsgObj(); //发送队列中取出;
                        lock (this)
                        {
                            outitem.MsgState = (int)MSG_STATE.SENDING;
                            this.delFromOutQueue(seq);
                        }
                        tcp.Send(terminate_resp.toBytes());
                        outitem.MsgState = (int)MSG_STATE.SENDING_FINISHED;
                        break;
                }
                LogLastOkTime(DateTime.Now);  //记录当前最后一次消息soket正确时间
            }
            catch (SocketException se)
            {
                //发生套接字错误
                this.ErrorInfo = this.ErrorInfo + "\r\n" + se.ToString();
            }
            catch (NullReferenceException nre)
            {
                this._bNre = true;  //出现空引用错误
                this.ErrorInfo = this.ErrorInfo + "\r\n" + nre.ToString();
            }
        }

        private bool tcpIsCanUse()  //测试当前tcp是否可用
        {
            bool reval = true;
            DateTime t = DateTime.Now;
            TimeSpan ts = t - this._lastOkTime;
            if (ts.TotalSeconds > CMPPClient.CMPP_ACTIVE_TEST_T_TICKs) //60秒
            {
                reval = false;  //不可用
            }
            if (this._bNre)
            {
                reval = false;
            }
            return (reval);
        }

        private void _reStartRecvNSend()
        {
            Send_Thread = new Thread(new ThreadStart(this.SendSPMsgThread));
            Send_Thread.Start();
            Recv_Thread = new Thread(new ThreadStart(this.RecvISMGMsgThread));
            Recv_Thread.Start();
        }

        private void LogLastOkTime(DateTime lastoktime)
        {
            lock (this)
            {
                this._lastOkTime = lastoktime;  //设定最后成功消息交互时间 
            }
        }

        private void defaultReportHandler() //却省的报告事件处理函数
        {

        }

        private void defaultSMSHandler()
        {

        }

        private void defaultTeminateHandler()
        {

        }

        private void defaultTestEventHandler()
        {

        }
        private void defaultTestRespEventHandler()
        {

        }
        private void defaultTerminateEventHandler()
        {
        }
        private void defaultTerminateRespEventHandler()
        {
        }
        private void defaultCancelRespEventHandler()
        {