cmppspclient.cs

CMPP的一个完整类

            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()
        {
        }
        private void defaultQueryRespEventHandler()
        {
        }

        private void defaultConnectRespEventHandler()
        {
            QueueItem q = new QueueItem(this.getNextSequence(), (uint) MSG.CMPP_COMMAND_ID.CMPP_ACTIVE_TEST, 0, (int) MSG_STATE.NEW);
            MSG.CMPP_MSG_TEST test = new MSG.CMPP_MSG_TEST(q.Sequence); //立即发送包过去
            q.setmsgObj(test);
            this.addToOutQueue(q);
        }
        private void defaultSubmitRespEventHandler()
        {
        }

        private void defaultClientStopEventHandler()
        { }