private async void OnJoinVoiceMessage (MessageEventArgs<JoinVoiceMessage> e)
{
var person = await GetPersonAsync (e.Connection);
if (person == null) {
await e.Connection.DisconnectAsync();
return;
}
Group group;
lock (SyncRoot) {
if (!Groups.TryGetGroup (e.Message.GroupId, out group) || !group.Participants.Contains (person.Identity))
return;
}
IConnection connection;
lock (SyncRoot) {
connection = GetConnection (group.OwnerId);
}
if (connection == null)
return;
var join = new JoinVoiceMessage {
GroupId = e.Message.GroupId,
Target = e.Message.Target
};
try {
var response = await connection.SendFor<JoinVoiceResponseMessage> (join, responseTimeout: 30000);
await e.Connection.SendResponseAsync (e.Message, response);
} catch (OperationCanceledException) {
}
}
public void OnEntitySnapshotMessage(MessageEventArgs<EntitySnapshotMessage> ev)
{
var entityMessage = ev.Message;
foreach (SnapshotEntity entity in entityMessage.Entities)
SyncEntity (entity.Entity);
}
private void OnConnectMessageReceived(MessageEventArgs<ConnectMessage> ev)
{
var player = new SPlayer();
player.Name = ev.Message.PlayerName;
players.Add (ev.Connection.ConnectionId, player);
RegisterEntity (player);
Console.Write (player.Name + " has connected!");
}
public void OnDestroyEntityMessage(MessageEventArgs<DestroyEntityMessage> ev)
{
NetworkEntity destroyedEntity;
lock (entityLock)
{
destroyedEntity = entities[ev.Message.EntityID];
entities.Remove (ev.Message.EntityID);
}
OnEntityDestroyed (destroyedEntity);
}
public void OnEntitySnapshotMessage(MessageEventArgs<EntitySnapshotMessage> ev)
{
var entityMessage = ev.Message;
foreach (SnapshotEntity entity in entityMessage.Entities)
{
if (!entityMap.ContainsKey (entity.Entity.NetworkID))
CreateEntity (entity.Entity);
else
SyncEntity (entity.Entity);
}
}
private void OnMoveMessageReceived(MessageEventArgs<MoveMessage> ev)
{
SPlayer player;
if (this.players.TryGetValue (ev.Connection.ConnectionId, out player))
{
var dir = ev.Message.Direction;
if (dir != Vector2.Zero)
dir.Normalize ();
player.Direction = dir;
}
}
internal void OnRegisterResultMessage(MessageEventArgs<RegisterResultMessage> e)
{
OnRegisterResult (new ReceivedRegisterResultEventArgs (((RegisterResultMessage)e.Message).Result));
}
internal void OnPermissionsMessage(MessageEventArgs<PermissionsMessage> e)
{
var msg = (PermissionsMessage)e.Message;
if (msg.OwnerId != this.UserId)
return;
this.permissions = msg.Permissions;
OnPermissionsChanged (EventArgs.Empty);
}
internal void OnLoginResultMessage(MessageEventArgs<LoginResultMessage> e)
{
var msg = (LoginResultMessage)e.Message;
if (msg.Result.ResultState == LoginResultState.Success)
this.UserId = msg.Result.UserId;
var args = new ReceivedLoginResultEventArgs (msg.Result);
OnLoginResult (args);
}
internal void OnJoinResultMessage(MessageEventArgs<JoinResultMessage> e)
{
var msg = (JoinResultMessage)e.Message;
if (msg.Result == LoginResultState.Success)
{
this.UserId = msg.UserInfo.UserId;
this.Username = msg.UserInfo.Username;
this.Nickname = msg.UserInfo.Nickname;
this.CurrentChannelId = msg.UserInfo.CurrentChannelId;
}
var args = new ReceivedJoinResultEventArgs(msg.Result);
OnJoinResult (args);
}
private void OnScreenChangedMessage(MessageEventArgs<ScreenChangedMessage> e)
{
bool removed;
lock (this.screens)
{
removed = this.screens.Remove (e.Connection);
this.screens[e.Connection] = e.Message.Screen;
}
if (!removed)
{
var joined = ScreenJoined;
if (joined != null)
joined (this, new ScreenEventArgs (e.Message.Screen));
}
}
private void OnKeyboardEventMessage(MessageEventArgs<KeyboardEventMessage> e)
{
}
private void OnSourceMutedMessage(MessageEventArgs<SourceMutedMessage> e)
{
var msg = (SourceMutedMessage) e.Message;
bool fire = false;
AudioSource s;
lock (this.manager.SyncRoot)
{
s = this.manager[msg.SourceId];
if (s != null && msg.Unmuted == s.IsMuted)
{
this.manager.ToggleMute (s);
fire = true;
}
}
if (fire)
OnAudioSourceMuted (new AudioSourceMutedEventArgs (s, msg.Unmuted));
}
internal void OnUserUpdatedMessage(MessageEventArgs<UserUpdatedMessage> e)
{
var msg = (UserUpdatedMessage) e.Message;
if (!msg.User.Equals (this))
return;
this.Comment = msg.User.Comment;
this.Status = msg.User.Status;
}
internal void OnUserChangedChannelMessage(MessageEventArgs<UserChangedChannelMessage> e)
{
var msg = (UserChangedChannelMessage) e.Message;
var channel = this.context.Channels[msg.ChangeInfo.TargetChannelId];
if (channel == null)
return;
var user = this.context.Users[msg.ChangeInfo.TargetUserId];
if (user == null || !user.Equals (this))
return;
this.CurrentChannelId = msg.ChangeInfo.TargetChannelId;
}
private void OnTimeSyncMessage(MessageEventArgs<TimeSyncMessage> ev)
{
var serverTime = ev.Message.ServerClockTime;
var adjusted = serverTime.AddMilliseconds (ev.Message.Latency);
clockOffset = DateTime.UtcNow.Subtract(adjusted);
Latency = ev.Message.Latency;
}
private void OnServerInformationMessage(MessageEventArgs<ServerInformationMessage> ev)
{
TickRate = new TimeSpan (0, 0, 0, 0, (int)ev.Message.TickRate);
}
private void OnPingMessageReceived(MessageEventArgs<CincoPingMessage> ev)
{
connection.Send (new CincoPongMessage());
}
private void OnEntitySnapshotMessage(MessageEventArgs<EntitySnapshotMessage> ev)
{
var entityMessage = ev.Message;
foreach (SnapshotEntity entity in entityMessage.Entities)
{
if (!this.entities.ContainsKey (entity.Entity.NetworkID))
CreateEntity (entity.Entity);
else
SyncEntity (entity.Entity);
}
OnSnapshotProcessed();
}
private void ConnectionOnMessageReceived(object sender, MessageEventArgs e)
{
this.mqueue.Enqueue (e);
AutoResetEvent wait = this.mwait;
if (wait != null)
wait.Set();
}
internal void OnUserKickedMessage(MessageEventArgs<UserKickedMessage> e)
{
var msg = (UserKickedMessage)e.Message;
if (msg.UserId != UserId)
return;
OnKicked (EventArgs.Empty);
}
internal void ClientAudioSourceStateChangeMessage(MessageEventArgs<ClientAudioSourceStateChangeMessage> e)
{
var msg = e.Message;
IUserInfo speaker;
if (!CanSendFromSource (e.Connection, msg.SourceId, out speaker))
return;
foreach (IConnection connection in context.Users.Connections)
{
if (connection == e.Connection)
continue;
connection.SendAsync (new AudioSourceStateChangeMessage { Starting = msg.Starting, SourceId = msg.SourceId });
}
}
private void OnScreenFrameRequestMessage(MessageEventArgs<ScreenFrameRequestMessage> e)
{
Debug.WriteLine(String.Format("Server: OnScreenFrameRequestMessage() {0}", DateTime.Now.ToLongTimeString()));
if (ScreenFrameRequestReceived != null)
ScreenFrameRequestReceived();
}
internal void OnClientAudioDataMessage(MessageEventArgs<ClientAudioDataMessage> e)
{
var msg = e.Message;
IUserInfo speaker;
if (!CanSendFromSource (e.Connection, msg.SourceId, out speaker))
return;
if (!context.GetPermission (PermissionName.SendAudio, speaker))
{
e.Connection.SendAsync (new PermissionDeniedMessage (GablarskiMessageType.ClientAudioData));
return;
}
if (msg.TargetIds.Length > 1 && !context.GetPermission (PermissionName.SendAudioToMultipleTargets, speaker))
{
e.Connection.SendAsync (new PermissionDeniedMessage (GablarskiMessageType.ClientAudioData));
return;
}
if (msg.TargetType == TargetType.Channel)
{
for (int i = 0; i < msg.TargetIds.Length; ++i)
{
foreach (var user in this.context.Users.Where (u => u.CurrentChannelId == msg.TargetIds[i]))
{
IConnection connection = this.context.Users[user];
if (connection == null || connection == e.Connection)
continue;
connection.SendAsync (new ServerAudioDataMessage {
Data = msg.Data,
Sequence = msg.Sequence,
SourceId = msg.SourceId
});
}
}
}
else if (msg.TargetType == TargetType.User)
{
for (int i = 0; i < msg.TargetIds.Length; ++i)
{
IUserInfo user = this.context.Users[msg.TargetIds[i]];
if (user == null)
continue;
IConnection connection = this.context.Users[user];
if (connection == null || connection == e.Connection)
continue;
connection.SendAsync (new ServerAudioDataMessage {
Data = msg.Data,
Sequence = msg.Sequence,
SourceId = msg.SourceId
});
}
}
}
private void OnConnectMessage(MessageEventArgs<ConnectMessage> e)
{
if (e.Message.Password != ServerPassword)
{
e.Connection.SendResponse (e.Message, new ConnectResultMessage { Result = ConnectResult.FailedPassword });
e.Connection.DisconnectAsync();
}
else
{
e.Connection.SendResponse (e.Message, new ConnectResultMessage
{
Result = ConnectResult.Success,
KeyboardEncryption = KeyboardEventEncryption,
MouseEncryption = MouseEventEncryption
});
}
}
internal void RequestMuteSourceMessage(MessageEventArgs<RequestMuteSourceMessage> e)
{
var request = (RequestMuteMessage)e.Message;
if (!e.Connection.IsConnected)
return;
if (!context.GetPermission (PermissionName.MuteAudioSource, e.Connection))
{
e.Connection.SendAsync (new PermissionDeniedMessage { DeniedMessage = GablarskiMessageType.RequestMuteSource });
return;
}
var source = manager[request.TargetId];
if (source == null)
return;
bool muted = manager.ToggleMute (source);
foreach (IConnection connection in this.context.Connections)
connection.SendAsync (new SourceMutedMessage { SourceId = source.Id, Unmuted = !muted });
}
private void OnMouseEventMessage(MessageEventArgs<MouseEventMessage> e)
{
}
internal void RequestSourceListMessage(MessageEventArgs<RequestSourceListMessage> e)
{
if (!e.Connection.IsConnected)
return;
e.Connection.SendAsync (new SourceListMessage (manager));
}
private void OnScreenFrameMessage(MessageEventArgs<ScreenFrameResponseMessage> e)
{
if (ScreenFrameReceived != null)
ScreenFrameReceived(e.Message.ScreenFrame);
}
internal void RequestSourceMessage(MessageEventArgs<RequestSourceMessage> e)
{
var request = (RequestSourceMessage)e.Message;
SourceResult result = SourceResult.FailedUnknown;
IUserInfo requestingUser = context.Users[e.Connection];
if (requestingUser == null)
return;
if (!context.GetPermission (PermissionName.RequestSource, requestingUser))
result = SourceResult.FailedPermissions;
if (String.IsNullOrEmpty (request.Name)
|| AudioCodecArgs.IsInvalidBitrate (request.AudioSettings.Bitrate)
|| AudioCodecArgs.IsInvalidComplexity (request.AudioSettings.Complexity)
|| AudioCodecArgs.IsInvalidFrequency (request.AudioSettings.SampleRate)
|| AudioCodecArgs.IsInvalidFrameSize (request.AudioSettings.SampleRate, request.AudioSettings.Channels, request.AudioSettings.FrameSize))
{
result = SourceResult.FailedInvalidArguments;
}
AudioSource source = null;
try
{
if (result == SourceResult.FailedUnknown)
{
int bitrate = context.Settings.DefaultAudioBitrate;
if (request.AudioSettings.Bitrate != 0)
bitrate = request.AudioSettings.Bitrate.Trim (context.Settings.MinimumAudioBitrate, context.Settings.MaximumAudioBitrate);
if (manager.IsSourceNameTaken (requestingUser, request.Name))
result = SourceResult.FailedDuplicateSourceName;
else
{
source = manager.Create (request.Name, requestingUser,
new AudioCodecArgs (request.AudioSettings) { Bitrate = bitrate });
result = SourceResult.Succeeded;
}
}
}
catch (OverflowException)
{
result = SourceResult.FailedLimit;
}
finally
{
e.Connection.SendAsync (new SourceResultMessage (request.Name, result, source));
if (result == SourceResult.Succeeded)
{
foreach (IConnection connection in context.Connections)
{
if (connection == e.Connection)
continue;
connection.SendAsync (new SourceResultMessage (request.Name, SourceResult.NewSource, source));
}
}
}
}
