/// <exclude />
public static void SubscribeToDataAfterAdd(Type dataType, DataEventHandler dataAfterAddDelegate, bool flushPersistent)
{
Verify.ArgumentNotNull(dataType, "dataType");
Verify.ArgumentNotNull(dataAfterAddDelegate, "dataAfterAddDelegate");
_dataAfterAddEventDictionary.Add(dataType, dataAfterAddDelegate, flushPersistent);
}
public static void FireEvent(DataEventHandler _event, Data data)
{
if (_event != null)
{
_event(data);
}
}
/// <exclude />
public static void UnsubscribeToDataBeforeAdd(Type dataType, DataEventHandler dataBeforeAddDelegate)
{
Verify.ArgumentNotNull(dataType, "dataType");
Verify.ArgumentNotNull(dataBeforeAddDelegate, "dataBeforeAddDelegate");
_dataBeforeAddEventDictionary.Remove(dataType, dataBeforeAddDelegate);
}
public HTransportManager(HTransport tranpsport)
{
this.Transport = tranpsport;
this.Transport.onData += Transport_onData;
this.Transport.onStatus += Transport_onStatus;
ConnectionProfile internetConnectProfile = NetworkInformation.GetInternetConnectionProfile();
if (internetConnectProfile == null)
{
this.hasNetwork = false;
}
else
{
switch (internetConnectProfile.GetNetworkConnectivityLevel())
{
case NetworkConnectivityLevel.None:
this.hasNetwork = false;
break;
case NetworkConnectivityLevel.LocalAccess:
case NetworkConnectivityLevel.InternetAccess:
case NetworkConnectivityLevel.ConstrainedInternetAccess:
this.hasNetwork = true;
break;
}
}
networkStatusChangedCallback = new NetworkStatusChangedEventHandler(OnNetworkStatusChanged);
if (!registeredNetworkStatusNotif)
{
NetworkInformation.NetworkStatusChanged += networkStatusChangedCallback;
registeredNetworkStatusNotif = true;
}
}
private void fireDataEvent(DataEventHandler handler, int itemIndex, string item)
{
if (handler != null)
{
handler(this, new DataEventArgs(itemIndex, item));
}
}
public static void Fire <TSender, TEventArgs>(this DataEventHandler <TSender, TEventArgs> eventHandler, TSender sender, TEventArgs args)
{
if (eventHandler != null)
{
eventHandler(sender, args);
}
}
public HTransportManager(HTransport tranpsport)
{
this.Transport = tranpsport;
this.Transport.onData += Transport_onData;
this.Transport.onStatus += Transport_onStatus;
ConnectionProfile internetConnectProfile = NetworkInformation.GetInternetConnectionProfile();
if (internetConnectProfile == null)
this.hasNetwork = false;
else
{
switch (internetConnectProfile.GetNetworkConnectivityLevel())
{
case NetworkConnectivityLevel.None:
this.hasNetwork = false;
break;
case NetworkConnectivityLevel.LocalAccess:
case NetworkConnectivityLevel.InternetAccess:
case NetworkConnectivityLevel.ConstrainedInternetAccess:
this.hasNetwork = true;
break;
}
}
networkStatusChangedCallback = new NetworkStatusChangedEventHandler(OnNetworkStatusChanged);
if (!registeredNetworkStatusNotif)
{
NetworkInformation.NetworkStatusChanged += networkStatusChangedCallback;
registeredNetworkStatusNotif = true;
}
}
/// <summary>
/// Virtualna metoda na obsluhu eventu (posielanie dat do vyssej urovne)
/// </summary>
/// <param name="e">EventArgs obsahujuci data</param>
protected virtual void OnReceivedData(DataEventArgs e)
{
DataEventHandler handler = this.transportDataReceived;
if (handler != null)
{
handler.BeginInvoke(this, e, null, null);
}
}
/// <summary>
/// Vytvori asynchronne volanie na metodu zabezpecujucu vytvorenie eventu
/// oznamujuceho prijatie dat
/// </summary>
/// <param name="e">EventArgs obsahujuci data</param>
protected virtual void OnReceivedData(DataEventArgs e)
{
DataEventHandler handler = this.m_receivedDataEvent;
if (handler != null)
{
handler(this, e);
}
}
protected virtual void OnSaveClick(DataEventArgs e)
{
DataEventHandler SaveClickHandler = (DataEventHandler)Events[SaveClickObject];
if (SaveClickHandler != null)
{
e.DataValue = this.SignatureHex;
this.Page.Session["SaveValueHex"] = e.DataValue;
SaveClickHandler(this, e);
}
}
/// <exclude />
public static void UnsubscribeToDataAfterAdd(Type dataType, DataEventHandler dataAfterAddDelegate)
{
if (dataType == null)
{
throw new ArgumentNullException("dataType");
}
if (dataAfterAddDelegate == null)
{
throw new ArgumentNullException("dataAfterAddDelegate");
}
_dataAfterAddEventDictionary.Remove(dataType, dataAfterAddDelegate);
}
public static void ChoosePhoneNumber(DataEventHandler <string> callback)
{
PhoneNumberChooserTask task = new PhoneNumberChooserTask();
task.Completed +=
(sender, e) =>
{
if ((callback != null) && (e != null) && !String.IsNullOrEmpty(e.PhoneNumber))
{
callback(null, new DataEventArgs <string>(e.PhoneNumber));
}
};
task.Show();
}
/// <summary>
/// Initializes the UDP server and automatically starts waiting for connections on all available local IP addresses.
/// </summary>
/// <param name="port">The local port to listen to</param>
/// <param name="newClientCallback">The method to call if a client has been found</param>
/// <param name="receivedPacketCallback">The method to call if a new packet has been received</param>
public UdpServer(int port, SocketEventHandler newClientCallback, DataEventHandler receivedPacketCallback)
{
// Initialize the listener socket
_listener = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp)
{
ExclusiveAddressUse = false, EnableBroadcast = true
};
// Start listening to any connection made to the specified port
_listener.Bind(new IPEndPoint(IPAddress.Any, port));
ClientConnectionRequested += newClientCallback;
ReceivedPacket += receivedPacketCallback;
Active = true;
Receive();
}
public HTransportManager(HTransport tranpsport)
{
this.Transport = tranpsport;
this.Transport.onData += Transport_onData;
this.Transport.onStatus += Transport_onStatus;
if (Microsoft.Phone.Net.NetworkInformation.NetworkInterface.NetworkInterfaceType == NetworkInterfaceType.None)
this.hasNetwork = false;
else
this.hasNetwork = true;
networkStatusChangedCallback = new NetworkStatusChangedEventHandler(OnNetworkStatusChanged);
if (!registeredNetworkStatusNotif)
{
NetworkInformation.NetworkStatusChanged += networkStatusChangedCallback;
registeredNetworkStatusNotif = true;
}
}
/// <summary>
/// Initializes the UDP server and automatically starts waiting for connections.
/// </summary>
/// <param name="hostname">The local IP to listen to</param>
/// <param name="port">The local port to listen to</param>
/// <param name="newClientCallback">The method to call if a client has been found</param>
/// <param name="receivedPacketCallback">The method to call if a new packet has been received</param>
public UdpServer(string hostname, int port, SocketEventHandler newClientCallback, DataEventHandler receivedPacketCallback)
{
if (!IPAddress.TryParse(hostname, out IPAddress ip))
{
throw new InvalidCastException($"Could not convert {hostname} to a valid IPAddress instance.");
}
// Initialize the listener socket
_listener = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp)
{
ExclusiveAddressUse = false, EnableBroadcast = true
};
// Start listening to the specified IP and port
_listener.Bind(new IPEndPoint(ip, port));
ClientConnectionRequested += newClientCallback;
ReceivedPacket += receivedPacketCallback;
Receive();
}
public void ParseNetworkPacket(byte[] netpacket, int length)
{
byte[] data = new byte[length];
Buffer.BlockCopy(netpacket, 4, data, 0, length);
switch (BitConverter.ToUInt16(netpacket, 0))
{
case 0xABCD:
{
object nodetime = new UtilityClass.UtcTime();
nodetime = UtilityClass.RawDeserialize(data, (Type)nodetime.GetType());
ShowNodeTime(nodetime.ToString());
break;
}
case 0xAD01:
{
if (ch1AdFile.adfile.writeOpened == false)
{
ch1AdFile.OpenFile(MainForm.pMainForm.ADPathInfo);
}
ch1AdFile.BinaryWrite(data);
ADEventHandler handler = ADDataEvent;
EventsClass.DataEventArgs e = new EventsClass.DataEventArgs("1", data, length, "");
if (handler != null)
{
handler(this, e);
}
if (ch1AdFile.FileLen > 1024 * 1024 * 100)
{
ch1AdFile.close();
ch1AdFile.OpenFile(MainForm.pMainForm.ADPathInfo);
}
break;
}
case 0xAD02:
{
if (ch2AdFile.adfile.writeOpened == false)
{
ch2AdFile.OpenFile(MainForm.pMainForm.ADPathInfo);
}
ch2AdFile.BinaryWrite(data);
ADEventHandler handler = ADDataEvent;
EventsClass.DataEventArgs e = new EventsClass.DataEventArgs("2", data, length, "");
if (handler != null)
{
handler(this, e);
}
if (ch2AdFile.FileLen > 1024 * 1024 * 100)
{
ch2AdFile.close();
ch2AdFile.OpenFile(MainForm.pMainForm.ADPathInfo);
}
break;
}
case 0xAD03:
{
if (ch3AdFile.adfile.writeOpened == false)
{
ch3AdFile.OpenFile(MainForm.pMainForm.ADPathInfo);
}
ch3AdFile.BinaryWrite(data);
ADEventHandler handler = ADDataEvent;
EventsClass.DataEventArgs e = new EventsClass.DataEventArgs("3", data, length, "");
if (handler != null)
{
handler(this, e);
}
if (ch3AdFile.FileLen > 1024 * 1024 * 100)
{
ch3AdFile.close();
ch3AdFile.OpenFile(MainForm.pMainForm.ADPathInfo);
}
break;
}
case 0xAD04:
{
if (ch4AdFile.adfile.writeOpened == false)
{
ch4AdFile.OpenFile(MainForm.pMainForm.ADPathInfo);
}
ch4AdFile.BinaryWrite(data);
ADEventHandler handler = ADDataEvent;
EventsClass.DataEventArgs e = new EventsClass.DataEventArgs("4", data, length, "");
if (handler != null)
{
handler(this, e);
}
if (ch4AdFile.FileLen > 1024 * 1024 * 100)
{
ch4AdFile.close();
ch4AdFile.OpenFile(MainForm.pMainForm.ADPathInfo);
}
break;
}
case 0xEDED:
{
ch1AdFile.close();
ch2AdFile.close();
ch3AdFile.close();
ch4AdFile.close();
}
break;
case 0xBB01:
{
if (!hasRecv)
{
WaveFile.OpenFile(MainForm.pMainForm.NetRecvDataPathInfo);
hasRecv = true;
}
WaveFile.BinaryWrite(data);
if (WaveFile.FileLen > 1024 * 1024 * 100)
{
WaveFile.close();
WaveFile.OpenFile(MainForm.pMainForm.NetRecvDataPathInfo);
}
WaveEventHandler handler = WaveDisplEvent;
EventsClass.WaveEventArgs e = new EventsClass.WaveEventArgs(data, length);
if (handler != null)
{
handler(this, e);
}
break;
}
case 0xEE01:
{
NetTCPFile.OpenFile(MainForm.pMainForm.NetRecvTCPPathInfo);
string filename = NetTCPFile.adfile.fileName;
NetTCPFile.BinaryWrite(data);
NetTCPFile.close();
try
{
MainForm.ParseLock.WaitOne();
SourceDataClass.GetData(data);
SourceDataClass.Parse();
MainForm.ParseLock.ReleaseMutex();
}
catch (Exception ex)
{
MainForm.ParseLock.ReleaseMutex();
}
DataEventHandler handler = NetDataEvent;
EventsClass.DataEventArgs e = new EventsClass.DataEventArgs(Dclient.Client.RemoteEndPoint.ToString().Split(':')[0], data, length, filename);
if (handler != null)
{
handler(this, e);
}
break;
}
case 0xACAC:
{
ACPacketHandle.Set();
//Debug.WriteLine("收到包号：" + BitConverter.ToUInt16(netpacket,4));
break;
}
//4500test
case 0x45FF:
{
var cmd = new byte[260];
byte[] netcmd = SourceDataClass.NetPackage(cmd);
MainForm.pMainForm.CommandLineWin.SendCommand("gd -n");
if (MainForm.pMainForm.CommandLineWin.SendData(netcmd)) //正确发送
{
MainForm.pMainForm.mapdoc.WriteNetLog("数据已发送！");
}
break;
}
default:
break;
}
}
/// <exclude />
public static void UnsubscribeToDataAfterBuildNew(Type dataType, DataEventHandler dataAfterBuildNewDelegate)
{
_dataAfterBuildNewEventDictionary.Remove(dataType, dataAfterBuildNewDelegate);
}
/// <exclude />
public static void SubscribeToDataAfterBuildNew <T>(DataEventHandler dataAfterBuildNewDelegate, bool flushPersistent)
where T : IData
{
SubscribeToDataAfterBuildNew(typeof(T), dataAfterBuildNewDelegate, flushPersistent);
}
public static void SubscribeToDataAfterBuildNew <T>(DataEventHandler dataAfterBuildNewDelegate)
where T : IData
{
SubscribeToDataAfterBuildNew(typeof(T), dataAfterBuildNewDelegate);
}
/// <exclude />
public static void SubscribeToDataAfterBuildNew(Type dataType, DataEventHandler dataAfterBuildNewDelegate, bool flushPersistent)
{
_dataAfterBuildNewEventDictionary.Add(dataType, dataAfterBuildNewDelegate, flushPersistent);
}
/// <exclude />
public static void SubscribeToDataBeforeUpdate <T>(DataEventHandler dataBeforeUpdateDelegate, bool flushPersistent)
where T : IData
{
SubscribeToDataBeforeUpdate(typeof(T), dataBeforeUpdateDelegate, flushPersistent);
}
public StreamController(DataEventHandler dataEventHandler)
{
_dataEventHandler = dataEventHandler;
}
/// <exclude />
public static void SubscribeToDataDeleted <T>(DataEventHandler dataDeletedDelegate, bool flushPersistent)
where T : IData
{
SubscribeToDataDeleted(typeof(T), dataDeletedDelegate, flushPersistent);
}
public static void SubscribeToDataDeleted <T>(DataEventHandler dataDeletedDelegate)
where T : IData
{
SubscribeToDataDeleted(typeof(T), dataDeletedDelegate);
}
/// <exclude />
public static void SubscribeToDataDeleted(Type dataType, DataEventHandler dataDeletedDelegate, bool flushPersistent)
{
_dataDeletedEventDictionary.Add(dataType, dataDeletedDelegate, flushPersistent);
}
public static void SubscribeToDataDeleted(Type dataType, DataEventHandler dataDeletedDelegate)
{
SubscribeToDataDeleted(dataType, dataDeletedDelegate, false);
}
public static void SubscribeToDataAfterUpdate <T>(DataEventHandler dataAfterUpdateDelegate)
where T : IData
{
SubscribeToDataAfterUpdate(typeof(T), dataAfterUpdateDelegate);
}
/// <exclude />
public static void UnsubscribeToDataBeforeUpdate(Type dataType, DataEventHandler dataBeforeUpdateDelegate)
{
_dataBeforeUpdateEventDictionary.Remove(dataType, dataBeforeUpdateDelegate);
}
private void fireDataEvent(DataEventHandler handler, int itemIndex, string item)
{
if(handler != null)
handler(this, new DataEventArgs(itemIndex, item));
}
/// <exclude />
public static void UnsubscribeToDataDeleted(Type dataType, DataEventHandler dataDeletedDelegate)
{
_dataDeletedEventDictionary.Remove(dataType, dataDeletedDelegate);
}
public static void SubscribeToDataAfterBuildNew(Type dataType, DataEventHandler dataAfterBuildNewDelegate)
{
SubscribeToDataAfterBuildNew(dataType, dataAfterBuildNewDelegate, false);
}
public static void SubscribeToDataAfterUpdate(Type dataType, DataEventHandler dataAfterUpdateDelegate)
{
SubscribeToDataAfterUpdate(dataType, dataAfterUpdateDelegate, false);
}
/// <exclude />
public static void SubscribeToDataBeforeUpdate(Type dataType, DataEventHandler dataBeforeUpdateDelegate, bool flushPersistent)
{
_dataBeforeUpdateEventDictionary.Add(dataType, dataBeforeUpdateDelegate, flushPersistent);
}
