/// <summary>
/// Adds a message handler.
/// </summary>
/// <param name="handler">The handler to add.</param>
public void AddHandler(INetworkMessageHandler handler)
{
foreach (Type type in handler.HandledTypes)
{
GetHandlers(type).Add(handler);
}
}
/// <summary>
/// 根据IP连接到服务器
/// </summary>
/// <param name="ip"></param>
/// <param name="port"></param>
/// <param name="callback"></param>
/// <param name="error"></param>
/// <param name="handler"></param>
public static void Connect(string ip,
short port,
Action callback = null,
Action <string> error = null,
IConnection connector = null,
INetworkMessageHandler handler = null)
{
#if !UNITY_EDITOR && !UNITY_STANDALONE
if (Application.internetReachability == NetworkReachability.NotReachable)
{
if (NetworkStatusEvent != null)
{
NetworkStatusEvent(NetworkStatus.NetworkNotReachbility);
}
if (error != null)
{
error.Invoke("Network not reachable , please check you network setting!");
}
return;
}
#endif
ConnectedEvent = callback;
ConnectErrorEvent = error;
Instance.ConnectInternal(ip, port, connector, handler);
}
/// <summary>
/// Remove the message handler. Throws an exception if the handler was not previously added.
/// </summary>
/// <param name="handler">The handler to remove.</param>
public void RemoveHandler(INetworkMessageHandler handler) {
foreach (Type type in handler.HandledTypes) {
if (GetHandlers(type).Remove(handler) == false) {
throw new InvalidOperationException("Attempt to remove handler failed");
}
}
}
/// <summary>
/// 连接到服务器
/// </summary>
protected void ConnectInternal(string ip, short port, IConnection conn, INetworkMessageHandler handler = null)
{
if (connection != null && connection.IsConnected)
{
connection.Close();
}
if (!string.IsNullOrEmpty(connectorTypeName))
{
connection = (IConnection)Activator.CreateInstance(Type.GetType(connectorTypeName, true, true));
}
if (!string.IsNullOrEmpty(messageHandlerName))
{
messageHandler = (INetworkMessageHandler)Activator.CreateInstance(Type.GetType(messageHandlerName, true, true));
}
if (messageHandler == null)
{
messageHandler = handler ?? new DefaultMessageHandler();
}
if (connection == null)
{
connection = conn ?? new TCPConnection();
}
NetworkAddress = new NetworkAddress {
ip = ip, port = port
};
ping = new Ping(ip);
Connect();
#if UNITY_EDITOR
Debug.LogFormat("Connect to server , <color=cyan>Addr:[{0}:{1}] ,connector:{2} ,wrapper:{3}.</color>", ip, port, connection.GetType(), messageHandler.GetType());
#endif
}
public void DeregisterAllHandlers(INetworkMessageHandler handlerObject)
{
_redisServer.UnSubscribe(ChannelTypes.ServerToSimulator_Data, handlerObject.MessageHandlerID, AddPendingMessage);
_areaIDToHandlerMethod.Remove(handlerObject.MessageHandlerID);
_areaIDToHandlerObject.Remove(handlerObject.MessageHandlerID);
_pendingMessages.Remove(handlerObject.MessageHandlerID);
}
public MqConnectionHandler(MqServer server)
{
_server = server;
_serverHandler = new ServerMessageHandler(server);
_channelHandler = new ChannelMessageHandler(server);
_clientHandler = new ClientMessageHandler(server);
_responseHandler = new ResponseMessageHandler(server);
_acknowledgeHandler = new AcknowledgeMessageHandler(server);
_instanceHandler = new InstanceMessageHandler(server);
}
/// <summary>
/// Remove the message handler. Throws an exception if the handler was not previously added.
/// </summary>
/// <param name="handler">The handler to remove.</param>
public void RemoveHandler(INetworkMessageHandler handler)
{
foreach (Type type in handler.HandledTypes)
{
if (GetHandlers(type).Remove(handler) == false)
{
throw new InvalidOperationException("Attempt to remove handler failed");
}
}
}
public void DeregisterAllHandlers(INetworkMessageHandler handlerObject)
{
if (_messageReceived != null)
{
foreach (var h in _messageReceived.GetInvocationList().Where(h => h.Target == handlerObject).Where(h => _messageReceived != null))
{
_messageReceived -= (EventHandler <NetworkMessageContainer>)h;
}
}
}
public NetworkCommandReceiver(SequenceIndex sequenceIndex,
INetworkManager networkManager,
INetworkMessageHandler networkMessageHandler,
INetworkMessageSerializer messageSerializer, ICommandQueue commandQueue)
{
_sequenceIndex = sequenceIndex;
_networkManager = networkManager;
_networkMessageHandler = networkMessageHandler;
_messageSerializer = messageSerializer;
_commandQueue = commandQueue;
}
public void RegisterImmediate(int messageType, INetworkMessageHandler handler)
{
var handlers = immediateMessageType2Handler[messageType];
if (handlers == null)
{
handlers = new CompositeNetworkMessageHandler();
laterMessageType2Handlers[messageType] = handlers;
}
handlers.Register(handler);
}
/// <summary>
/// 根据网络配置连接到服务器
/// </summary>
/// <param name="configuration"></param>
public static void Connect(Action callback = null,
Action <string> error = null,
IConnection conn = null,
INetworkMessageHandler handler = null)
{
Connect(NetworkConfiguration.Current.ip,
NetworkConfiguration.Current.port,
callback,
error,
conn,
handler);
}
public HmqNetworkHandler(HorseMq server)
{
_server = server;
_serverHandler = new ServerMessageHandler(server);
_queueMessageHandler = new QueueMessageHandler(server);
_routerMessageHandler = new RouterMessageHandler(server);
_pullRequestHandler = new PullRequestMessageHandler(server);
_clientHandler = new DirectMessageHandler(server);
_responseHandler = new ResponseMessageHandler(server);
_instanceHandler = new NodeMessageHandler(server);
_eventHandler = new EventMessageHandler(server);
}
public void RegisterImmediate(int messageType, INetworkMessageHandler handler)
{
CompositeNetworkMessageHandler handlers;
_immediateMessageType2Handler.TryGetValue(messageType, out handlers);
if (handlers == null)
{
handlers = new CompositeNetworkMessageHandler();
_immediateMessageType2Handler[messageType] = handlers;
}
handlers.Register(handler);
}
public NetworkCommandBroadcaster(SequenceIndex sequenceIndex,
ICommandQueue commandQueue,
INetworkManager networkManager,
INetworkMessageHandler networkMessageHandler,
INetworkMessageSerializer networkMessageSerializer)
{
_sequenceIndex = sequenceIndex;
_networkManager = networkManager;
_networkMessageHandler = networkMessageHandler;
_networkMessageSerializer = networkMessageSerializer;
_disposable = networkManager.ClientConnected.Subscribe(Observer.Create <int>(HandleClientConnected));
commandQueue.AddListener(this);
}
public void RegisterMessageHandler(INetworkMessageHandler handlerObject, EventHandler <NetworkMessageContainer> handlerMethod)
{
//_redisServer.Subscribe(ChannelTypes.SimulatorData, handlerObject.MessageHandlerID.Value, handlerMethod);
if (!_areaIDToHandlerMethod.ContainsKey(handlerObject.MessageHandlerID.Value))
{
_areaIDToHandlerMethod.Add(handlerObject.MessageHandlerID.Value, handlerMethod);
_areaIDToHandlerObject.Add(handlerObject.MessageHandlerID.Value, handlerObject);
_redisServer.Subscribe(ChannelTypes.ServerToSimulator_Data, handlerObject.MessageHandlerID.Value, AddPendingMessage);//Putting this here should ensure unique subscriptions. If the same handler is subscribed twice, it will be called twice
_pendingMessages.Add(handlerObject.MessageHandlerID, new List <SimulatorBoundMessage>());
}
else
{
_areaIDToHandlerMethod[handlerObject.MessageHandlerID.Value] += handlerMethod;
}
}
public void DeregisterMessageHandler(INetworkMessageHandler handlerObject, EventHandler <NetworkMessageContainer> handlerMethod)
{
if (_areaIDToHandlerMethod.ContainsKey(handlerObject.MessageHandlerID.Value))
{
_areaIDToHandlerMethod[handlerObject.MessageHandlerID.Value] -= handlerMethod;
if (_areaIDToHandlerMethod[handlerObject.MessageHandlerID.Value] == null)
{
_areaIDToHandlerMethod.Remove(handlerObject.MessageHandlerID);
_areaIDToHandlerObject.Remove(handlerObject.MessageHandlerID);
_pendingMessages.Remove(handlerObject.MessageHandlerID);
}
}
if (!_areaIDToHandlerMethod.ContainsKey(handlerObject.MessageHandlerID.Value))
{
_redisServer.UnSubscribe(ChannelTypes.ServerToSimulator_Data, handlerObject.MessageHandlerID.Value, AddPendingMessage);//If there are no more handlers registered for this areaID, unsubscribe from redis. Not sure if this will throw if there is no current subscription, hopefully it won't
}
}
/// <summary>
/// Removes the given message handler from the context. If the dispatcher was not previously
/// contained in the context, then an exception is thrown.
/// </summary>
/// <param name="handler">The network message handler to remove.</param>
public void RemoveMessageHandler(INetworkMessageHandler handler) {
_dispatcher.RemoveHandler(handler);
}
public void UnRegister(INetworkMessageHandler handler)
{
_handlers.Remove(handler);
}
public void Register(INetworkMessageHandler handler)
{
_handlers.Add(handler);
}
/// <summary>
/// Removes the given message handler from the context. If the dispatcher was not previously
/// contained in the context, then an exception is thrown.
/// </summary>
/// <param name="handler">The network message handler to remove.</param>
public void RemoveMessageHandler(INetworkMessageHandler handler)
{
_dispatcher.RemoveHandler(handler);
}
/// <summary>
/// Adds a message handler.
/// </summary>
/// <param name="handler">The handler to add.</param>
public void AddHandler(INetworkMessageHandler handler) {
foreach (Type type in handler.HandledTypes) {
GetHandlers(type).Add(handler);
}
}
public void DeregisterMessageHandler(INetworkMessageHandler handlerObject, EventHandler <NetworkMessageContainer> handlerMethod)
{
_messageReceived -= handlerMethod;
}
/// <summary>
/// Adds the given message handler to the network context.
/// </summary>
/// <param name="handler">The network message handler to add.</param>
public void AddMessageHandler(INetworkMessageHandler handler) {
_dispatcher.AddHandler(handler);
}
/// <summary>
/// Adds the given message handler to the network context.
/// </summary>
/// <param name="handler">The network message handler to add.</param>
public void AddMessageHandler(INetworkMessageHandler handler)
{
_dispatcher.AddHandler(handler);
}
