messageeventargs.cs

移动ＭＩＳＣ１.６正向、反向定制、取消接口

using System.Data;
using System.Configuration;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Web.UI.HtmlControls;

using System;
using System.Collections.Generic;
using System.Text;
using System.Net.Sockets;
using System.Threading;
    
    public class MessageEventArgs : EventArgs
    {
        private byte[] _HeaderData;
        private Message_Header _Header;
        private byte[] _BodyData;

        public byte[] BodyData
        {
            get
            {
                return this._BodyData;
            }
        }

        public Message_Header Header
        {
            get
            {
                return this._Header;
            }
        }
        
        public byte[] HeaderData
        {
            get
            {
                return this._HeaderData;
            }
        }

        public MessageEventArgs(byte[] bytes)
        {
            this._HeaderData = new byte[Message_Header.Length];
            Buffer.BlockCopy(bytes, 0, this._HeaderData, 0, Message_Header.Length);
            this._Header = new Message_Header(this._HeaderData);
            this._BodyData = new byte[this._Header.Total_Length - Message_Header.Length];
            Buffer.BlockCopy(bytes, Message_Header.Length, this._BodyData, 0, this._BodyData.Length);
        }
    }
        public class Client
        {
            private string _Host;
            private int _Port;
            private string _Source_Addr;
            private string _Password;

            private TcpClient tc;

            private bool _IsConnected;

            public bool IsConnected
            {
                get
                {
                    return this._IsConnected;
                }
            }

            private NetworkStream _NetworkStream;

            private static object _SyncLockObject = new object();

            public delegate void MessageEventHandle(Client Sender, MessageEventArgs e);

            public event MessageEventHandle ResponseMessageReceive;

            public event MessageEventHandle RequestMessageSend;

            private Thread _ReadResponseThread;

            private void OnRequestMessageSend(byte[] data)
            {
                if (RequestMessageSend != null)
                {
                    RequestMessageSend(this, new MessageEventArgs(data));
                }
            }

            private void WriteToStreamWithLock(byte[] data, NetworkStream Stream)
            {
                this.OnRequestMessageSend(data);
                lock (_SyncLockObject)
                {
                    Util.WriteToStream(data, Stream);
                }
            }

            private byte[] ReadFromStreamWithLock(int Length, NetworkStream Stream)
            {
                lock (_SyncLockObject)
                {
                    return Util.ReadFromStream(Length, Stream);
                }
            }

            public void Terminate(uint SequenceId)
            {
                Message_Header terminate = new Message_Header(Message_Header.Length, CMPP_Command_Id.CMPP_TERMINATE, SequenceId);
                //Console.WriteLine("Request:\r\n{0}",terminate.ToString());
                this.WriteToStreamWithLock(terminate.ToBytes(), this._NetworkStream);
                this.StartRun();
            }
            public void ActiveTest(uint SequenceId)
            {
                Message_Header activeTest = new Message_Header(Message_Header.Length, CMPP_Command_Id.CMPP_ACTIVE_TEST, SequenceId);

                //Console.WriteLine("Request:\r\n{0}", activeTest.ToString());
                this.WriteToStreamWithLock(activeTest.ToBytes(), this._NetworkStream);
                this.StartRun();
            }
            public bool Connect(string Host, int Port, string UserID, string Password, uint SequenceId)
            {
                this._Host = Host;
                this._Port = Port;
                this._Source_Addr = UserID;
                this._Password = Password;

                DateTime ts = DateTime.Now;
                CMPP_CONNECT connect = new CMPP_CONNECT(this._Source_Addr, this._Password, ts, 1, SequenceId);

                //Console.WriteLine("Request:\r\n{0}", connect.ToString());
                
                tc = new TcpClient();
                tc.Connect(this._Host, this._Port);
                this._NetworkStream = tc.GetStream();

                this.WriteToStreamWithLock(connect.ToBytes(), this._NetworkStream);

                this.Run(ref this._IsConnected);
                return this._IsConnected;
            }
            public void Query(DateTime Time, uint QueryType, string QueryCode, string Reserve, uint SequenceId)
            {
                CMPP_QUERY query = new CMPP_QUERY(Time, QueryType, QueryCode, Reserve, SequenceId);

                //Console.WriteLine("Request:\r\n{0}", query.ToString());

                this.WriteToStreamWithLock(query.ToBytes(), this._NetworkStream);
                this.StartRun();
            }
            public void Submit(ulong MsgId, uint RegisteredDelivery, string FeeTerminalId, string[] DestTerminalId, string MsgContent, uint SequenceId)
            {
                CMPP_SUBMIT submit = new CMPP_SUBMIT(SequenceId);
                submit.Msg_Id = MsgId;//      uint _Msg_Id;      // 8 Unsigned Integer 信息标识。
                submit.Pk_total = 1;//      uint _Pk_total;      // 1 Unsigned Integer 相同Msg_Id的信息总条数,从1开始。
                submit.Pk_number = 0;//      uint _Pk_number;     // 1 Unsigned Integer 相同Msg_Id的信息序号,从1开始。
                submit.Registered_Delivery = RegisteredDelivery;//      uint _Registered_Delivery;   // 1 Unsigned Integer 是否要求返回状态确认报告: 
                //      //   0:不需要; 
                //      //   1:需要。


                submit.Msg_level = 1;//      uint _Msg_level;     // 1 Unsigned Integer 信息级别。
                submit.Service_Id = "abcdefghij";//      string _Service_Id;     // 10 Octet String 业务标识,是数字、字母和符号的组合。
                submit.Fee_UserType = 3;//      uint _Fee_UserType;     // 1 Unsigned Integer 计费用户类型字段: 
                //      //   0:对目的终端MSISDN计费; 
                //      //   1:对源终端MSISDN计费; 
                //      //   2:对SP计费; 
                //      //   3:表示本字段无效,对谁计费参见Fee_terminal_Id字段。



                submit.Fee_terminal_Id = FeeTerminalId; //      string _Fee_terminal_Id;   // 32 Octet String 被计费用户的号码,当Fee_UserType为3时该值有效,当Fee_UserType为0、1、2时该值无意义。
                submit.Fee_terminal_type = 0;//      uint _Fee_terminal_type;   // 1 Unsigned Integer 被计费用户的号码类型,0:真实号码;1:伪码。 


                submit.TP_pId = 0;
                submit.TP_udhi = 0;
                submit.Msg_Fmt = 15;//      uint _Msg_Fmt;      // 1 Unsigned Integer 信息格式: 
                //      //   0:ASCII串; 
                //      //   3:短信写卡操作; 
                //      //   4:二进制信息; 
                //      //   8:UCS2编码; 
                //      //   15:含GB汉字......





                submit.Msg_src = this._Source_Addr;//      string _Msg_src;     // 6 Octet String 信息内容来源(SP_Id)。 
                submit.FeeType = "03"; //      string _FeeType;     // 2 Octet String 资费类别: 
                //      //   01:对"计费用户号码"免费; 
                //      //   02:对"计费用户号码"按条计信息费; 
                //      //   03:对"计费用户号码"按包月收取信息费。



                submit.FeeCode = "100";//      string _FeeCode;     // 6 Octet String 资费代码(以分为单位)。 

                submit.ValId_Time = Util.Get_MMDDHHMMSS_String(DateTime.Now.AddHours(2)) + "032+";//      string _ValId_Time;     // 17 Octet String 存活有效期,格式遵循SMPP3.3协议。
                submit.At_Time = Util.Get_MMDDHHMMSS_String(DateTime.Now) + "032+";//      string _At_Time;     // 17 Octet String 定时发送时间,格式遵循SMPP3.3协议。
                //spnum
                submit.Src_Id = "";//      string _Src_Id;      // 21 Octet String 源号码。SP的服务代码或前缀为服务代码的长号码, 网关将该号码完整的填到SMPP协议Submit_SM消息相应的source_addr字段,该号码最终在用户手机上显示为短消息的主叫号码。 


                submit.Dest_terminal_Id = DestTerminalId;//new string[] {"1391xxx1138", "1391xxx1137"}; //      string[] _Dest_terminal_Id;   // 32*DestUsr_tl Octet String 接收短信的MSISDN号码。 

                submit.DestUsr_tl = (uint)submit.Dest_terminal_Id.Length;//      uint _DestUsr_tl;     // 1 Unsigned Integer 接收信息的用户数量(小于100个用户)。 


                submit.Dest_terminal_type = 0;//      uint _Dest_terminal_type;   // 1 Unsigned Integer 接收短信的用户的号码类型,0:真实号码;1:伪码。 

                submit.Msg_Fmt = 15;//      uint _Msg_Length;     // 1 Unsigned Integer 信息长度(Msg_Fmt值为0时:<160个字节;其它<=140个字节),取值大于或等于0。
                submit.Msg_Content = MsgContent; //"大家好!这是一个短信群发测试!"; //      string _Msg_Content;    // Msg_length Octet String 信息内容。 

                submit.LinkId = "";//      string _LinkID;      // 20 Octet String 点播业务使用的LinkID,非点播类业务的MT流程不使用该字段。 


                //Console.WriteLine("Request:\r\n{0}", submit.ToString());
                this.WriteToStreamWithLock(submit.ToBytes(), this._NetworkStream);

                this.StartRun();
            }
            bool _b = false;
            private bool _IsStarted = false;

            public void StartRun()
            {
                if (!this._IsStarted)
                {
                    this._IsStarted = true;
                    if (this._ReadResponseThread == null)
                    {
                        this._ReadResponseThread = new Thread(new ThreadStart(this.Run));
                    }
                    if (this._ReadResponseThread.ThreadState == ThreadState.Unstarted)
                    {
                        this._ReadResponseThread.Start();
                    }
                }
            }

            private void Run()
            {
                this.Run(ref this._b);
            }

            private void Run(ref bool BreakFlag)
            {
                while (!BreakFlag)
                {
                    if (this._NetworkStream.CanRead)
                    {
                        if (this._NetworkStream.DataAvailable)
                        {
                            byte[] buffer = new byte[Message_Header.Length];
                            buffer = this.ReadFromStreamWithLock(Message_Header.Length, this._NetworkStream);

                            Message_Header header = new Message_Header(buffer);
                            byte[] bytes = new byte[header.Total_Length];
                            Buffer.BlockCopy(buffer, 0, bytes, 0, buffer.Length);

                            int l = (int)header.Total_Length - Message_Header.Length;
                            if (l > 0)
                            {
                                buffer = this.ReadFromStreamWithLock(l, this._NetworkStream);
                                Buffer.BlockCopy(buffer, 0, bytes, Message_Header.Length, buffer.Length);
                            }

                            if (header.Command_Id == CMPP_Command_Id.CMPP_CONNECT_RESP)
                            {
                                CMPP_CONNECT_RESP connect_resp = new CMPP_CONNECT_RESP(bytes);
                                this._IsConnected = connect_resp.Status == 0;
                            }
                            else if(header.Command_Id == CMPP_Command_Id.CMPP_TERMINATE_RESP)
                            {
                                this._b = true;
                            }

                            if (ResponseMessageReceive != null)
                            {
                                ResponseMessageReceive(this, new MessageEventArgs(bytes));
                            }
                        }
                    }
                    Thread.Sleep(100);
                }
                if (this._b)
                {
                    this._NetworkStream.Close();
                    this._NetworkStream = null;
                }
            }
        }