private void FrameMessageActionHandler(FrameMessage message)
{
//if (message.Type == FrameMessage.MessageType.CurrentFrameByExportedDataResult)
//{
// if (this.Export.Id == message.ExportResultId) { this.SelectFrame(message.FrameId, message.BringToFront); }
//}
}
public void Add(Session session, FrameMessage frameMessage)
{
this.Queue.Enqueue(new SessionFrameMessage()
{
Session = session, FrameMessage = frameMessage
});
}
public async Task InitializeAsync()
{
// Retrieve v8 version
IResponseMessage response = await _client.SendMessage("version").ConfigureAwait(false);
var versionMessage = response as VersionMessage;
if (versionMessage == null || !versionMessage.IsSuccessful)
{
string message = string.Format("Invalid version response: {0}", response);
throw new InvalidOperationException(message);
}
IsRunning = versionMessage.IsRunning;
_v8EngineVersion = versionMessage.Version;
response = await _client.SendMessage("frame", new { inlineRefs = true }).ConfigureAwait(false);
var frameMessage = response as FrameMessage;
if (frameMessage == null || !frameMessage.IsSuccessful)
{
string message = string.Format("Invalid listbreakpoints response: {0}", response);
throw new InvalidOperationException(message);
}
foreach (NodeScript script in frameMessage.Scripts)
{
AddModuleIfNotExist(script.Id, script.Filename);
}
_initialFrame = frameMessage;
}
public static Frame Deserialize(FrameMessage frameMessage, TypeRegistry typeRegistry, Frame previousFrame)
{
var frame = new Frame(
(int)frameMessage.ListId,
frameMessage.ObjectsDestroyed.ToList());
using (var stream = new MemoryStream())
{
frameMessage.ObjectUpdates.WriteTo(stream);
stream.Position = 0;
using (var codedStream = new CodedInputStream(stream))
{
var updateCount = codedStream.ReadInt32();
for (var i = 0; i < updateCount; ++i)
{
var update = codedStream.ReadBytes();
frame.DeserializeUpdate(update, typeRegistry, previousFrame);
}
return(frame);
}
}
}
private void FrameActionHandler(FrameMessage message)
{
if (message.Type == FrameMessage.MessageType.CurrentFrameChanged)
{
if (this._context != null)
{
this._context.PropertyChanged -= this.context_PropertyChanged;
}
this._context = message.Frame as FrameVm;
if (this._context != null)
{
this._context.PropertyChanged += this.context_PropertyChanged;
}
this.DataContext = this._context;
this.Visibility = (this._context != null? Visibility.Visible : Visibility.Hidden);
//this.ControlVisible = (this._context != null? Visibility.Visible : Visibility.Collapsed);
this.GenericFiledsView.UpdateExpandState();
this.GenericFiledsView.FrameVm = (FrameVm)message.Frame;
this.radHexDetailsDataGrid.DataContext = this._context;
this.UpdateSelection();
}
}
private void TransportOnOnMessage(IAvaloniaRemoteTransportConnection conn, object msg)
{
if (msg is FrameMessage frame)
{
lock (_lock)
_lastFrame = frame;
}
}
async void setText()
{
await CrossMedia.Current.Initialize();
Color hexColor = (Color)Application.Current.Resources["MainColor"];
FrameMessage.SetAppThemeColor(Frame.BorderColorProperty, hexColor, Color.White);
}
public void OnRecvFrame(FrameMessage msg)
{
Console.WriteLine("Client Receive Frame: " + msg);
string err = m_dealer.SendFrame(msg);
if (err != "")
{
Console.WriteLine("Client Send Frame Error " + err);
}
}
public static void SendFrameMessage(object frame, MessageType type, bool bringToFront)
{
var newFrameMessage = new FrameMessage
{
Frame = frame,
Type = type,
BringToFront = bringToFront
};
AsyncSendMessage(newFrameMessage);
}
private void OnMessage(object msg)
{
if (msg is FrameMessage frame)
{
_connection.Send(new FrameReceivedMessage
{
SequenceId = frame.SequenceId
});
_lastFrame = frame;
InvalidateVisual();
}
}
public static void SendFrameMessage(string exportResultId, uint frameId, MessageType type, bool bringToFront)
{
var newFrameMessage = new FrameMessage
{
ExportResultId = exportResultId,
FrameId = frameId,
Type = type,
BringToFront = bringToFront
};
AsyncSendMessage(newFrameMessage);
}
public static void SendFrameMessage(string captureId, uint conversationIndex, uint frameId, MessageType type, bool bringToFront)
{
var newFrameMessage = new FrameMessage
{
CaptureId = captureId,
ConversationIndex = conversationIndex,
FrameId = frameId,
Type = type,
BringToFront = bringToFront
};
AsyncSendMessage(newFrameMessage);
}
public Task Send(object data)
{
if (data is FrameMessage frame)
{
_lastFrameMessage = frame;
_wakeup.Set();
return(Task.CompletedTask);
}
if (data is RequestViewportResizeMessage req)
{
return(Task.CompletedTask);
}
return(_signalTransport.Send(data));
}
public static byte[] EncodePng(this FrameMessage frame)
{
var ms = new MemoryStream();
var pngw = new PngWriter(ms, new ImageInfo(frame.Width, frame.Height, 8, true));
var row = new byte[4 * frame.Width];
for (int y = 0; y < frame.Height; y++)
{
var off = y * frame.Stride;
Buffer.BlockCopy(frame.Data, off, row, 0, frame.Width * 4);
pngw.WriteRowByte(row, y);
}
pngw.End();
return(ms.ToArray());
}
public void Dispatch(Session session, ushort opcode, object message)
{
// 如果是帧同步消息,交给ClientFrameComponent处理
FrameMessage frameMessage = message as FrameMessage;
if (frameMessage != null)
{
Game.Scene.GetComponent <ClientFrameComponent>().Add(session, frameMessage);
return;
}
// 普通消息或者是Rpc请求消息
MessageInfo messageInfo = new MessageInfo(opcode, message);
Game.Scene.GetComponent <MessageDispatcherComponent>().Handle(session, messageInfo);
}
async void SocketWorker()
{
try
{
SimpleWebSocket socket = null;
while (true)
{
if (_disposed)
{
socket?.Dispose();
return;
}
FrameMessage sendNow = null;
lock (_lock)
{
if (_pendingSocket != null)
{
socket?.Dispose();
socket = _pendingSocket;
_pendingSocket = null;
_lastSentFrameMessage = null;
}
if (_lastFrameMessage != _lastSentFrameMessage)
{
_lastSentFrameMessage = sendNow = _lastFrameMessage;
}
}
if (sendNow != null && socket != null)
{
await socket.SendMessage(
$"frame:{sendNow.SequenceId}:{sendNow.Width}:{sendNow.Height}:{sendNow.Stride}:{sendNow.DpiX}:{sendNow.DpiY}");
await socket.SendMessage(false, sendNow.Data);
}
_wakeup.WaitOne(TimeSpan.FromSeconds(1));
}
}
catch (Exception e)
{
Console.Error.WriteLine(e.ToString());
}
}
async void setText()
{
await CrossMedia.Current.Initialize();
try
{
LabelNumber.Text = "№ " + _requestInfo.RequestNumber;
}
catch (Exception e)
{
Console.WriteLine(e);
}
Color hexColor = (Color)Application.Current.Resources["MainColor"];
FrameKeys.SetAppThemeColor(Frame.BorderColorProperty, hexColor, Color.FromHex("#B5B5B5"));
FrameMessage.SetAppThemeColor(Frame.BorderColorProperty, hexColor, Color.White);
}
public FrameMessage Run(uint[] players, uint frame)
{
FrameMessage message = new FrameMessage()
{
frame = frame
};
foreach (var item in players)
{
var input = world.GetComponent <InputComponenet>(item);
if (input != null)
{
message.paylods.Add(input.data);
input.data = null;
}
}
return(message);
}
public FrameMessage Serialize(NetworkObjectList objectList, Frame previousFrame)
{
var updateList = new List <MemoryStream>();
foreach (var update in _updates)
{
var data = update.Serialize(objectList.InternalGetNetworkObjectById(update.ObjectHandle.Id), previousFrame?.FindUpdateByObjectId(update.ObjectHandle.Id));
//TODO: figure out if there's a better way to handle change detection during serialization
//if (data.ContainsChanges)
{
data.Memory.Position = 0;
updateList.Add(data.Memory);
}
}
var stream = new MemoryStream();
using (var codedStream = new CodedOutputStream(stream, true))
{
codedStream.WriteInt32(updateList.Count);
foreach (var update in updateList)
{
codedStream.WriteBytes(ByteString.FromStream(update));
update.Dispose();
}
}
stream.Position = 0;
var frameMessage = new FrameMessage
{
ListId = (uint)ListId,
ObjectUpdates = ByteString.FromStream(stream)
};
stream.Dispose();
frameMessage.ObjectsDestroyed.AddRange(_destroyedObjects);
return(frameMessage);
}
public FrameMessage ToMessage()
{
const int HEADER_SIZE = 17;
int messageSize = 0;
foreach (var packet in Packets)
{
messageSize += packet.Length - HEADER_SIZE;
}
byte[] message = new byte[messageSize];
for (int i = 0; i < Packets.Length; ++i)
{
int cursor = (1500 - HEADER_SIZE) * i;
Array.Copy(Packets[i], HEADER_SIZE, message, cursor, Packets[i].Length - HEADER_SIZE);
}
stopWatch.Stop();
return(FrameMessage.Create(FrameId, message, stopWatch.Elapsed));
}
private void UpdateFrame()
{
if (this.Queue.Count == 0)
{
return;
}
FrameMessage frameMessage = this.Queue.Dequeue();
this.Frame = frameMessage.Frame;
for (int i = 0; i < frameMessage.Messages.Count; ++i)
{
AFrameMessage message = frameMessage.Messages[i];
ushort opcode = Game.Scene.GetComponent <OpcodeTypeComponent>().GetOpcode(message.GetType());
Game.Scene.GetComponent <MessageDispatherComponent>().Handle(new MessageInfo()
{
Opcode = opcode, Message = message
});
}
}
public void Add(FrameMessage frameMessage)
{
this.Queue.Enqueue(frameMessage);
}
