private void Callback_OnReceive(IAsyncResult result)
{
try
{
ReceiveStateObject obj = (ReceiveStateObject)result.AsyncState;
int recvBytes = _socket.EndReceive(result);
if (0 == recvBytes)
{
Close();
return;
}
obj.buffer.writeIndex += recvBytes;
ReceiveEvent evt = new ReceiveEvent();
evt.session = this;
evt.buffer = obj.buffer;
eventQueue.Enqueue(evt);
Receive();
}
catch (System.Exception error)
{
Error(error);
}
}
public ColorMessage DispatchReceiveColorMessage(ColorMessage colorMessage)
{
if (ReceiveEvent == null)
{
return(colorMessage);
}
foreach (ReceiveEventDelegate del in ReceiveEvent.GetInvocationList())
{
try
{
colorMessage = del(colorMessage);
}
catch (Exception e)
{
ChiConsole.WriteError("Error calling colormessage handler", e);
}
if (colorMessage == null)
{
break;
}
}
return(colorMessage);
}
public void AddListener <T>(ReceiveEvent eventID, Action <T> eventHandler)
{
foreach (int id in eventID.receivingEvents)
{
compositeEventManager.AddListener <T>(id, eventHandler);
}
}
public void TestSend()
{
string q = "me";
string appKey = "3c0a72612269ebac";
string from = "zh-CHS";
string to = "en";
string salt = DateTime.Now.Millisecond.ToString();
string appSecret = "tJN4pmDy34ET8aLZmADUjCIs2YLx0OaS";
MD5 md5 = new MD5CryptoServiceProvider();
string md5Str = appKey + q + salt + appSecret;
byte[] output = md5.ComputeHash(System.Text.Encoding.UTF8.GetBytes(md5Str));
string sign = BitConverter.ToString(output).Replace("-", "");
string url = string.Format("http://openapi.youdao.com/api?appKey={0}&q={1}&from={2}&to={3}&sign={4}&salt={5}",
appKey, System.Web.HttpUtility.UrlDecode(q, System.Text.Encoding.GetEncoding("UTF-8")), from, to, sign, salt);
WebRequest translationWebRequest = WebRequest.Create(url);
WebResponse response = null;
response = translationWebRequest.GetResponse();
Stream stream = response.GetResponseStream();
Encoding encode = Encoding.GetEncoding("utf-8");
StreamReader reader = new StreamReader(stream, encode);
string result = reader.ReadToEnd();
//result = GetJsonNode(result, "basic");
ReceiveEvent?.Invoke(Json.ConvertJsonString(result));
//Debug.WriteLine(result);
}
async Task Receive()
{
var s = await _client.ReceiveAsync();
ReceiveEvent?.Invoke(s.Buffer);
Receive();
}
private void Callback_Receive(IAsyncResult result)
{
try
{
lock (this)
{
Gamnet.Buffer buffer = (Gamnet.Buffer)result.AsyncState;
int recvBytes = _socket.EndReceive(result);
if (0 == recvBytes)
{
Debug.Log("socket read '0' byte. close socket");
Disconnect();
return;
}
buffer.write_index += recvBytes;
ReceiveEvent evt = new ReceiveEvent(this);
evt.buffer = buffer;
_event_queue.Add(evt);
Receive();
}
}
catch (SocketException e)
{
Debug.LogError("[Session.Callback_Receive] session_state:" + _state + ", exception:" + e.ToString());
if (ConnectionState.Disconnected == _state)
{
return;
}
Error(new Gamnet.Exception(ErrorCode.UndefinedError, e.ToString()));
Disconnect();
}
}
//###########################################################################################
public void AddListener(ReceiveEvent eventID, Action eventHandler)
{
foreach (int id in eventID.receivingEvents)
{
eventManager.AddListener(id, eventHandler);
}
}
private void Callback_Receive(IAsyncResult result)
{
try {
Gamnet.Buffer buffer = (Gamnet.Buffer)result.AsyncState;
int recvBytes = _socket.EndReceive(result);
if (0 == recvBytes)
{
Close();
return;
}
buffer.write_index += recvBytes;
ReceiveEvent evt = new ReceiveEvent(this);
evt.buffer = buffer;
lock (_sync_obj) {
_event_queue.Add(evt);
}
Receive();
}
catch (SocketException e) {
if (ConnectionState.Disconnected == _state)
{
return;
}
Error(new Gamnet.Exception(ErrorCode.UndefinedError, e.Message));
Close();
}
}
void Receive(object socketObj)
{
Socket socket = socketObj as Socket;
while (true)
{
int receiveCount;
try
{
receiveCount = socket.Receive(_receiveBuffer);
}
catch (Exception e)
{
//关闭Link
Close(NetExceptionType.Receive, e);
return;
}
if (receiveCount == 0)
{
//关闭Link
Close(NetExceptionType.OtherSideClose, new Exception("OtherSideClose"));
return;
}
lock (_receiveTransitStream)
{
_receiveTransitStream.Oct.Write(_receiveBuffer, 0, receiveCount);
}
if (ReceiveEvent != null)
{
ReceiveEvent.Set();
}
}
}
private void Receive(string message)
{
if (verbose)
{
Debug.Log($"ZeroMQApi Receiving {subscriberIp}: {message}");
}
ReceiveEvent?.Invoke(message);
}
private void ReceiveCallback(IAsyncResult asyncResult)
{
byte[] receiveBytes = SNMPListener.EndReceive(asyncResult, ref ipEnPoint);
ReceiveEventArgs receiveArgs = new ReceiveEventArgs(receiveBytes, ipEnPoint);
ReceiveEvent.Invoke(this, receiveArgs);
SNMPListener.BeginReceive(ReceiveCallback, new SNMPState(SNMPListener, ipEnPoint));
}
/// <summary>
/// When you have received a data packet from the server and are done
/// processing it in a HandleDATA-routine, call PostToHost() to trigger
/// an event for this type.
/// </summary>
/// <typeparam name="T">Contains the data type for which the event is thrown.
/// This can be safely ommitted.</typeparam>
/// <param name="Event">Contains the event that is to be thrown.</param>
/// <param name="id">Contains the Zusi command ID.</param>
/// <param name="value">Contains the new value of the measure.</param>
protected void PostToHost <T>(ReceiveEvent <T> Event, int id, T value)
{
if (Event == null)
{
return;
}
_hostContext.Post(EventMarshal <T>, new MarshalArgs <T>(Event, id, value));
}
private void SocketClient_onReceive(object sender, ReceiveEvent e) {
if (__cSocket == e.ActiveSocket) {
__iNoPacketCount1 = 0;
}
if (__cSession == e.ActiveSocket) {
__iNoPacketCount2 = 0;
}
StockDecoder.Decode(e.ActiveSocket, e.Token, this.IsDecode);
}
// Update is called once per frame
void Update()
{
while (receiveBufferQueue.Count > 0)
{
byte[] _receiveBuffer = receiveBufferQueue.Dequeue();
if (ReceiveEvent != null)
{
ReceiveEvent.Invoke(_receiveBuffer);
}
}
}
protected override void HandleEvent(object evt)
{
if (evt is ReceiveEvent)
{
ReceiveEvent e = (ReceiveEvent)evt;
HandleBeacon(e.data, e.remoteEndPoint);
}
else if (evt is System.Exception)
{
throw (System.Exception)evt;
}
}
public void Dispose()
{
ReceiveEvent.UserToken = null;
ReceiveEvent.Completed -= ReceiveSocketEvent_Completed;
ReceiveEvent.SetBuffer(null);
socketEventPool.Push(ReceiveEvent);
SendEvent.UserToken = null;
SendEvent.Completed -= SendSocketEvnet_Completed;
socketEventPool.Push(SendEvent);
}
public virtual void registerEventHandler(ComponentSystem handler)
{
Type handlerClass = handler.GetType();
if (!Modifier.isPublic(handlerClass.Modifiers))
{
//JAVA TO C# CONVERTER WARNING: The .NET Type.FullName property will not always yield results identical to the Java Class.getName method:
logger.error("Cannot register handler {}, must be public", handler.GetType().FullName);
return;
}
//JAVA TO C# CONVERTER WARNING: The .NET Type.FullName property will not always yield results identical to the Java Class.getName method:
logger.debug("Registering event handler " + handlerClass.FullName);
foreach (Method method in handlerClass.GetMethods())
{
ReceiveEvent receiveEventAnnotation = method.getAnnotation(typeof(ReceiveEvent));
if (receiveEventAnnotation != null)
{
if (!receiveEventAnnotation.netFilter().isValidFor(networkSystem.Mode, false))
{
continue;
}
Set <Type> requiredComponents = Sets.newLinkedHashSet();
method.Accessible = true;
Type[] types = method.ParameterTypes;
logger.debug("Found method: " + method.ToString());
if (!types[0].IsSubclassOf(typeof(Event)) || !types[1].IsSubclassOf(typeof(EntityRef)))
{
logger.error("Invalid event handler method: {}", method.Name);
return;
}
requiredComponents.addAll(Arrays.asList(receiveEventAnnotation.components()));
IList <Type> componentParams = Lists.newArrayList();
for (int i = 2; i < types.Length; ++i)
{
if (!types[i].IsSubclassOf(typeof(Component)))
{
logger.error("Invalid event handler method: {} - {} is not a component class", method.Name, types[i]);
return;
}
requiredComponents.add((Type)types[i]);
componentParams.Add((Type)types[i]);
}
ByteCodeEventHandlerInfo handlerInfo = new ByteCodeEventHandlerInfo(handler, method, receiveEventAnnotation.priority(), requiredComponents, componentParams);
addEventHandler((Type)types[0], handlerInfo, requiredComponents);
}
}
}
private SocketEventProvider(Session.Session session)
{
Sending = false;
ReceiveEvent = socketEventPool.Pop();
ReceiveEvent.UserToken = session;
ReceiveEvent.Completed += ReceiveSocketEvent_Completed;
// TODO: Memory Manager
ReceiveEvent.SetBuffer(new byte[MaxBufferSize]);
SendEvent = socketEventPool.Pop();
SendEvent.UserToken = session;
SendEvent.Completed += SendSocketEvnet_Completed;
}
void Update()
{
if (_isGameStarted)
{
PollMovement();
ManageHud();
}
ReceiveEvent recEvent = base.Receive();
if (recEvent.type == NetworkEventType.DataEvent)
{
Message message = recEvent.message;
if (message.type == MessageType.SetUp)
{
SetUpMessage setupMessage = (SetUpMessage)message.GetData();
StartGame(setupMessage.activePlayers);
}
else if (message.type == MessageType.StateUpdate)
{
ChangeLog changes = (ChangeLog)message.GetData();
foreach (var kvp in _players)
{
if (!changes.PlayerLocations.ContainsKey(kvp.Key))
{
kvp.Value.isDeadImage.SetActive(true);
}
}
foreach (var playerTransform in changes.PlayerLocations)
{
CellID playerNum = playerTransform.Key;
Vector2 position = (Vector2)playerTransform.Value;
float rotation = playerTransform.Value.z;
_players[playerNum].playerObject.transform.position = position;
_players[playerNum].playerObject.transform.rotation = Quaternion.Euler(new Vector3(0, 0, rotation));
if (playerTransform.Key == _myPlayer)
{
Camera.main.transform.position = new Vector3(position.x, position.y, -10);
}
}
foreach (var kvp in changes.ChangedCells)
{
Instantiate(_players[kvp.Value].playerTrail, new Vector2(kvp.Key.x, -kvp.Key.y), Quaternion.identity);
}
}
}
}
/// <summary>
/// DR module initialization
/// </summary>
/// <param name="objectParameters"></param>
public static void DRInit(object objectParameters)
{
moduleControlDataBlock
= (ModuleControlDataBlock)objectParameters;
threadParameters = moduleControlDataBlock.ThreadParameters;
try
{
// Initialize Ready/Abort Event and threadpool
ModuleReadyEvent = threadParameters.ModuleReadyEvent;
ModuleAbortEvent = threadParameters.ModuleAbortEvent;
// Set the socket configuration
ServerSocket = new Socket(AddressFamily.InterNetwork,
SocketType.Stream, ProtocolType.Tcp);
receiveEvent = new ReceiveEvent();
ModuleReadyEvent.Set();
ReceiveWorkThread = new Thread(ReceiveWork);
Log.GeneralEvent
.Write("DRInit complete Phase 1 Initialization");
// Wait for core StartWork Signal
ModuleStartWorkEvent = threadParameters.ModuleStartWorkEvent;
ModuleStartWorkEvent.WaitOne();
Log.GeneralEvent
.Write("DRInit complete Phase 2 Initialization");
ReceiveWorkThread.Start();
Log.GeneralEvent.Write("DR module is working...");
// Check ModuleAbortEvent periodically
SpinWait.SpinUntil(() => !ModuleAbortEvent
.WaitOne((int)TimeInterval.VeryVeryShortTime));
Log.GeneralEvent.Write("DR module is aborting.");
}
catch (Exception ex)
{
Log.ErrorEvent.Write(ex.Message);
Log.ErrorEvent.Write("DR module thread failed.");
threadParameters.ModuleInitFailedEvent.Set();
Log.ErrorEvent.Write("DR ModuleInitFailedEvent Set");
}
CleanupExit();
}
private void StartThreadFire()
{
ce = new CreateEvent(1, patrons, R, R);
StartFire += new ReceiveEvent(ce.Start);
StopFire += new ReceiveEvent(ce.Stop);
ce.CoordinatesEvent += new EventResult(FireEvent);
StartFire();
Thread thread = new Thread(ce.StartCalculate);
thread.Start();
StopFire2 += new ReceiveEvent(ce.Stop2);
ce.CalculateEvents += new CalculationResult(Show);
Thread thread2 = new Thread(ce.StartCalculateNumber);
thread2.Start();
}
public ReceiveEvent GetReceivePackage(Header head, byte[] data)
{
if (data.Length >= (head.size + _headerLength))
{
string name = System.Text.Encoding.UTF8.GetString(data, _headerLength, ReceiveEvent.Size).TrimEnd('\0');
int dataSize = (int)head.size - ReceiveEvent.Size;
if (dataSize >= 0)
{
byte[] content = new byte[dataSize];
Buffer.BlockCopy(data, _headerLength + ReceiveEvent.Size, content, 0, dataSize);
ReceiveEvent receiveEvent = new ReceiveEvent(name, content);
return(receiveEvent);
}
}
return(null);
}
/// <summary>
/// Sets up the notifications;
/// Will call Status
/// </summary>
/// <param name="notifyType"></param>
/// <returns>true if the notify was set up. </returns>
public async Task <bool> NotifyReceiveAsync(GattClientCharacteristicConfigurationDescriptorValue notifyType = GattClientCharacteristicConfigurationDescriptorValue.Notify)
{
if (!await EnsureCharacteristicAsync())
{
return(false);
}
var ch = Characteristics[4];
if (ch == null)
{
return(false);
}
GattCommunicationStatus result = GattCommunicationStatus.ProtocolError;
try
{
result = await ch.WriteClientCharacteristicConfigurationDescriptorAsync(notifyType);
if (!NotifyReceive_ValueChanged_Set)
{
// Only set the event callback once
NotifyReceive_ValueChanged_Set = true;
ch.ValueChanged += (sender, args) =>
{
var datameaning = "STRING|ASCII^LONG|Data";
var parseResult = BluetoothDeviceController.BleEditor.ValueParser.Parse(args.CharacteristicValue, datameaning);
Receive = parseResult.ValueList.GetValue("Data").AsString;
ReceiveEvent?.Invoke(parseResult);
};
}
}
catch (Exception e)
{
Status.ReportStatus($"NotifyReceive: {e.Message}", result);
return(false);
}
Status.ReportStatus($"NotifyReceive: set notification", result);
return(true);
}
static void Main(string[] args)
{
Console.Write("Enter Input - send or receive \r\n");
var input = Console.ReadLine();
Console.Write("User Entered : " + input + "\r\n");
if (!String.IsNullOrEmpty(input) && input.ToLower().Equals("send"))
{
Console.Write("Sending \r\n");
SendEvent.SendAsync("Message ").GetAwaiter().GetResult();
}
else
{
Console.Write("Receive \r\n");
ReceiveEvent.ReceiveAsync().GetAwaiter().GetResult();
}
Console.WriteLine("Press ENTER to exit.");
Console.ReadLine();
}
void Update()
{
ReceiveEvent recEvent = base.Receive();
switch (recEvent.type)
{
case NetworkEventType.ConnectEvent:
clientList.Add(recEvent.sender);
break;
case NetworkEventType.DataEvent:
Message message = recEvent.message;
if (message.type == MessageType.Move)
{
Direction moveDirection = (Direction)message.GetData();
_gameManager.Players[recEvent.sender].SetDirection(moveDirection);
}
break;
case NetworkEventType.DisconnectEvent:
break;
}
}
private void RaiseReceiveEvent(string message, IPEndPoint ipep)
{
ReceiveEvent?.Invoke(message, ipep);
}
public async Task <ReceiveEvent> DeleteReceiveEvent(ReceiveEvent ReceiveEventInfo)
{
return(await _repository.UpdateAsync(ReceiveEventInfo));
}
public async Task <ReceiveEvent> CreateReceiveEvent(ReceiveEvent ReceiveEventInfo)
{
ReceiveEventInfo.Id = await _repository.InsertAndGetIdAsync(ReceiveEventInfo);
return(ReceiveEventInfo);
}
public MarshalArgs(ReceiveEvent <T> recveiveEvent, int id, T data)
: this()
{
Event = recveiveEvent;
Data = new DataSet <T>(id, data);
}
protected virtual void OnReceiveEvent(MessageEventArgs e)
{
ReceiveEvent?.Invoke(this, e);
}
