sgip.cs

SMGP协议对象

			get { return _userNumber; }
			set
			{
				apiHelper.CheckMaxBytes(value, 21);
				_userNumber = apiHelper.Prefix86ForMobilbeNumber(value);
			}
		}

		/// <summary>
		/// 该命令所涉及的短消息的当前执行状态  0：发送成功  1：等待发送 2：发送失败
		/// </summary>
		public byte State
		{
			get
			{
				return _state;
			}
			set
			{
				_state = value;
			}
		}

		/// <summary>
		/// 当State=2时为错误码值，否则为0
		/// </summary>
		public byte ErrorCode
		{
			get
			{
				return _errorCode;
			}
			set
			{
				_errorCode = value;
			}
		}

		/// <summary>
		/// 保留，最多8个字节
		/// </summary>
		public byte[] Reserved
		{
			get { return _reserved; }
			set
			{
				apiHelper.CheckMaxBytes(value, 8);
				_reserved = value;
			}
		}
		#endregion


		public override uint GetCommandID()
		{
			return Command.SGIP_REPORT;
		}

		public override int GetLength()
		{
			return 44;
		}

		public override byte[] GetBytes()
		{
			byte[] result = new byte[this.GetLength()];
			int nIndex = 0;
			_sequenceNumber.GetBytes().CopyTo(result, nIndex);
			nIndex += _sequenceNumber.GetLength();
			result[nIndex++] = _reportType;
			Encoding.Default.GetBytes(_userNumber).CopyTo(result, nIndex);
			nIndex += 21;
			result[nIndex++] = _state;
			result[nIndex++] = _errorCode;
			_reserved.CopyTo(result, nIndex);

			return result;
		}

		internal override void ReadFromBytes(byte[] buffer, int startIndex)
		{
			int nIndex = startIndex;
			_sequenceNumber.ReadFromBytes(buffer, nIndex);
			nIndex += _sequenceNumber.GetLength();
			_reportType = buffer[nIndex++];
			_userNumber = apiHelper.GetASCIIString(buffer, nIndex, 21);
			nIndex += 21;
			_state = buffer[nIndex++];
			_errorCode = buffer[nIndex++];
			Buffer.BlockCopy(buffer, nIndex, _reserved, 0, 8);
		}
	}

	public class Report_Resp: ResponseBody
	{
		public override uint GetCommandID()
		{
			return Command.SGIP_REPORT_RESP;
		}
	}

	/// <summary>
	/// UserRpt命令和UserRpt_Resp应答用于完成对用户鉴权后，由SMG向手机用户所注册的SP发送命令，对手机用户进行状态配置。
	/// </summary>
	public class UserRpt : Body
	{
		public override uint GetCommandID()
		{
			return Command.SGIP_USERRPT;
		}

		#region private member's
		private string _spNumber = ""; //21, SP的接入号码
		private string _userNumber = ""; //21, 待配置的手机号码，手机号码前加“86”国别标志
		private byte _userCondition; //1, 0：注销；1：欠费停机；2：恢复正常
		private byte[] _reserved = new byte[8]; //保留，扩展用
		#endregion

		#region  public property's
		/// <summary>
		/// SP的接入号码
		/// </summary>
		public string SPNumber
		{
			get { return _spNumber; }
			set
			{
				apiHelper.CheckMaxBytes(value, 21);
				_spNumber = value;
			}
		}

		/// <summary>
		/// 待配置的手机号码，手机号码前加“86”国别标志
		/// </summary>
		public string UserNumber
		{
			get { return _userNumber; }
			set
			{
				apiHelper.CheckMaxBytes(value, 21);
				_userNumber = apiHelper.Prefix86ForMobilbeNumber(value);
			}
		}

		/// <summary>
		/// 0：注销；1：欠费停机；2：恢复正常
		/// </summary>
		public byte UserCondition
		{
			get
			{
				return _userCondition;
			}
			set
			{
				_userCondition = value;
			}
		}

		/// <summary>
		/// 保留，最多8个字节
		/// </summary>
		public byte[] Reserved
		{
			get { return _reserved; }
			set
			{
				apiHelper.CheckMaxBytes(value, 8);
				_reserved = value;
			}
		}
		#endregion

		public override int GetLength()
		{
			return 51;
		}

		public override byte[] GetBytes()
		{
			byte[] result = new byte[this.GetLength()];
			int nIndex = 0;
			Encoding.Default.GetBytes(_spNumber).CopyTo(result, nIndex);
			nIndex += 21;
			Encoding.Default.GetBytes(_userNumber).CopyTo(result, nIndex);
			nIndex += 21;
			result[nIndex++] = _userCondition;
			_reserved.CopyTo(result, nIndex);

			return result;
		}

		internal override void ReadFromBytes(byte[] buffer, int startIndex)
		{
			int nIndex = startIndex;
			_spNumber = apiHelper.GetASCIIString(buffer, nIndex, 21);
			nIndex += 21;
			_userNumber = apiHelper.GetASCIIString(buffer, nIndex, 21);
			nIndex += 21;
			_userCondition = buffer[nIndex++];
			Buffer.BlockCopy(buffer, nIndex, _reserved, 0, 8);
		}

	}

	/// <summary>
	/// UserRpt命令和UserRpt_Resp应答用于完成对用户鉴权后，由SMG向手机用户所注册的SP发送命令，对手机用户进行状态配置。
	/// </summary>
	public class UserRpt_Resp : ResponseBody
	{
		public override uint GetCommandID()
		{
			return Command.SGIP_USERRPT_RESP;
		}
	}

	public class Trace : Body
	{
		#region private members
		private SequenceNumber _sequenceNumber = new SequenceNumber(); //12, 被跟踪MT短消息的命令序列号
		private string _userNumber = ""; //21, 接收短消息的手机号，手机号码前加“86”国别标志
		private byte[] _reserved = new byte[8]; // 保留，最多8个字节
		#endregion

		#region public propertys

		/// <summary>
		/// 被跟踪MT短消息的命令序列号
		/// </summary>
		public SequenceNumber SequenceNumber
		{
			get { return _sequenceNumber; }
			set { _sequenceNumber = value; }
		}

		/// <summary>
		/// 接收短消息的手机号，手机号码前加“86”国别标志
		/// </summary>
		public string UserNumber
		{
			get { return _userNumber; }
			set
			{
				apiHelper.CheckMaxBytes(value, 21);
				_userNumber = apiHelper.Prefix86ForMobilbeNumber(value);
			}
		}

		/// <summary>
		/// 保留，最多8个字节
		/// </summary>
		public byte[] Reserved
		{
			get { return _reserved; }
			set
			{
				apiHelper.CheckMaxBytes(value, 8);
				_reserved = value;
			}
		}
		#endregion


		public override uint GetCommandID()
		{
			return Command.SGIP_TRACE;
		}

		public override int GetLength()
		{
			return 41;
		}

		public override byte[] GetBytes()
		{
			byte[] result = new byte[this.GetLength()];
			int nIndex = 0;
			_sequenceNumber.GetBytes().CopyTo(result, nIndex);
			nIndex += _sequenceNumber.GetLength();
			Encoding.Default.GetBytes(_userNumber).CopyTo(result, nIndex);
			nIndex += 21;
			_reserved.CopyTo(result, nIndex);

			return result;
		}

		internal override void ReadFromBytes(byte[] buffer, int startIndex)
		{
			int nIndex = startIndex;
			_sequenceNumber.ReadFromBytes(buffer, nIndex);
			nIndex += _sequenceNumber.GetLength();
			_userNumber = apiHelper.GetASCIIString(buffer, nIndex, 21);
			nIndex += 21;
			Buffer.BlockCopy(buffer, nIndex, _reserved, 0, 8);
		}
	}

	public class Trace_Resp: Body
	{
		private byte _count; //1, 被跟踪MT短消息经过的节点个数，当被跟踪短消息经过多个节点时，以下各个字段可重复
		private byte _result; //1, Trace命令在该节点是否成功接收。十六进制数字 0：接收成功 1：等待处理 其它：错误码
		private string _nodeId = ""; //6, 节点编号
		private string _receiveTime = ""; //16, 被跟踪的短消息到达该节点时刻，格式为“yymmddhhmmss”
		private string _sendTime = ""; //16, 该节点发出被跟踪的短消息时刻，格式为“yymmddhhmmss”
		private byte[] _reserved = new byte[8]; //保留，扩展用

		/// <summary>
		/// 被跟踪MT短消息经过的节点个数，当被跟踪短消息经过多个节点时，以下各个字段可重复
		/// </summary>
		public byte Count
		{
			get
			{
				return _count;
			}
			set
			{
				_count = value;
			}
		}

		/// <summary>
		/// Trace命令在该节点是否成功接收。十六进制数字 0：接收成功 1：等待处理 其它：错误码
		/// </summary>
		public byte Result
		{
			get
			{
				return _result;
			}
			set
			{
				_result = value;
			}
		}

		/// <summary>
		/// 节点编号
		/// </summary>
		public string NodeId
		{
			get { return _nodeId; }
			set
			{
				apiHelper.CheckMaxBytes(value, 6);
				_nodeId = value;
			}
		}

		/// <summary>
		/// 被跟踪的短消息到达该节点时刻，格式为“yymmddhhmmss”
		/// </summary>
		public string ReceiveTime
		{
			get { return _receiveTime; }
			set
			{
				apiHelper.CheckMaxBytes(value, 16);
				_receiveTime = value;
			}
		}

		/// <summary>
		/// 该节点发出被跟踪的短消息时刻，格式为“yymmddhhmmss”
		/// </summary>
		public string SendTime
		{
			get { return _sendTime; }
			set
			{
				apiHelper.CheckMaxBytes(value, 16);
				_sendTime = value;
			}
		}

		/// <summary>
		/// 保留，最多8个字节
		/// </summary>
		public byte[] Reserved
		{
			get { return _reserved; }
			set
			{
				apiHelper.CheckMaxBytes(value, 8);
				_reserved = value;
			}
		}

		public override uint GetCommandID()
		{
			return Command.SGIP_TRACE_RESP;
		}

		public override byte[] GetBytes()
		{
			byte[] buffer = new byte[this.GetLength()];
			int nIndex = 0;
			buffer[nIndex++] = _count;
			buffer[nIndex++] = _result;
			Encoding.ASCII.GetBytes(_nodeId).CopyTo(buffer, nIndex);
			nIndex += 6;
			Encoding.ASCII.GetBytes(_receiveTime).CopyTo(buffer, nIndex);
			nIndex += 16;
			Encoding.ASCII.GetBytes(_sendTime).CopyTo(buffer, nIndex);
			nIndex += 16;
			_reserved.CopyTo(buffer, nIndex);
			return buffer;
		}

		public override int GetLength()
		{
			return 48;
		}

		internal override void ReadFromBytes(byte[] buffer, int startIndex)
		{
			int nIndex = startIndex;
			_count = buffer[nIndex++];
			_result = buffer[nIndex++];
			_nodeId = apiHelper.GetASCIIString(buffer, nIndex, 6);
			nIndex += 6;
			_receiveTime = apiHelper.GetASCIIString(buffer, nIndex, 16);
			nIndex += 16;
			_sendTime = apiHelper.GetASCIIString(buffer, nIndex, 16);
			nIndex += 16;
			Buffer.BlockCopy(buffer, nIndex, _reserved, 0, 8);
		}
	}

	/// <summary>
	/// 自定义的命令
	/// </summary>
	public class KeepAlive : Body
	{
		public override uint GetCommandID()
		{
			return Command.SGIP_KEEPALIVE;
		}
	}

	/// <summary>
	/// 自定义的命令
	/// </summary>
	public class KeepAlive_Resp : Body
	{
		public override uint GetCommandID()
		{
			return Command.SGIP_KEEPALIVE_RESP;
		}
	}
}