/// <summary>
/// This function invokes the registered handler function for a message.
/// <para>Network connections used by the NetworkClient and NetworkServer use this function for handling network messages.</para>
/// </summary>
/// <typeparam name="T">The message type to unregister.</typeparam>
/// <param name="msg">The message object to process.</param>
/// <returns></returns>
public bool InvokeHandler <T>(T msg) where T : IMessageBase
{
int msgType = MessagePacker.GetId <T>();
byte[] data = MessagePacker.Pack(msg);
return(InvokeHandler(msgType, new NetworkReader(data)));
}
public static void UnregisterHandler <T>() where T : IMessageBase
{
// use int to minimize collisions
int msgType = MessagePacker.GetId <T>();
handlers.Remove(msgType);
}
// note: original HLAPI HandleBytes function handled >1 message in a while loop, but this wasn't necessary
// anymore because NetworkServer/NetworkClient Update both use while loops to handle >1 data events per
// frame already.
// -> in other words, we always receive 1 message per Receive call, never two.
// -> can be tested easily with a 1000ms send delay and then logging amount received in while loops here
// and in NetworkServer/Client Update. HandleBytes already takes exactly one.
/// <summary>
/// This function allows custom network connection classes to process data from the network before it is passed to the application.
/// </summary>
/// <param name="buffer">The data received.</param>
internal void TransportReceive(ArraySegment <byte> buffer, int channelId)
{
// unpack message
using (PooledNetworkReader networkReader = NetworkReaderPool.GetReader(buffer))
{
try
{
int msgType = MessagePacker.UnpackId(networkReader);
if (msgType == MessagePacker.GetId <NotifyPacket>())
{
// this is a notify message, send to the notify receive
NotifyPacket notifyPacket = networkReader.ReadNotifyPacket();
ReceiveNotify(notifyPacket, networkReader, channelId);
}
else
{
// try to invoke the handler for that message
InvokeHandler(msgType, networkReader, channelId);
}
}
catch (InvalidDataException ex)
{
logger.Log(ex.ToString());
}
catch (Exception ex)
{
logger.LogError("Closed connection: " + this + ". Invalid message " + ex);
Disconnect();
}
}
}
/// <summary>
/// Replaces a handler for a particular message type.
/// <para>See also <see cref="RegisterHandler{T}(Action{NetworkConnection, T}, bool)">RegisterHandler(T)(Action(NetworkConnection, T), bool)</see></para>
/// </summary>
/// <typeparam name="T">Message type</typeparam>
/// <param name="handler">Function handler which will be invoked when this message type is received.</param>
/// <param name="requireAuthentication">True if the message requires an authenticated connection</param>
public static void ReplaceHandler <T>(Action <NetworkConnection, T> handler, bool requireAuthentication = true)
where T : struct, NetworkMessage
{
int msgType = MessagePacker.GetId <T>();
handlers[msgType] = MessagePacker.WrapHandler(handler, requireAuthentication);
}
/// <summary>
/// Unregisters a network message handler.
/// </summary>
/// <typeparam name="T">The message type to unregister.</typeparam>
public static bool UnregisterHandler <T>() where T : NetworkMessage
{
// use int to minimize collisions
int msgType = MessagePacker.GetId <T>();
return(handlers.Remove(msgType));
}
/// <summary>
/// Unregisters a network message handler.
/// </summary>
/// <typeparam name="T">The message type to unregister.</typeparam>
public static bool UnregisterHandler <T>()
//where T : struct, NetworkMessage // Wappen: For compatibility
{
// use int to minimize collisions
int msgType = MessagePacker.GetId <T>();
return(handlers.Remove(msgType));
}
/// <summary>
/// Register a handler for a particular message type.
/// <para>There are several system message types which you can add handlers for. You can also add your own message types.</para>
/// </summary>
/// <typeparam name="T">Message type</typeparam>
/// <param name="handler">Function handler which will be invoked when this message type is received.</param>
/// <param name="requireAuthentication">True if the message requires an authenticated connection</param>
public static void RegisterHandler <T>(Action <NetworkConnection, T> handler, bool requireAuthentication = true) where T : NetworkMessage
{
int msgType = MessagePacker.GetId <T>();
if (handlers.ContainsKey(msgType))
{
logger.LogWarning($"NetworkClient.RegisterHandler replacing handler for {typeof(T).FullName}, id={msgType}. If replacement is intentional, use ReplaceHandler instead to avoid this warning.");
}
handlers[msgType] = MessagePacker.MessageHandler(handler, requireAuthentication);
}
/// <summary>
/// Register a handler for a particular message type.
/// <para>There are several system message types which you can add handlers for. You can also add your own message types.</para>
/// </summary>
/// <typeparam name="T">Message type</typeparam>
/// <param name="handler">Function handler which will be invoked for when this message type is received.</param>
/// <param name="requireAuthentication">True if the message requires an authenticated connection</param>
public void RegisterHandler <T>(Action <INetworkConnection, T> handler)
{
int msgType = MessagePacker.GetId <T>();
if (logger.filterLogType == LogType.Log && messageHandlers.ContainsKey(msgType))
{
logger.Log("NetworkServer.RegisterHandler replacing " + msgType);
}
messageHandlers[msgType] = MessageHandler(handler);
}
public bool InvokeHandler <T>(T msg) where T : IMessageBase
{
NetworkWriter writer = MessagePacker.PackWriter(msg);
NetworkReader reader = NetworkReaderPool.GetPooledReader(writer.ToArraySegment());
bool result = InvokeHandler(MessagePacker.GetId <T>(), reader);
NetworkReaderPool.Recycle(reader);
NetworkWriterPool.Recycle(writer);
return(result);
}
/// <summary>
/// Register a handler for a particular message type.
/// <para>There are several system message types which you can add handlers for. You can also add your own message types.</para>
/// </summary>
/// <typeparam name="T">Message type</typeparam>
/// <param name="handler">Function handler which will be invoked for when this message type is received.</param>
/// <param name="requireAuthentication">True if the message requires an authenticated connection</param>
public void RegisterHandler <T>(Action <INetworkConnection, T> handler)
where T : IMessageBase, new()
{
int msgType = MessagePacker.GetId <T>();
if (LogFilter.Debug && messageHandlers.ContainsKey(msgType))
{
Debug.Log("NetworkServer.RegisterHandler replacing " + msgType);
}
messageHandlers[msgType] = MessageHandler(handler);
}
/// <summary>
/// Register a handler for a particular message type.
/// <para>There are several system message types which you can add handlers for. You can also add your own message types.</para>
/// </summary>
/// <typeparam name="T">Message type</typeparam>
/// <param name="handler">Function handler which will be invoked for when this message type is received.</param>
/// <param name="requireAuthentication">True if the message requires an authenticated connection</param>
public void RegisterHandler <C, T>(Action <C, T> handler, bool requireAuthentication = true)
where T : IMessageBase, new()
where C : NetworkConnection
{
int msgType = MessagePacker.GetId <T>();
if (LogFilter.Debug && messageHandlers.ContainsKey(msgType))
{
Debug.Log("NetworkServer.RegisterHandler replacing " + msgType);
}
messageHandlers[msgType] = MessageHandler(handler, requireAuthentication);
}
public static void RegisterHandler <T>(Action <NetworkConnection, T> handler) where T : IMessageBase, new()
{
int msgType = MessagePacker.GetId <T>();
if (handlers.ContainsKey(msgType))
{
if (LogFilter.Debug)
{
Debug.Log("NetworkClient.RegisterHandler replacing " + handler + " - " + msgType);
}
}
handlers[msgType] = MessagePacker.MessageHandler <T>(handler);
}
/// <summary>
/// Register a handler for a particular message type.
/// <para>There are several system message types which you can add handlers for. You can also add your own message types.</para>
/// </summary>
/// <typeparam name="T">The message type to unregister.</typeparam>
/// <param name="handler"></param>
/// <param name="requireAuthentication">true if the message requires an authenticated connection</param>
public static void RegisterHandler <T>(Action <NetworkConnection, T> handler, bool requireAuthentication = true) where T : IMessageBase, new()
{
int msgType = MessagePacker.GetId <T>();
if (handlers.ContainsKey(msgType))
{
if (logger.LogEnabled())
{
logger.Log("NetworkClient.RegisterHandler replacing " + handler + " - " + msgType);
}
}
handlers[msgType] = MessagePacker.MessageHandler(handler, requireAuthentication);
}
public static void RegisterHandler<T>(Action<NetworkConnection, T> handler) where T: IMessageBase, new()
{
int msgType = MessagePacker.GetId<T>();
if (handlers.ContainsKey(msgType))
{
if (LogFilter.Debug) Debug.Log("NetworkServer.RegisterHandler replacing " + msgType);
}
handlers[msgType] = networkMessage =>
{
T message = networkMessage.ReadMessage<T>();
handler(networkMessage.conn, message);
};
}
/// <summary>
/// This function invokes the registered handler function for a message.
/// <para>Network connections used by the NetworkClient and NetworkServer use this function for handling network messages.</para>
/// </summary>
/// <typeparam name="T">The message type to unregister.</typeparam>
/// <param name="msg">The message object to process.</param>
/// <returns></returns>
public bool InvokeHandler <T>(T msg) where T : IMessageBase
{
// get writer from pool
NetworkWriter writer = NetworkWriterPool.GetWriter();
// pack and invoke
int msgType = MessagePacker.GetId <T>();
MessagePacker.Pack(msg, writer);
bool result = InvokeHandler(msgType, new NetworkReader(writer.ToArraySegment()));
// recycle writer and return
NetworkWriterPool.Recycle(writer);
return(result);
}
/// <summary>
/// This function invokes the registered handler function for a message.
/// <para>Network connections used by the NetworkClient and NetworkServer use this function for handling network messages.</para>
/// </summary>
/// <typeparam name="T">The message type to unregister.</typeparam>
/// <param name="msg">The message object to process.</param>
/// <returns>Returns true if the handler was successfully invoked</returns>
public bool InvokeHandler <T>(T msg, int channelId) where T : NetworkMessage
{
using (PooledNetworkWriter writer = NetworkWriterPool.GetWriter())
{
// if it is a value type, just use typeof(T) to avoid boxing
// this works because value types cannot be derived
// if it is a reference type (for example NetworkMessage),
// ask the message for the real type
int msgType = MessagePacker.GetId(default(T) != null ? typeof(T) : msg.GetType());
MessagePacker.Pack(msg, writer);
ArraySegment <byte> segment = writer.ToArraySegment();
using (PooledNetworkReader networkReader = NetworkReaderPool.GetReader(segment))
return(InvokeHandler(msgType, networkReader, channelId));
}
}
public static void RegisterHandler <T>(Action <NetworkConnection, T> handler) where T : IMessageBase, new()
{
int msgType = MessagePacker.GetId <T>();
if (handlers.ContainsKey(msgType))
{
if (LogFilter.Debug)
{
Debug.Log("NetworkClient.RegisterHandler replacing " + handler.ToString() + " - " + msgType);
}
}
handlers[msgType] = (networkMessage) =>
{
handler(networkMessage.conn, networkMessage.ReadMessage <T>());
};
}
/// <summary>
/// This function invokes the registered handler function for a message.
/// <para>Network connections used by the NetworkClient and NetworkServer use this function for handling network messages.</para>
/// </summary>
/// <typeparam name="T">The message type to unregister.</typeparam>
/// <param name="msg">The message object to process.</param>
/// <returns></returns>
public bool InvokeHandler <T>(T msg, int channelId) where T : IMessageBase
{
// get writer from pool
NetworkWriter writer = NetworkWriterPool.GetWriter();
// pack and invoke
int msgType = MessagePacker.GetId(typeof(T).IsValueType ? typeof(T) : msg.GetType());
MessagePacker.Pack(msg, writer);
ArraySegment <byte> segment = writer.ToArraySegment();
NetworkReader reader = NetworkReaderPool.GetReader(segment);
bool result = InvokeHandler(msgType, reader, channelId);
NetworkReaderPool.Recycle(reader);
// recycle writer and return
NetworkWriterPool.Recycle(writer);
return(result);
}
/// <summary>
/// This function invokes the registered handler function for a message.
/// <para>Network connections used by the NetworkClient and NetworkServer use this function for handling network messages.</para>
/// </summary>
/// <typeparam name="T">The message type to unregister.</typeparam>
/// <param name="msg">The message object to process.</param>
/// <returns></returns>
public bool InvokeHandler <T>(T msg, int channelId) where T : IMessageBase
{
// get writer from pool
NetworkWriter writer = NetworkWriterPool.GetWriter();
// if it is a value type, just use typeof(T) to avoid boxing
// this works because value types cannot be derived
// if it is a reference type (for example IMessageBase),
// ask the message for the real type
int msgType = MessagePacker.GetId(typeof(T).IsValueType ? typeof(T) : msg.GetType());
MessagePacker.Pack(msg, writer);
ArraySegment <byte> segment = writer.ToArraySegment();
bool result = InvokeHandler(msgType, new NetworkReader(segment), channelId);
// recycle writer and return
NetworkWriterPool.Recycle(writer);
return(result);
}
/// <summary>
/// This function invokes the registered handler function for a message.
/// <para>Network connections used by the NetworkClient and NetworkServer use this function for handling network messages.</para>
/// </summary>
/// <typeparam name="T">The message type to unregister.</typeparam>
/// <param name="msg">The message object to process.</param>
/// <returns></returns>
public bool InvokeHandler <T>(T msg, int channelId) where T : IMessageBase
{
// get writer from pool
using (PooledNetworkWriter writer = NetworkWriterPool.GetWriter())
{
// if it is a value type, just use typeof(T) to avoid boxing
// this works because value types cannot be derived
// if it is a reference type (for example IMessageBase),
// ask the message for the real type
int msgType = MessagePacker.GetId(typeof(T).IsValueType ? typeof(T) : msg.GetType());
Debug.Log("[NetworkConnection].InvokeHandler -- msg: " + msg.ToString());
MessagePacker.Pack(msg, writer);
ArraySegment <byte> segment = writer.ToArraySegment();
using (PooledNetworkReader networkReader = NetworkReaderPool.GetReader(segment))
return(InvokeHandler(msgType, networkReader, channelId));
}
}
/* TODO use or remove
static void GenerateDataError(NetworkConnection conn, byte error)
{
NetworkError dataError = (NetworkError)error;
Debug.LogError("Mirror Server Data Error: " + dataError);
GenerateError(conn, error);
}
static void GenerateDisconnectError(NetworkConnection conn, byte error)
{
NetworkError disconnectError = (NetworkError)error;
Debug.LogError("Mirror Server Disconnect Error: " + disconnectError + " conn:[" + conn + "]:" + conn.connectionId);
GenerateError(conn, error);
}
*/
static void GenerateError(NetworkConnection conn, byte error)
{
int msgId = MessagePacker.GetId<ErrorMessage>();
if (handlers.ContainsKey(msgId))
{
ErrorMessage msg = new ErrorMessage
{
value = error
};
// write the message to a local buffer
NetworkWriter writer = new NetworkWriter();
msg.Serialize(writer);
// pass a reader (attached to local buffer) to handler
NetworkReader reader = new NetworkReader(writer.ToArray());
conn.InvokeHandler(msgId, reader);
}
}
/// <summary>
/// Unregisters a handler for a particular message type.
/// </summary>
/// <typeparam name="T">Message type</typeparam>
public void UnregisterHandler <T>()
{
int msgType = MessagePacker.GetId <T>();
messageHandlers.Remove(msgType);
}
public static void UnregisterHandler <T>() where T : IMessageBase
{
int msgType = MessagePacker.GetId <T>();
handlers.Remove(msgType);
}