public void SendMsg(Msg.MessageObject msgObject)
{
if (msgObject != null)
{
BaseConnect.SendMsg(msgObject);
}
}
public void SendNoSyncMsg(Msg.MessageObject msgObject)
{
if (msgObject != null)
{
this.BaseConnect.SendMsg(msgObject);
}
}
public override void SendMsg(Msg.MessageObject msg)
{
if (msg == null)
{
return;
}
msg.CmdPacked();
this.SendMsg(msg.CmdToBytes());
}
public virtual void SendMsg(Msg.MessageObject message)
{
if (message == null)
{
return;
}
message.CmdPacked();
this.SendMsg(message.CmdToBytes());
}
protected void CallDelegateReceived(Msg.MessageObject messageObject)
{
try
{
if (this.dMsgReceived != null)
{
this.dMsgReceived(messageObject);
}
}
catch { }
}
public virtual void SendMsg(Msg.MessageObject message)
{
if (message == null)
{
return;
}
message.CmdPacked();
for (int i = 0; i < message.Data.Count; i++)
{
this.SendMsg(message.Data[i]);
}
}
public override void SendMsg(Msg.MessageObject msg)
{
if (msg == null)
{
return;
}
msg.CmdPacked();
for (int i = 0; i < msg.Data.Count; i++)
{
this.SendMsg(msg.Data[i]);
}
}
protected void ReceivedDataSplit(object state)
{
while (this.isConnected)
{
byte[] receivedBytes = null;
lock (SyncObject)
{
try
{
if (receivedRingBuffer.DataCount < 3)
{
Monitor.Wait(SyncObject);
continue;
}
if (receivedRingBuffer[0] != 0xAA)
{
receivedRingBuffer.Clear(1);
continue;
}
int len = DataConvert.Bytes_To_Ushort(new byte[2] {
receivedRingBuffer[1], receivedRingBuffer[2]
}) + 5;
if (receivedRingBuffer.DataCount < len)
{
Monitor.Wait(SyncObject);
continue;
}
if (receivedRingBuffer[len - 1] != 0xBB)
{
receivedRingBuffer.Clear(1);
continue;
}
receivedBytes = new byte[len];
receivedRingBuffer.ReadFromRingBuffer(receivedBytes, 0, len);
receivedRingBuffer.Clear(len);
Monitor.Pulse(SyncObject);
}
catch { }
}
if (receivedBytes != null)
{
Msg.MessageObject msg = new Msg.MessageObject(receivedBytes);
if (msg.CheckData())
{
CallDelegateReceived(msg);
}
}
}
}
private void SortMessage(Msg.MessageObject msgObject)
{
try
{
if (msgObject == null)
{
return;
}
string key = msgObject.ToKey();
if (dictionary.ContainsKey(key))
{
dictionary[key].msgMethod = msgObject;
dictionary[key].ResetEvent.Set();
}
}
catch { }
}
private void SortMessage(Msg.MessageObject msgObject)
{
try
{
if (msgObject == null)
{
return;
}
byte head = (byte)(msgObject.CmdType & 0xF0);
if (head == 0xC0)
{
if (msgObject.CmdType == 0xC3)
{
Msg.MsgObject_GetLockStatus getLockStatus = new Msg.MsgObject_GetLockStatus
{
FrameMsg = msgObject.FrameMsg, Data = msgObject.Data
};
getLockStatus.CmdUnpacked();
if (dSwitchLock != null)
{
dSwitchLock(getLockStatus);
}
return;
}
byte key = msgObject.ToKey();
if (dictionary.ContainsKey(key))
{
dictionary[key].msgMethod = msgObject;
dictionary[key].ResetEvent.Set();
}
}
else if (head == 0xF0)
{
Msg.MsgObject_ErrorMsg error = new Msg.MsgObject_ErrorMsg
{
CmdType = msgObject.CmdType
};
error.CmdUnpacked();
if (dErrorMsg != null)
{
dErrorMsg(error);
}
}
}
catch { }
}
private void SortMessage(Msg.MessageObject msgObject)
{
try
{
if (msgObject == null)
{
return;
}
Msg.NotifyLockStatus getLockStatus = new Msg.NotifyLockStatus
{
Data = msgObject.Data
};
getLockStatus.Unpacked();
if (dLockStatus != null)
{
dLockStatus(getLockStatus);
}
}
catch { }
}
protected void ReceivedDataSplit(object state)
{
while (this.isConnected)
{
byte[] receivedBytes = null;
lock (SyncObject)
{
try
{
if (receivedRingBuffer.DataCount < 4)
{
Monitor.Wait(SyncObject);
continue;
}
if (receivedRingBuffer[0] != 8)
{
receivedRingBuffer.Clear(1);
continue;
}
if (receivedRingBuffer[1] != 129)
{
receivedRingBuffer.Clear(1);
continue;
}
receivedBytes = new byte[4];
receivedRingBuffer.ReadFromRingBuffer(receivedBytes, 0, 4);
receivedRingBuffer.Clear(4);
Monitor.Pulse(SyncObject);
}
catch { }
}
if (receivedBytes != null)
{
Msg.MessageObject msg = new Msg.MessageObject(receivedBytes);
CallDelegateReceived(msg);
}
}
}
public void SendSyncMsg(Msg.MessageObject msgObject, int tiemOut)
{
if (msgObject != null)
{
if (dictionary == null)
{
dictionary = new Dictionary <string, ManualReset>();
}
string key = msgObject.ToKey();
if (!dictionary.ContainsKey(key))
{
ManualReset manualReset = new ManualReset(false)
{
msgMethod = null
};
dictionary.Add(key, manualReset);
}
else
{
dictionary[key].msgMethod = null;
dictionary[key].ResetEvent.Reset();
}
WaitHandle[] waitHandles = new WaitHandle[] { dictionary[key].ResetEvent };
BaseConnect.SendMsg(msgObject);
int num = WaitHandle.WaitAny(waitHandles, tiemOut, false);
try
{
if ((num == 0) && (dictionary[key].msgMethod != null))
{
msgObject.UshortLen = dictionary[key].msgMethod.UshortLen;
msgObject.SetData = dictionary[key].msgMethod.SetData;
msgObject.Child = dictionary[key].msgMethod.Child;
msgObject.CmdUnpacked();
}
}
catch { }
}
}
public void SendSyncMsg(Msg.MessageObject msgObject)
{
this.SendSyncMsg(msgObject, this.timeOut);
}
protected void ReceivedDataSplit(object state)
{
while (this.isConnected)
{
byte[] receivedBytes = null;
lock (SyncObject)
{
try
{
if (receivedRingBuffer.DataCount < 8)
{
Monitor.Wait(SyncObject);
continue;
}
if (receivedRingBuffer[0] != 64)
{
receivedRingBuffer.Clear(1);
continue;
}
if (receivedRingBuffer[7] != 13)
{
receivedRingBuffer.Clear(1);
continue;
}
int len = 0;
switch (receivedRingBuffer[1])
{
case 4:
case 7:
case 8:
case 9:
case 10:
case 11:
case 13:
case 16:
len = (ushort)(((0xff & receivedRingBuffer[4]) << 8) + (0xff & receivedRingBuffer[3]));
break;
}
if (len != 0)
{
if (receivedRingBuffer.DataCount < len + 13)
{
Monitor.Wait(SyncObject);
continue;
}
if (receivedRingBuffer[8] != 62)
{
receivedRingBuffer.Clear(1);
continue;
}
if (receivedRingBuffer[len + 12] != 13)
{
receivedRingBuffer.Clear(1);
continue;
}
}
receivedBytes = new byte[len == 0?8:(len + 13)];
receivedRingBuffer.ReadFromRingBuffer(receivedBytes, 0, receivedBytes.Length);
receivedRingBuffer.Clear(receivedBytes.Length);
Monitor.Pulse(SyncObject);
}
catch { }
}
if (receivedBytes != null)
{
Msg.MessageObject msg = new Msg.MessageObject(receivedBytes);
if (msg.CheckData())
{
CallDelegateReceived(msg);
}
}
}
}
