/// <summary>
/// Registers a packetHandler. This handler will be invoked if this connection
/// receives the given type.
/// </summary>
/// <param name="packetType">Type of the packet we would like to receive.</param>
/// <param name="handler">The handler which should be invoked.</param>
public void RegisterPacketHandler(Type packetType, PacketReceivedHandler handler)
{
if (!packetHandler.ContainsKey(packetType))
{
packetHandler.Add(packetType, handler);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="NetworkManagerAsync"/> class.
/// </summary>
/// <param name="connection"><see cref="Socket"/> to wrap.</param>
/// <param name="networkHandler"><see cref="PacketReceivedHandler"/> that will handle incoming packet.</param>
/// <param name="packetReceivedFailedHandler"><see cref="PacketReceivedFailedHandler"/> that will handle incoming packet that failed to read.</param>
/// <exception cref="System.ArgumentNullException"/>
public NetworkManagerAsync(Socket connection,
PacketReceivedHandler packetReceivedHandler,
PacketReceivedFailedHandler packetReceivedFailedHandler)
{
if (PacketDictionary == null) // could a use a static constructor?
{
InitializePacketDictionary();
}
if (connection == null)
{
throw new ArgumentNullException("connection");
}
if (packetReceivedHandler == null)
{
throw new ArgumentNullException("packetReceivedHandler");
}
Connection = connection;
PacketReceived = packetReceivedHandler;
PacketReceivedFailed = packetReceivedFailedHandler;
CoCCrypto = new CoCCrypto();
ReceiveEventPool = new SocketAsyncEventArgsPool(25);
SendEventPool = new SocketAsyncEventArgsPool(25);
StartReceive(ReceiveEventPool.Pop());
}
/// <summary>
/// Initializes a new instance of the <see cref="NetworkManagerAsync"/> class.
/// </summary>
/// <param name="connection"><see cref="Socket"/> to wrap.</param>
/// <param name="networkHandler"><see cref="PacketReceivedHandler"/> that will handle incoming packet.</param>
/// <param name="packetReceivedFailedHandler"><see cref="PacketReceivedFailedHandler"/> that will handle incoming packet that failed to read.</param>
/// <exception cref="System.ArgumentNullException"/>
public NetworkManagerAsync(Socket connection,
PacketReceivedHandler packetReceivedHandler,
PacketReceivedFailedHandler packetReceivedFailedHandler)
{
if (PacketDictionary == null) // could a use a static constructor?
{
InitializePacketDictionary();
}
if (connection == null)
{
throw new ArgumentNullException("connection");
}
if (packetReceivedHandler == null)
{
throw new ArgumentNullException("packetReceivedHandler");
}
Connection = connection;
PacketReceived = packetReceivedHandler;
PacketReceivedFailed = packetReceivedFailedHandler;
Seed = MathHelper.Random.Next(); // must make this moar flexible
CoCCrypto = new CoCCrypto();
ReceiveEventPool = new SocketAsyncEventArgsPool(25);
SendEventPool = new SocketAsyncEventArgsPool(25);
StartReceive();
}
/// <summary>
/// Registers a udp packetHandler. This handler will be invoked if this connection
/// receives the given type.
/// </summary>
/// <param name="packetType">Type of the packet we would like to receive.</param>
/// <param name="handler">The handler which should be invoked.</param>
public void UDP_RegisterPacketHandler(Type packetType, PacketReceivedHandler handler)
{
if (udpConnection != null && udpConnection.IsAlive)
{
udpConnection.RegisterPacketHandler(packetType, handler);
}
udpPacketHandlerBuffer.Add(new Tuple <Type, PacketReceivedHandler>(packetType, handler));
}
/// <summary>
/// Registers a packetHandler for raw data requests.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="handler"></param>
internal void RegisterStaticRawDataHandler <T>(string key, PacketReceivedHandler <T> handler) where T : Packet
{
if (string_methodInfo.ContainsKey(key))
{
return; //Never register a string key twice.
}
string_methodInfo.Add(key, handler);
}
public RequestHandler(IServiceProvider serviceProvider)
{
_serviceProvider = serviceProvider;
_packetHandler = async(packet, connection) =>
await Handle(packet, new List <IActionBag> {
new ConnectionBag(connection)
}).ConfigureAwait(false);
}
/// <inheritdoc cref="IPacketHandler.RegisterStaticPacketHandler{P}"/>
public void UDP_RegisterStaticPacketHandler <P>(PacketReceivedHandler <P> handler) where P : Packet
{
if (IsAlive_UDP)
{
udpConnection.RegisterStaticPacketHandler <P>(handler);
}
else
{
udpStaticPacketHandlerBuffer.Add(new Tuple <Type, Delegate>(typeof(P), handler));
}
}
/// <summary>
/// Registers a packetHandler for UDP. This handler will be invoked if this connection
/// receives the given type.
/// </summary>
/// <typeparam name="T">The type we would like to receive.</typeparam>
/// <param name="handler">The handler which should be invoked.</param>
/// <param name="obj">The object which wants to receive the packet.</param>
/// <exception cref="System.NotImplementedException"></exception>
public void UDP_RegisterPacketHandler <T>(PacketReceivedHandler <T> handler, object obj) where T : Packet
{
if (IsAlive_UDP)
{
udpConnection.RegisterPacketHandler <T>(handler, obj);
}
else
{
udpPacketHandlerBuffer.Add(new Tuple <Type, Delegate, object>(typeof(T), handler, obj));
}
}
/// <summary>
/// Registers a packetHandler for TCP. This handler will be invoked if this connection
/// receives the given type.
/// </summary>
/// <typeparam name="T">The type we would like to receive.</typeparam>
/// <param name="handler">The handler which should be invoked.</param>
/// <exception cref="System.NotImplementedException"></exception>
public void TCP_RegisterStaticPacketHandler <T>(PacketReceivedHandler <T> handler) where T : Packet
{
if (IsAlive_TCP)
{
tcpConnection.RegisterStaticPacketHandler <T>(handler);
}
else
{
tcpStaticPacketHandlerBuffer.Add(new Tuple <Type, Delegate>(typeof(T), handler));
}
}
/// <inheritdoc cref="IPacketHandler.RegisterPacketHandler{P}"/>
public void TCP_RegisterPacketHandler <P>(PacketReceivedHandler <P> handler, object obj) where P : Packet
{
if (IsAlive_TCP)
{
tcpConnection.RegisterPacketHandler <P>(handler, obj);
}
else
{
tcpPacketHandlerBuffer.Add(new Tuple <Type, Delegate, object>(typeof(P), handler, obj));
}
}
/// <summary>
/// Initializes a new instance of the <see cref="NetworkManagerAsync"/> class.
/// </summary>
/// <param name="connection"><see cref="Socket"/> to wrap.</param>
/// <param name="networkHandler"><see cref="PacketReceivedHandler"/> that will handle incoming packet.</param>
/// <param name="packetReceivedFailedHandler"><see cref="PacketReceivedFailedHandler"/> that will handle incoming packet that failed to read.</param>
/// <exception cref="System.ArgumentNullException"/>
public NetworkManagerAsync(Socket connection,
PacketReceivedHandler packetReceivedHandler,
PacketReceivedFailedHandler packetReceivedFailedHandler)
{
if (PacketDictionary == null) // could a use a static constructor?
InitializePacketDictionary();
if (connection == null)
throw new ArgumentNullException("connection");
if (packetReceivedHandler == null)
throw new ArgumentNullException("packetReceivedHandler");
Connection = connection;
PacketReceived = packetReceivedHandler;
PacketReceivedFailed = packetReceivedFailedHandler;
CoCCrypto = new CoCCrypto();
ReceiveEventPool = new SocketAsyncEventArgsPool(25);
SendEventPool = new SocketAsyncEventArgsPool(25);
StartReceive(ReceiveEventPool.Pop());
}
/// <summary>
/// Initializes a new instance of the <see cref="NetworkManagerAsync"/> class.
/// </summary>
/// <param name="connection"><see cref="Socket"/> to wrap.</param>
/// <param name="networkHandler"><see cref="PacketReceivedHandler"/> that will handle incoming packet.</param>
/// <param name="packetReceivedFailedHandler"><see cref="PacketReceivedFailedHandler"/> that will handle incoming packet that failed to read.</param>
/// <exception cref="System.ArgumentNullException"/>
public NetworkManagerAsync(Socket connection,
PacketReceivedHandler packetReceivedHandler,
PacketReceivedFailedHandler packetReceivedFailedHandler)
{
if (PacketDictionary == null) // could a use a static constructor?
InitializePacketDictionary();
if (connection == null)
throw new ArgumentNullException("connection");
if (packetReceivedHandler == null)
throw new ArgumentNullException("packetReceivedHandler");
Connection = connection;
PacketReceived = packetReceivedHandler;
PacketReceivedFailed = packetReceivedFailedHandler;
Seed = MathHelper.Random.Next(); // must make this moar flexible
CoCCrypto = new CoCCrypto();
ReceiveEventPool = new SocketAsyncEventArgsPool(25);
SendEventPool = new SocketAsyncEventArgsPool(25);
StartReceive();
}
/// <summary> Registers the given <see cref="PacketReceivedHandler{T}"/> for all <see cref="RawData"/> packets with the given <see cref="string"/> key. </summary>
/// <param name="key"> The <see cref="string"/> key whose <see cref="Packet"/> should be handled by the given <see cref="PacketReceivedHandler{T}"/>. </param>
/// <param name="handler"> The <see cref="PacketReceivedHandler{T}"/> delegate to be invoked for each received <see cref="RawData"/> packet with the given key. </param>
public void RegisterRawDataHandler(string key, PacketReceivedHandler <RawData> handler)
{
packetHandlerMap.RegisterStaticRawDataHandler(key, handler);
SearchAndInvokeUnknownHandlerPackets((Delegate)handler);
}
/// <inheritdoc/>
public void RegisterPacketHandler <T>(PacketReceivedHandler <T> handler, object obj) where T : Packet
{
packetHandlerMap.RegisterPacketHandler <T>(handler, obj);
SearchAndInvokeUnknownHandlerPackets((Delegate)handler);
}
/// <inheritdoc/>
public void RegisterStaticPacketHandler <T>(PacketReceivedHandler <T> handler) where T : Packet
{
packetHandlerMap.RegisterStaticPacketHandler <T>(handler);
SearchAndInvokeUnknownHandlerPackets(handler);
}
/// <summary>
/// Registers a packetHandler. This handler will be invoked if this connection
/// receives the given type.
/// </summary>
/// <typeparam name="T">The type we would like to receive.</typeparam>
/// <param name="handler">The handler which should be invoked.</param>
/// <param name="obj">The object which wants to receive the packet.</param>
internal void RegisterPacketHandler <T>(PacketReceivedHandler <T> handler, object obj) where T : Packet
{
RegisterPacketHandler <T>((Delegate)handler, obj);
}
/// <summary>
/// Registers a packetHandler. This handler will be invoked if this connection
/// receives the given type.
/// </summary>
/// <typeparam name="T">The type we would like to receive.</typeparam>
/// <param name="handler">The handler which should be invoked.</param>
internal void RegisterStaticPacketHandler <T>(PacketReceivedHandler <T> handler) where T : Packet
{
RegisterStaticPacketHandler <T>((Delegate)handler);
}
/// <summary>
/// Registers a udp and a tcp packetHandler. This handler will be invoked if this connection
/// receives the given type.
/// </summary>
/// <param name="packetType">Type of the packet we would like to receive.</param>
/// <param name="handler">The handler which should be invoked.</param>
public void RegisterPacketHandler(Type packetType, PacketReceivedHandler handler)
{
TCP_RegisterPacketHandler(packetType, handler);
UDP_RegisterPacketHandler(packetType, handler);
}
/// <summary>
/// Registers a packetHandler for TCP and UDP. This handler will be invoked if this connection
/// receives the given type.
/// </summary>
/// <typeparam name="T">The type we would like to receive.</typeparam>
/// <param name="handler">The handler which should be invoked.</param>
/// <param name="obj">The object which wants to receive the packet.</param>
/// <exception cref="System.NotImplementedException"></exception>
public void RegisterPacketHandler <T>(PacketReceivedHandler <T> handler, object obj) where T : Packet
{
TCP_RegisterPacketHandler <T>(handler, obj);
UDP_RegisterPacketHandler <T>(handler, obj);
}
/// <summary>
/// Registers a udp packetHandler. This handler will be invoked if this connection
/// receives the given type.
/// </summary>
/// <param name="packetType">Type of the packet we would like to receive.</param>
/// <param name="handler">The handler which should be invoked.</param>
public void UDP_RegisterPacketHandler(Type packetType, PacketReceivedHandler handler)
{
if (udpConnection != null && udpConnection.IsAlive)
udpConnection.RegisterPacketHandler(packetType, handler);
udpPacketHandlerBuffer.Add(new Tuple<Type, PacketReceivedHandler>(packetType, handler));
}
/// <summary>
/// Starts connection with nRF and initializes it in RX mode. If init is successful, it starts listening for data
/// and returns true
/// </summary>
/// <param name="handler">If a valid delegate is specified, it will be called each time the nRF receives a packet.</param>
/// <returns></returns>
public static bool Init(int cont, byte pipe, PacketReceivedHandler handler = null)
{
// Comment/uncomment the following lines to select the USB-to-SPI interface to use. Make sure the pin definitions above match th
// actual hardware connections.
// Uncomment the following two lines to use with MCP2210/Aardvark... make sure the IRQ and CE cables math the GPIO definitions
if (cont == 0)
{
transceiver = new TJMCP2210SPITransceiver();
IRQPin = TJGPIOPins.TJGPIO_2; // Uncomment for MCP2210
CEPin = TJGPIOPins.TJGPIO_1; // Uncomment for MCP2210
}
else if (cont == 1)
{
transceiver = new TJAardvarkSPITransceiver();
IRQPin = TJGPIOPins.TJGPIO_0; // Uncomment for aardvark
CEPin = TJGPIOPins.TJGPIO_1; // Uncomment for aardvark
}
if (transceiver.Init())
{
transceiver.SetGPIODirection(IRQPin);
Mode = RFOpMode.RFRXMode;
ConfigureRF(pipe);
if (handler != null)
PacketReceived = handler;
TXPayloads = new ConcurrentQueue<byte[]>();
NewPackets = new ConcurrentQueue<byte[]>();
StartDispatchThreads();
return true;
}
return false;
}
/// <summary>
/// "RawData" packets will be forwarded to the desired delegate.
/// </summary>
/// <param name="key">A specific raw data key. Only raw data packets with the given key will be forwarded to the given delegate.</param>
/// <param name="handler">The delegate to forward the packet to.</param>
public void RegisterRawDataHandler(string key, PacketReceivedHandler <RawData> handler)
{
objectMap.RegisterStaticRawDataHandler(key, handler);
}
/// <summary>
/// Registers a packetHandler. This handler will be invoked if this connection
/// receives the given type.
/// </summary>
/// <typeparam name="T">The type we would like to receive.</typeparam>
/// <param name="handler">The handler which should be invoked.</param>
public void RegisterStaticPacketHandler <T>(PacketReceivedHandler <T> handler) where T : Packet
{
objectMap.RegisterStaticPacketHandler <T>(handler);
}
/// <summary>
/// Registers a udp and a tcp packetHandler. This handler will be invoked if this connection
/// receives the given type.
/// </summary>
/// <param name="packetType">Type of the packet we would like to receive.</param>
/// <param name="handler">The handler which should be invoked.</param>
public void RegisterPacketHandler(Type packetType, PacketReceivedHandler handler)
{
TCP_RegisterPacketHandler(packetType, handler);
UDP_RegisterPacketHandler(packetType, handler);
}
/// <summary>
/// Registers a packetHandler for TCP and UDP. This handler will be invoked if this connection
/// receives the given type.
/// </summary>
/// <typeparam name="T">The type we would like to receive.</typeparam>
/// <param name="handler">The handler which should be invoked.</param>
/// <exception cref="System.NotImplementedException"></exception>
public void RegisterStaticPacketHandler <T>(PacketReceivedHandler <T> handler) where T : Packet
{
TCP_RegisterStaticPacketHandler <T>(handler);
UDP_RegisterStaticPacketHandler <T>(handler);
}
