public byte[] Serialize(Message msg) { if(msg == null) { throw new ArgumentNullException("msg"); } MessageEncoder encoder; if(!m_encoders.TryGetValue(msg.Type, out encoder)) { throw new NotImplementedException("Message type not supported: " + msg.Type); } MemoryStream s = new MemoryStream(); BinaryWriter writer = new BinaryWriter(s); // write placeholder for message size writer.Write((int)0); // write message type writer.Write((int)msg.Type); // write message body encoder(writer, msg); writer.Flush(); // write message size writer.Seek(0, SeekOrigin.Begin); writer.Write((int)s.Length); writer.Flush(); return s.ToArray(); }
/// <summary> /// Send a message to the server, changing its sender. It will be handled in the server's thread. /// </summary> public void EnqueueMessage(Message message, object sender) { if(message != null && sender != null) { message.Sender = sender; } m_queue.Enqueue(message); }
protected virtual void OnMessageReceived(Message msg) { if(m_receiveQueue != null) { m_receiveQueue.Enqueue(msg); } EventHandler<MessageEventArgs> handler = MessageReceived; if (handler != null) { handler(this, new MessageEventArgs(msg)); } }
/// <summary> /// Send a message to the client (blocking). /// </summary> public void SendMessage(Message message) { m_socket.Send(m_serializer.Serialize(message)); }
private void SerializePopBalloon(BinaryWriter writer, Message msg) { PopBalloonMessage pbm = (PopBalloonMessage)msg; writer.Write(pbm.BalloonID); }
private void SerializeChangeScreen(BinaryWriter writer, Message msg) { ChangeScreenMessage csm = (ChangeScreenMessage)msg; writer.Write(csm.BalloonID); writer.Write((int)csm.Direction); writer.Write(csm.Y); writer.Write(csm.Velocity.X); writer.Write(csm.Velocity.Y); }
private void SerializeBalloonContentUpdate(BinaryWriter writer, Message msg) { BalloonContentUpdateMessage bcm = (BalloonContentUpdateMessage)msg; writer.Write(bcm.BalloonID); writer.Write((int)bcm.BalloonType); writer.Write(bcm.Label == null ? "" : bcm.Label); writer.Write(bcm.Content == null ? "" : bcm.Content); writer.Write(bcm.Url == null ? "" : bcm.Url); writer.Write(bcm.ImageUrl == null ? "" : bcm.ImageUrl); }
private void LogMessage(Message msg, string direction) { if((m_logFormatter != null) && (msg != null)) { try { string line = m_logFormatter.Format(msg); Trace.WriteLine(String.Format("{0} {1}", direction, line)); } catch(Exception) { } } }
/// <summary> /// Send a message to the server. It will be handled in the server's thread. /// </summary> public void EnqueueMessage(Message message) { m_queue.Enqueue(message); }
private void FormatBalloonContentUpdate(JArray args, Message m) { BalloonContentUpdateMessage bcm = (BalloonContentUpdateMessage)m; args.Add(JValue.FromObject(bcm.BalloonID)); args.Add(JValue.FromObject((int)bcm.BalloonType)); args.Add(JValue.CreateString(bcm.Label)); args.Add(JValue.CreateString(bcm.Content)); args.Add(JValue.CreateString(bcm.Url)); args.Add(JValue.CreateString(bcm.ImageUrl)); }
private void FormatBalloon(JArray args, Message m) { BalloonMessage bm = (BalloonMessage)m; args.Add(JValue.FromObject(bm.BalloonID)); }
public byte[] Serialize(Message msg) { string line = Format(msg); if(Configuration.LogNetworkMessages) { Trace.WriteLine(String.Format(">> {0}", line)); } return m_encoding.GetBytes(line + "\n"); }
/// <summary> /// Handle a message. Must be called from the server's thread. /// </summary> /// <returns> /// True if the message has been handled, false if messages should stop being processed. /// </returns> private bool HandleMessage(Message msg) { if(msg == null) { return false; } switch(msg.Type) { case MessageType.Connected: return HandleScreenConnected((ConnectedMessage)msg); case MessageType.Disconnected: return HandleScreenDisconnected((DisconnectedMessage)msg); case MessageType.ChangeScreen: return HandleChangeScreen((ChangeScreenMessage)msg); case MessageType.NewBalloon: return HandleNewBalloon((NewBalloonMessage)msg); case MessageType.NewPlane: return HandleNewPlane((NewPlaneMessage)msg); case MessageType.PopObject: return HandlePopObject((PopObjectMessage)msg); case MessageType.GetBalloonContent: return HandleGetBalloonContent((GetBalloonContentMessage)msg); case MessageType.GetBalloonState: return HandleGetBalloonState((GetBalloonStateMessage)msg); case MessageType.BalloonContentUpdate: return HandleBalloonContentUpdate((BalloonContentUpdateMessage)msg); case MessageType.BalloonStateUpdate: return HandleBalloonStateUpdate((BalloonStateUpdateMessage)msg); case MessageType.FeedUpdated: return HandleFeedUpdated((FeedUpdatedMessage)msg); default: // warn about unknown messages Trace.WriteLine(String.Format("Warning: message type not handled by server: {0}", msg.Type)); return true; } }
private void SerializeNewPlane(BinaryWriter writer, Message msg) { NewPlaneMessage npm = (NewPlaneMessage)msg; writer.Write(npm.ObjectID); writer.Write((int)npm.PlaneType); writer.Write((int)npm.Direction); writer.Write(npm.Y); writer.Write(npm.Velocity.X); writer.Write(npm.Velocity.Y); writer.Write(npm.Time); }
private void SerializeBalloon(BinaryWriter writer, Message msg) { ObjectMessage bm = (ObjectMessage)msg; writer.Write(bm.ObjectID); }
/// <summary> /// Handles a message. Must be called from the screen's thread. /// </summary> /// <returns> /// True if the message has been handled, false if messages should stop being processed. /// </returns> private bool HandleMessage(Message msg) { if(msg == null) { return false; } switch(msg.Type) { case MessageType.NewBalloon: NewBalloonMessage am = (NewBalloonMessage)msg; m_bubbles[am.BalloonID] = m_server.GetBubble(am.BalloonID); m_bubbles[am.BalloonID].Screen = this; m_connection.SendMessage(am); return true; case MessageType.ChangeScreen: ChangeScreenMessage csm = (ChangeScreenMessage)msg; m_bubbles.Remove(csm.BalloonID); m_server.EnqueueMessage(csm, this); return true; case MessageType.PopBalloon: PopBalloonMessage pbm = (PopBalloonMessage)msg; if(pbm.Sender is ScreenConnection) { m_server.EnqueueMessage(pbm); // Notify server } else { m_connection.SendMessage(pbm); // Notify physical screen } return true; default: // Disconnect when receiving unknown messages return false; } }
/// <summary> /// Handle a message. Must be called from the server's thread. /// </summary> /// <returns> /// True if the message has been handled, false if messages should stop being processed. /// </returns> private bool HandleMessage(Message msg) { if(msg == null) { return false; } switch(msg.Type) { case MessageType.Connected: return HandleScreenConnected((ConnectedMessage)msg); case MessageType.Disconnected: return HandleScreenDisconnected((DisconnectedMessage)msg); case MessageType.ChangeScreen: return HandleChangeScreen((ChangeScreenMessage)msg); case MessageType.NewBalloon: return HandleNewBalloon((NewBalloonMessage)msg); case MessageType.PopBalloon: return HandlePopBalloon((PopBalloonMessage)msg); default: // Disconnect when receiving unknown messages return false; } }
private void FormatBalloonStateUpdate(JArray args, Message m) { BalloonStateUpdateMessage bdm = (BalloonStateUpdateMessage)m; args.Add(JValue.FromObject(bdm.BalloonID)); args.Add(JValue.FromObject((int)bdm.OverlayType)); args.Add(JValue.FromObject(bdm.BackgroundColor.Red)); args.Add(JValue.FromObject(bdm.BackgroundColor.Green)); args.Add(JValue.FromObject(bdm.BackgroundColor.Blue)); args.Add(JValue.FromObject(bdm.BackgroundColor.Alpha)); args.Add(JValue.FromObject(bdm.Votes)); }
private void FormatChangeScreen(JArray args, Message m) { ChangeScreenMessage csm = (ChangeScreenMessage)m; args.Add(JValue.FromObject(csm.BalloonID)); args.Add(JValue.CreateString(Balloon.FormatDirection(csm.Direction))); args.Add(JValue.FromObject(csm.Y)); args.Add(JValue.FromObject(csm.Velocity.X)); args.Add(JValue.FromObject(csm.Velocity.Y)); }
private void FormatNewBalloon(JArray args, Message m) { NewBalloonMessage nbm = (NewBalloonMessage)m; args.Add(JValue.FromObject(nbm.BalloonID)); args.Add(JValue.CreateString(Balloon.FormatDirection(nbm.Direction))); args.Add(JValue.FromObject(nbm.Y)); args.Add(JValue.FromObject(nbm.Velocity.X)); args.Add(JValue.FromObject(nbm.Velocity.Y)); }
private void SerializeBalloon(BinaryWriter writer, Message msg) { BalloonMessage bm = (BalloonMessage)msg; writer.Write(bm.BalloonID); }
public string Format(Message msg) { MessageFormatter formatter; if(!m_formatters.TryGetValue(msg.TypeTag, out formatter)) { throw new Exception("Unsupported type: " + msg.TypeTag); } JArray args = new JArray(); args.Add(JValue.CreateString(msg.TypeTag)); formatter(args, msg); return args.ToString(Formatting.None); }
private void SerializeBalloonStateUpdate(BinaryWriter writer, Message msg) { BalloonStateUpdateMessage bdm = (BalloonStateUpdateMessage)msg; writer.Write(bdm.BalloonID); writer.Write((int)bdm.OverlayType); writer.Write(bdm.BackgroundColor.Red); writer.Write(bdm.BackgroundColor.Green); writer.Write(bdm.BackgroundColor.Blue); writer.Write(bdm.BackgroundColor.Alpha); writer.Write(bdm.Votes); }
public MessageEventArgs(Message message) { m_message = message; }
private void SerializeNewBalloon(BinaryWriter writer, Message msg) { NewBalloonMessage nbm = (NewBalloonMessage)msg; writer.Write(nbm.BalloonID); writer.Write((int)nbm.Direction); writer.Write(nbm.Y); writer.Write(nbm.Velocity.X); writer.Write(nbm.Velocity.Y); }
/// <summary> /// Handles a message. Must be called from the screen reader's thread. /// </summary> /// <returns> /// True if the message has been handled, false if messages should stop being processed. /// </returns> private bool HandleMessage(Message msg) { if(msg == null) { return false; } else if(msg.Type == MessageType.RefreshFeed) { DoRefresh(); } else { // warn about unknown messages Trace.WriteLine(String.Format("Warning: message type not handled by feed: {0}", msg.Type)); } return true; }