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)); } } } }