using System;
|
using System.Collections.Generic;
|
using System.Net.Sockets;
|
using System.Text;
|
using System.Threading;
|
using System.Timers;
|
using HDL_ON;
|
using HDL_ON.Entity;
|
using HDL_ON.UI;
|
|
namespace HDL_ON.DriverLayer
|
{
|
/// <summary>
|
/// link网关本地链接逻辑
|
/// </summary>
|
public class Control_Tcp
|
{
|
#region ■ 变量声明___________________________
|
|
/// <summary>
|
/// link网关链接逻辑
|
/// </summary>
|
private static Control_Tcp m_Current = null;
|
/// <summary>
|
/// link网关链接逻辑
|
/// </summary>
|
public static Control_Tcp Current
|
{
|
get
|
{
|
if (m_Current == null)
|
{
|
m_Current = new Control_Tcp();
|
}
|
return m_Current;
|
}
|
}
|
/// <summary>
|
/// Link网关tcp接收回调,理论上它不会处理zigbee的上报(第一个参数是网关的mac,第二个参数是接收的数据)
|
/// </summary>
|
private Action<string, string, string> tcpReceiveEvent = null;
|
/// <summary>
|
/// Tcp客户端连接池
|
/// </summary>
|
private List<TcpConnectData> listTcpClient = new List<TcpConnectData>();
|
/// <summary>
|
/// 是否搜索网关
|
/// </summary>
|
private bool isSearchGateway = false;
|
|
#endregion
|
|
#region ■ 搜索Link网关_______________________
|
|
// /// <summary>
|
// /// 搜索Link网关
|
// /// </summary>
|
// /// <param name="resultEvent">搜索到网关的回调函数,-1:异常了 1:收到一个A网关</param>
|
// /// <param name="searchTime">搜索时间(秒)</param>
|
// /// <param name="connectLocalOnly">当搜索到网关时,是否只连接本地的(不能瞎连其他的网关,但是网关搜索界面特殊)</param>
|
// public void SearchLinkGateway(Action<int, AGatewayInfo> resultEvent, int searchTime, bool connectLocalOnly)
|
// {
|
// this.isSearchGateway = true;
|
// //算了,在这里启动远程连接吧,反正也就执行一次
|
// HdlLinkCloudConnectLogic.Current.StartCloudMqttConnection();
|
|
// var listGateway = HdlLinkGatewayLogic.Current.GetAllLocalGateway();
|
// var dicGateway = new Dictionary<string, ZigBee.Device.LinkGateway>();
|
// foreach (var gw in listGateway)
|
// {
|
// //获取本地全部的A网关的mac
|
// dicGateway[gw.GwMac] = gw;
|
// }
|
// //重复检测
|
// var listCheck = new HashSet<string>();
|
|
// var sendData = "Topic:/user/all/custom/gateway/search\r\n";
|
|
// var dic = new Dictionary<string, string>();
|
// dic["id"] = HdlGatewayResourse.AGatewayLinkFlage;
|
// dic["time_stamp"] = HdlHttpLogic.Current.GetTimestamp().PadRight(13, '0');
|
// var bodyData = Newtonsoft.Json.JsonConvert.SerializeObject(dic);
|
// sendData += "Length:" + bodyData.Length + "\r\n\r\n";
|
// sendData += bodyData;
|
|
// //初始化udp
|
// var udpLogic = new HdlUdpLogic();
|
// if (udpLogic.InitUdp("239.0.168.188", 8585) == false)
|
// {
|
// //关闭udp
|
// udpLogic.CloseUdp();
|
|
// resultEvent?.Invoke(-1, null);
|
// return;
|
// }
|
|
// HDL_ON.DriverLayer.Control.Ins.OpenUdp(8585);
|
|
// //接收事件
|
// Action<System.Net.IPEndPoint, string> actionEvent = (ipPoint, result) =>
|
// {
|
// //处理搜索A网关时,网关回复的数据
|
// try
|
// {
|
// /////
|
// System.Net.IPAddress s = ipPoint.Address;
|
// MainPage.Log("TcpClient->SearchLinkGateway", $"{s}==网关搜索本地回复,数据内容{result}");
|
|
// //检验A协议网关主题(如果检验是指定主题,则返回负载数据,否则返回null)
|
// var resultData = HdlLinkGatewaySendLogic.Current.CheckLinkGatewayTopic("/user/all/custom/gateway/search_reply", result);
|
// if (resultData == null) { return; }
|
// //调用回调函数
|
// var info = Newtonsoft.Json.JsonConvert.DeserializeObject<AGatewayInfo>(resultData);
|
// if (info == null)
|
// {
|
// //数据异常，退出
|
// return;
|
// }
|
// if (!(string.IsNullOrEmpty(info.HomeId) == true || info.HomeId == Common.Config.Instance.HomeId))
|
// {
|
// //网关已经绑定其他住宅，退出
|
// return;
|
// }
|
// ///tcp连接目标设备的ip
|
// info.Ip_address = ipPoint.Address.ToString();
|
// //搜索到的这个网关,是否是存在在本地了的
|
// if (dicGateway.ContainsKey(info.Device_mac) == true)
|
// {
|
// var gateWay = dicGateway[info.Device_mac];
|
// //如果搜索得到本地存在的网关,则使用本地通信
|
// gateWay.OnlineStatu = 1;
|
// gateWay.isLocalEncrypt = info.isLocalEncrypt;
|
// gateWay.Master = info.Master;
|
// //gateWay.Slaver_list1 = info.Slaver_list1;
|
// gateWay.Oid = info.Oid;
|
// gateWay.InGatewayHomeId = info.HomeId;
|
// info.IsBindGateway = true;
|
|
// Common.Config.Instance.Home.NowHomeOnlineStatu = "1";
|
// }
|
// //搜索到的网关,建立链接
|
// if (connectLocalOnly == false || info.IsBindGateway == true)
|
// {
|
// this.ConnectLocalLinkGateway(info.Device_mac, info.Ip_address, info.GatewayId, info.isLocalEncrypt);
|
// }
|
// else
|
// {
|
// //获取连接对象
|
// var connectObj = this.GetConnectObject(info.Device_mac, false);
|
// if (connectObj != null)
|
// {
|
// //如果有这个对象, 则替换一下它的网关id
|
// connectObj.GatewayId = info.GatewayId;
|
// connectObj.localEncrypt = info.isLocalEncrypt;
|
// return;
|
// }
|
// }
|
// if (listCheck.Contains(info.Device_mac) == true)
|
// {
|
// //已经处理过了
|
// return;
|
// }
|
// listCheck.Add(info.Device_mac);
|
|
|
//#if DEBUG
|
// Console.WriteLine($"搜索网关捕抓到网关:{info.Device_mac}");
|
//#endif
|
// //info
|
|
// //回调函数
|
// resultEvent?.Invoke(1, info);
|
// }
|
// catch (Exception e)
|
// {
|
// string str = e.Message;
|
// }
|
// };
|
// udpLogic.ReceviceEvent += actionEvent;
|
// var dateTime = System.DateTime.Now.AddSeconds(searchTime);
|
// while (this.isSearchGateway && System.DateTime.Now < dateTime)
|
// {
|
// udpLogic.SendData(sendData, "239.0.168.188", 8585);
|
// udpLogic.SendData(sendData, "255.255.255.255", 8585);
|
// System.Threading.Thread.Sleep(1000);
|
// }
|
// udpLogic.ReceviceEvent -= actionEvent;
|
// //别关那么快
|
// System.Threading.Thread.Sleep(300);
|
// this.isSearchGateway = false;
|
// //关闭udp
|
// udpLogic.CloseUdp();
|
|
// }
|
|
// /// <summary>
|
// /// 停止搜索Link网关
|
// /// </summary>
|
// public void StopSearchLinkGateway()
|
// {
|
// this.isSearchGateway = false;
|
// }
|
|
#endregion
|
|
#region ■ 链接本地Link网关___________________
|
|
/// <summary>
|
/// 链接Link网关
|
/// </summary>
|
/// <param name="i_mac">网关mac</param>
|
/// <param name="i_ipAdrr">网关ip</param>
|
/// <param name="i_gwId">网关Id</param>
|
/// <param name="isBinded">该tcp所指向的网关,是否是当前住宅所绑定的</param>
|
/// <returns></returns>
|
public void ConnectLocalLinkGateway(string i_mac, string i_ipAdrr, string i_gwId, bool localEncrypt)
|
{
|
if (i_mac == string.Empty || i_ipAdrr == string.Empty)
|
{
|
return;
|
}
|
var connectData = new TcpConnectData();
|
connectData.GatewayId = i_gwId;
|
connectData.GatewayIp = i_ipAdrr;
|
connectData.GatewayMac = i_mac;
|
connectData.localEncrypt = localEncrypt;
|
lock (this.listTcpClient)
|
{
|
//找到当前网关的连接
|
if (this.listTcpClient.Find((v) => v.GatewayMac == i_mac) != null)
|
{
|
return;
|
}
|
this.listTcpClient.Add(connectData);
|
}
|
|
try
|
{
|
//TCP连接
|
connectData.tcpClient = new Communication.TcpClient(i_ipAdrr, 8586);
|
connectData.tcpClient.Connect();
|
connectData.tcpClient.ReadFormSocket();
|
connectData.tcpClient.ExitEvent += (s, e) =>
|
{
|
StopConnectLinkGateway(connectData);
|
};
|
connectData.tcpClient.ReceiveBytesAction += (topic, bytes, socket) =>
|
{
|
managerLinkGatewayData(topic, bytes, socket);
|
};
|
|
|
}
|
catch
|
{
|
#if DEBUG
|
//HdlMessageLogic.Current.ShowMassage(ShowMsgType.Tip, i_ipAdrr + "Tcp链接不了");
|
#endif
|
StopConnectLinkGateway(connectData);
|
}
|
}
|
|
public TcpConnectData GetConnectObjectBySocket(Socket socket)
|
{
|
lock (listTcpClient)
|
{
|
var tcpConnectData = listTcpClient.Find(tcd => tcd.tcpClient._socket == socket);
|
return tcpConnectData;
|
}
|
}
|
|
/// <summary>
|
/// 断开全部的Link网关连接
|
/// </summary>
|
public void StopAllConnectLinkGateway()
|
{
|
var listTemp = new List<TcpConnectData>();
|
for (int i = 0; i < this.listTcpClient.Count; i++)
|
{
|
//创另外一个对象出来,是有作用的
|
listTemp.Add(this.listTcpClient[i]);
|
}
|
foreach (var data in listTemp)
|
{
|
//断开指定的link网关连接
|
this.StopConnectLinkGateway(data);
|
}
|
//清空缓存
|
this.listTcpClient.Clear();
|
}
|
|
/// <summary>
|
/// 断开指定的link网关连接
|
/// </summary>
|
/// <param name="mac">需要断开连接的网关mac</param>
|
public void StopConnectLinkGateway(string mac)
|
{
|
var tempGateway = listTcpClient.Find((v) => v.GatewayMac == mac);
|
if (tempGateway != null)
|
{
|
//断开指定的link网关连接
|
this.StopConnectLinkGateway(tempGateway);
|
}
|
}
|
|
/// <summary>
|
/// 断开指定的link网关连接
|
/// </summary>
|
/// <param name="connectData">连接数据</param>
|
private void StopConnectLinkGateway(TcpConnectData connectData)
|
{
|
lock (listTcpClient)
|
{
|
this.listTcpClient.Remove(connectData);
|
connectData.tcpClient.Dispose();
|
}
|
}
|
|
#endregion
|
|
#region ■ 发送数据到Link网关_________________
|
/// <summary>
|
/// 发送数据到本地Link网关
|
/// </summary>
|
/// <param name="connectData">链接信息</param>
|
/// <param name="sendData">发送的数据</param>
|
/// <returns></returns>
|
private void DoSendDataToLinkGateway(TcpConnectData connectData, string sendData)
|
{
|
#if DEBUG
|
MainPage.Log(DateTime.Now + ":TcpClient->DoSendDataToLinkGateway", $"本地发送数据，Data:{sendData}");
|
#endif
|
byte[] byteData;
|
//44bytes 加密数据 AES加密 base64密文
|
////目前默认都是加密载荷
|
//byteData = this.AesEncryptPayload(byteData, Config.Instance.Home.localSecret);
|
//解密负载数据(因为写密钥给网关一定明文，因为那时网关还没有密钥)
|
if (connectData.localEncrypt)
|
{
|
var headerAndBody = sendData.Split("\r\n\r\n");
|
string topic = headerAndBody[0].Split("\r\n")[0];
|
//加密载荷
|
var byteBody = this.AesEncryptPayload(System.Text.Encoding.UTF8.GetBytes(headerAndBody[1]), DB_ResidenceData.Instance.CurrentRegion.localSecret);
|
var header = System.Text.Encoding.UTF8.GetBytes($"{topic}\r\nLength:{byteBody.Length}\r\n" + "\r\n");
|
|
byteData = new byte[header.Length + byteBody.Length];
|
System.Array.Copy(header, 0, byteData, 0, header.Length);
|
///参数（源文件，取源文件索引值，存储器，存放位置，源文件长度）
|
System.Array.Copy(byteBody, 0, byteData, header.Length, byteBody.Length);
|
|
}
|
else
|
{
|
byteData = Encoding.UTF8.GetBytes(sendData);
|
}
|
|
//byteData = Encoding.UTF8.GetBytes(sendData);
|
//将数据写入网络流
|
connectData.tcpClient?.CommSend(byteData, byteData.Length);
|
}
|
|
#endregion
|
|
#region ■ 处理Link网关的数据_________________
|
|
/// <summary>
|
/// 处理接收本地Link网关的数据(返回值 0:还不存在完成的数据 1:已经存在完成的数据)
|
/// </summary>
|
/// <param name="listByte">数据</param>
|
private void managerLinkGatewayData(string topic, byte[] bytes, Socket socket)
|
{
|
try
|
{
|
var arryTopic = topic.Split(new string[] { "/" }, StringSplitOptions.RemoveEmptyEntries);
|
if (arryTopic.Length < 2)
|
{
|
//非正规主题
|
return;
|
}
|
|
|
var connectData = this.GetConnectObjectBySocket(socket);
|
if (connectData == null)
|
{
|
return;
|
}
|
string gatewayMac = connectData.GatewayMac;
|
string gatewayId = connectData.GatewayId;
|
///解密负载数据
|
if (connectData.localEncrypt == true)
|
{
|
var tempBytes = bytes;
|
bytes = this.AesDecryptPayload(bytes, DB_ResidenceData.Instance.CurrentRegion.localSecret);
|
if (bytes == null)
|
{
|
bytes = tempBytes;
|
}
|
}
|
/////目前网关默认都是加密的
|
//bytes = this.AesDecryptPayload(bytes, Config.Instance.Home.localSecret);
|
var bodyData = System.Text.Encoding.UTF8.GetString(bytes);
|
|
MainPage.Log(DateTime.Now + ":Control_Tcp->本地接收数据", $"Topic:{topic}\r\nData:{bodyData}");
|
|
if (topic.Contains("thing/property/up") == true)
|
{
|
//这个是Link设备的状态上报,别整,只要zigbee的
|
var temp = Newtonsoft.Json.JsonConvert.DeserializeObject<AlinkFunctionStatusObj>(bodyData);
|
|
return;
|
}
|
|
}
|
catch (Exception e)
|
{
|
}
|
}
|
|
|
#endregion
|
|
#region ■ 结构体_____________________________
|
|
|
/// <summary>
|
/// Tcp连接信息
|
/// </summary>
|
public class TcpConnectData
|
{
|
/// <summary>
|
/// 网关的mac(主键使用)
|
/// </summary>
|
public string GatewayMac = string.Empty;
|
/// <summary>
|
/// 网关ip
|
/// </summary>
|
public string GatewayIp = string.Empty;
|
/// <summary>
|
/// 网关Id(不是云端的那个)
|
/// </summary>
|
public string GatewayId = string.Empty;
|
|
//
|
public Communication.TcpClient tcpClient;
|
|
/// <summary>
|
/// 本地是否加密
|
/// </summary>
|
public bool localEncrypt;
|
}
|
#endregion
|
|
#region ■ 加密以及解密_______________________
|
|
/// <summary>
|
/// 加密负载为二进制流(Link专用)
|
/// </summary>
|
/// <param name="toEncryptArray"></param>
|
/// <param name="key"></param>
|
/// <returns></returns>
|
private byte[] AesEncryptPayload(byte[] toEncryptArray, string key)
|
{
|
//加密密钥为空
|
if (key == string.Empty)
|
{
|
return toEncryptArray;
|
}
|
try
|
{
|
if (string.IsNullOrEmpty(key)) return toEncryptArray;
|
//配置AES加密Key(密钥、向量、模式、填充)
|
var rm = new System.Security.Cryptography.RijndaelManaged
|
{
|
Key = Encoding.UTF8.GetBytes(key),
|
IV = Encoding.UTF8.GetBytes(key),
|
Mode = System.Security.Cryptography.CipherMode.CBC,
|
Padding = System.Security.Cryptography.PaddingMode.PKCS7
|
};
|
|
//创建AES加密器对象
|
var cTransform = rm.CreateEncryptor();
|
//使用AES将明文流转成密文字节数组
|
return cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length);
|
}
|
catch
|
{
|
return null;
|
}
|
}
|
|
/// <summary>
|
/// 采用Aes解密负载数据(Link专用)
|
/// </summary>
|
/// <param name="toEncryptArray"></param>
|
/// <param name="key"></param>
|
/// <returns></returns>
|
private byte[] AesDecryptPayload(byte[] toEncryptArray, string key)
|
{
|
//解密密钥为空
|
if (key == string.Empty)
|
{
|
return toEncryptArray;
|
}
|
|
try
|
{
|
//配置AES加密Key(密钥、向量、模式、填充)
|
var rm = new System.Security.Cryptography.RijndaelManaged
|
{
|
Key = Encoding.UTF8.GetBytes(key),
|
IV = Encoding.UTF8.GetBytes(key),
|
Mode = System.Security.Cryptography.CipherMode.CBC,
|
Padding = System.Security.Cryptography.PaddingMode.PKCS7
|
};
|
|
//创建AES解密器对象
|
var cTransform = rm.CreateDecryptor();
|
|
//使用AES将密文流转成明文的字节数组
|
return cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length);
|
}
|
catch
|
{
|
return null;
|
}
|
}
|
|
#endregion
|
|
}
|
}
|
namespace Communication
|
{
|
//TCP客户端实现
|
public class TcpClient
|
{
|
private const int MAX_RECONNECT_TIMES = 3; //断线重连尝试次数
|
|
//soket对象及参数
|
public Socket _socket;
|
private string host;
|
private int port;
|
private bool reconnect;
|
private bool run = true;
|
private int ConnecteFailedCount { get; set; }
|
public int ReconnectStatistics { get; private set; }
|
|
private static uint _keepAliveTime = 5000; //无数据交互持续时间(ms)
|
private static uint _keepAliveInterval = 500; //发送探测包间隔(ms)
|
|
//重连失败事件
|
public event EventHandler ExitEvent;
|
public Action<string, byte[], Socket> ReceiveBytesAction;
|
|
//构造函数
|
public TcpClient(string host, int port)
|
{
|
this.host = host;
|
this.port = port;
|
reconnect = false;
|
ConnecteFailedCount = 0;
|
}
|
|
//连接
|
public void Connect()
|
{
|
byteList = new List<byte>(1024 * 5);
|
_socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream,
|
ProtocolType.Tcp);
|
_socket.Connect(host, port);
|
MainPage.Log("TcpClient->Reconnect", $"连接成功，IP:{host}");
|
ConnecteFailedCount = MAX_RECONNECT_TIMES;
|
|
//设置KeepAlive
|
_socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.KeepAlive, true);
|
byte[] optionValue = new byte[12];
|
BitConverter.GetBytes(1).CopyTo(optionValue, 0);
|
BitConverter.GetBytes(_keepAliveTime).CopyTo(optionValue, 4);
|
BitConverter.GetBytes(_keepAliveInterval).CopyTo(optionValue, 8);
|
_socket.IOControl(IOControlCode.KeepAliveValues, optionValue, null);
|
}
|
|
//重连
|
public bool Reconnect()
|
{
|
ReconnectStatistics++;
|
reconnect = false;
|
close();
|
try
|
{
|
MainPage.Log("TcpClient->Reconnect", $"重新开始连接，IP:{host}");
|
Connect();
|
}
|
catch (Exception e)
|
{
|
ConnecteFailedCount--;
|
if (ConnecteFailedCount > 0)
|
{
|
//Console.WriteLine("重试次数剩余{0}",ConnecteFailedCount);
|
reconnect = true;
|
return true;
|
}
|
else
|
{
|
//重连失败事件
|
return false;
|
}
|
}
|
return true;
|
}
|
|
/// <summary>
|
/// 关闭
|
/// </summary>
|
private void close()
|
{
|
try
|
{
|
MainPage.Log("TcpClient->Close", $"Socket 关闭，IP:{host}");
|
_socket.Close();
|
}
|
catch { }
|
}
|
|
|
/// <summary>
|
/// 释放资源
|
/// </summary>
|
public void Dispose()
|
{
|
run = false;
|
close();
|
}
|
|
|
//发送数据接收实现,断线重连
|
public int CommSend(byte[] buffer, int size)
|
{
|
int sendSize = 0;
|
try
|
{
|
if (_socket.Connected)
|
{
|
sendSize = _socket.Send(buffer, size, SocketFlags.None);
|
}
|
}
|
catch (Exception e)
|
{
|
MainPage.Log("TcpClient->CommSend", $"发送失败，Data:{System.Text.Encoding.UTF8.GetString(buffer)} Exception:{e.Message}");
|
ReconnectStatistics++;
|
reconnect = true;
|
}
|
return sendSize;
|
}
|
|
List<byte> byteList = new List<byte>();
|
//接收数据线程,使用阻塞方式接收数据
|
public void ReadFormSocket()
|
{
|
new System.Threading.Thread(() =>
|
{
|
int count;
|
byte[] byteBuffer = new byte[2048];
|
|
while (run)
|
{
|
try
|
{
|
try
|
{
|
count = _socket.Receive(byteBuffer, SocketFlags.None);
|
for (int i = 0; i < count; i++)
|
{
|
byteList.Add(byteBuffer[i]);
|
}
|
}
|
catch (Exception e)
|
{
|
count = 0;
|
}
|
|
//网络断开Receive返回0
|
if (count == 0 || reconnect == true)
|
{
|
if (run)
|
{
|
//重连次数用尽,退出
|
if (Reconnect() == false)
|
{
|
//通知其它功能释放及删除当前对象
|
ExitEvent?.Invoke(null, new EventArgs());
|
break;
|
}
|
}
|
else
|
{
|
ExitEvent?.Invoke(null, new EventArgs());
|
}
|
}
|
else
|
{
|
|
while (true)
|
{
|
var bytes = byteList.ToArray();
|
var topMsgs = System.Text.Encoding.UTF8.GetString(bytes).Split("\r\n");
|
|
var lenght = getLenght(topMsgs);
|
|
if (lenght <= 0)
|
{
|
//头部数据还没有接收完成
|
break;
|
}
|
//是否已经获取完整所有的数据
|
var data = new byte[lenght];
|
int index = getDataIndex(byteList);
|
if (byteList.Count < index + lenght)
|
{
|
//当前数据还没有接收完成
|
break;
|
}
|
//复制出body数据
|
System.Array.Copy(bytes, index, data, 0, data.Length);
|
|
//保留剩余的数据，以次用
|
byteList.Clear();
|
for (int i = index + lenght; i < bytes.Length; i++)
|
{
|
byteList.Add(bytes[i]);
|
}
|
var topic = getTopic(topMsgs);
|
|
ReceiveBytesAction?.Invoke(topic, data, _socket);
|
}
|
}
|
}
|
catch (Exception e)
|
{
|
MainPage.Log("TcpClient->ReadFormSocket", $"Exception:{e.Message}");
|
}
|
}
|
})
|
{
|
IsBackground = true
|
}.Start();
|
|
}
|
|
/// <summary>
|
/// 获取内容长度
|
/// </summary>
|
/// <param name="topMsgs"></param>
|
/// <returns></returns>
|
int getLenght(string[] topMsgs)
|
{
|
for (int i = 0; i < topMsgs.Length; i++)
|
{
|
string topMsg = topMsgs[i].Trim();
|
if (topMsg.StartsWith("Length:"))
|
{
|
return int.Parse(topMsg.Replace("Length:", ""));
|
}
|
}
|
//找不到长度
|
return -1;
|
}
|
|
/// <summary>
|
/// 获取主题
|
/// </summary>
|
/// <param name="topMsgs"></param>
|
/// <returns></returns>
|
private string getTopic(string[] topMsgs)
|
{
|
for (int i = 0; i < topMsgs.Length; i++)
|
{
|
var topMsg = topMsgs[i].Trim();
|
if (topMsg.StartsWith("Topic:"))
|
{
|
return topMsg.Replace("Topic:", "");
|
}
|
}
|
//找不到主题
|
return null;
|
}
|
|
/**
|
* 获取数据的开始位置
|
* @param arrayList 接收到的所有数据
|
* @return 数据位的开始索引
|
*/
|
int getDataIndex(List<byte> arrayList)
|
{
|
var r = (byte)'\r';
|
var n = (byte)'\n';
|
for (int i = 0; i < arrayList.Count; i++)
|
{
|
//找出数据内容前面的两个换行
|
if (3 <= i && arrayList[i - 3] == r && arrayList[i - 2] == n && arrayList[i - 1] == r && arrayList[i] == n)
|
{
|
//剩余的数据
|
return i + 1;
|
}
|
}
|
return -1;
|
}
|
|
|
}
|
}
|
