private async Task DiscordShardedClientOnUserLeft(SocketGuildUser arg)
{
if (UserLeft != null)
{
await UserLeft.Invoke(this, arg).ConfigureAwait(false);
}
}
void ReceivePart(IrcMessage message)
{
string user = message.ExtractUser();
users.Remove(user);
UserLeft?.Invoke(this, user);
}
public async Task OnUserLeft(SocketGuildUser user)
{
var method = new UserLeft(Client, Config);
await method.ProcessAsync(user).ConfigureAwait(false);
IncrementEventHandle("UserLeft");
}
private void Bt_LogIn_Click(object sender, EventArgs e)
{
if (!string.IsNullOrEmpty(txtUserName.Text.Trim()))
{
try
{
NewJoin += new UserJoined(ChatClient_NewJoin);
MessageSent += new UserSendMessage(ChatClient_MessageSent);
RemoveUser += new UserLeft(ChatClient_RemoveUser);
channel = null;
this.userName = txtUserName.Text.Trim();
InstanceContext context = new InstanceContext(new MainWindow(txtUserName.Text.Trim()));
factory = new DuplexChannelFactory <IChatChannel>(context, "ChatEndPoint");
channel = factory.CreateChannel();
IOnlineStatus status = channel.GetProperty <IOnlineStatus>();
status.Offline += new EventHandler(Offline);
status.Online += new EventHandler(Online);
channel.Open();
channel.Join(this.userName);
rtbMessages.AppendText("*****************************WEL-COME to Chat Application*****************************\r\n");
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString());
}
}
}
private void btnJoin_Click(object sender, EventArgs e)
{
if (txtUserName.Text.Trim() != "")
{
try
{
NewJoin += new UserJoined(Form1_NewJoin);
MessageSent += new UserSendMessage(Form1_MessageSent);
RemoveUser += new UserLeft(Form1_RemoveUser);
channel = null;
this.userName = txtUserName.Text.Trim();
InstanceContext context = new InstanceContext(new Form1(txtUserName.Text.Trim()));
factory = new DuplexChannelFactory <IChatChannel>(context, "ChatEndPoint");
channel = factory.CreateChannel();
channel.Open();
channel.Join(this.userName);
gbChatWindow.Enabled = true;
gbUserInfo.Enabled = false;
this.AcceptButton = btnSend;
txtChatMessages.AppendText("******Welcome to Turn Shop Automobile Chat Application****\r\n");
txtSendMessage.Select();
txtSendMessage.Focus();
this.Text = "Chat Clent-" + txtUserName.Text;
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString(), "Error");
}
}
}
/// <summary>
/// Constructs a new <see cref="BaseSocketClientAbstraction"/> around an existing <see cref="WebSocket.BaseSocketClient"/>.
/// </summary>
/// <param name="baseSocketClient">The value to use for <see cref="WebSocket.BaseSocketClient"/>.</param>
/// <exception cref="ArgumentNullException">Throws for <paramref name="baseSocketClient"/>.</exception>
protected BaseSocketClientAbstraction(BaseSocketClient baseSocketClient)
: base(baseSocketClient)
{
baseSocketClient.ChannelCreated += x => ChannelCreated?.InvokeAsync(x.Abstract()) ?? Task.CompletedTask;
baseSocketClient.ChannelDestroyed += x => ChannelDestroyed?.InvokeAsync(x.Abstract()) ?? Task.CompletedTask;
baseSocketClient.ChannelUpdated += (x, y) => ChannelUpdated?.InvokeAsync(x.Abstract(), y.Abstract()) ?? Task.CompletedTask;
baseSocketClient.CurrentUserUpdated += (x, y) => CurrentUserUpdated?.InvokeAsync(x.Abstract(), y.Abstract()) ?? Task.CompletedTask;
baseSocketClient.GuildAvailable += x => GuildAvailable?.InvokeAsync(x.Abstract()) ?? Task.CompletedTask;
baseSocketClient.GuildMembersDownloaded += x => GuildMembersDownloaded?.InvokeAsync(x.Abstract()) ?? Task.CompletedTask;
baseSocketClient.GuildMemberUpdated += (x, y) => GuildMemberUpdated?.InvokeAsync(x.Abstract(), y.Abstract()) ?? Task.CompletedTask;
baseSocketClient.GuildUnavailable += x => GuildUnavailable?.InvokeAsync(x.Abstract()) ?? Task.CompletedTask;
baseSocketClient.GuildUpdated += (x, y) => GuildUpdated?.InvokeAsync(x.Abstract(), y.Abstract()) ?? Task.CompletedTask;
baseSocketClient.JoinedGuild += x => JoinedGuild?.InvokeAsync(x.Abstract()) ?? Task.CompletedTask;
baseSocketClient.LeftGuild += x => LeftGuild?.InvokeAsync(x.Abstract()) ?? Task.CompletedTask;
baseSocketClient.MessageReceived += x => MessageReceived?.InvokeAsync(x.Abstract()) ?? Task.CompletedTask;
baseSocketClient.MessageUpdated += (x, y, z) => MessageUpdated?.InvokeAsync(x.Abstract(), y.Abstract(), z.Abstract()) ?? Task.CompletedTask;
baseSocketClient.MessageDeleted += (x, y) => MessageDeleted?.InvokeAsync(x.Abstract(), y.Abstract()) ?? Task.CompletedTask;
baseSocketClient.ReactionAdded += (x, y, z) => ReactionAdded?.InvokeAsync(x.Abstract(), y.Abstract(), z.Abstract()) ?? Task.CompletedTask;
baseSocketClient.ReactionRemoved += (x, y, z) => ReactionRemoved?.InvokeAsync(x.Abstract(), y.Abstract(), z.Abstract()) ?? Task.CompletedTask;
baseSocketClient.ReactionsCleared += (x, y) => ReactionsCleared?.InvokeAsync(x.Abstract(), y.Abstract()) ?? Task.CompletedTask;
baseSocketClient.RecipientAdded += x => RecipientAdded?.InvokeAsync(x.Abstract()) ?? Task.CompletedTask;
baseSocketClient.RecipientRemoved += x => RecipientRemoved?.InvokeAsync(x.Abstract()) ?? Task.CompletedTask;
baseSocketClient.RoleCreated += x => RoleCreated?.InvokeAsync(x.Abstract()) ?? Task.CompletedTask;
baseSocketClient.RoleDeleted += x => RoleDeleted?.InvokeAsync(x.Abstract()) ?? Task.CompletedTask;
baseSocketClient.RoleUpdated += (x, y) => RoleUpdated?.InvokeAsync(x.Abstract(), y.Abstract()) ?? Task.CompletedTask;
baseSocketClient.UserBanned += (x, y) => UserBanned?.InvokeAsync(x.Abstract(), y.Abstract()) ?? Task.CompletedTask;
baseSocketClient.UserIsTyping += (x, y) => UserIsTyping?.InvokeAsync(x.Abstract(), y.Abstract()) ?? Task.CompletedTask;
baseSocketClient.UserJoined += x => UserJoined?.InvokeAsync(x.Abstract()) ?? Task.CompletedTask;
baseSocketClient.UserLeft += x => UserLeft?.InvokeAsync(x.Abstract()) ?? Task.CompletedTask;
baseSocketClient.UserUnbanned += (x, y) => UserUnbanned?.InvokeAsync(x.Abstract(), y.Abstract()) ?? Task.CompletedTask;
baseSocketClient.UserUpdated += (x, y) => UserUpdated?.InvokeAsync(x.Abstract(), y.Abstract()) ?? Task.CompletedTask;
baseSocketClient.UserVoiceStateUpdated += (x, y, z) => UserVoiceStateUpdated?.InvokeAsync(x.Abstract(), y.Abstract(), z.Abstract()) ?? Task.CompletedTask;
baseSocketClient.VoiceServerUpdated += x => VoiceServerUpdated?.InvokeAsync(x.Abstract()) ?? Task.CompletedTask;
}
void Given(UserLeft e)
{
if (Users.Any(user => user == e.UserId))
{
Users.Remove(e.UserId);
}
}
public void LoadEvents()
{
Client.UserJoined += async(u) =>
{
Task.Run(() => UserJoin?.Invoke(new RuntimeUser(u)));
};
Client.UserLeft += async(u) =>
{
Task.Run(() => UserLeft?.Invoke(new RuntimeUser(u)));
};
Client.UserUpdated += async(u, unew) =>
{
RuntimeUser userOld = new RuntimeUser(u);
RuntimeUser userNew = new RuntimeUser(unew);
Task.Run(() => UserUpdated?.Invoke(userOld, userNew));
};
Client.MessageReceived += async(m) =>
{
RuntimeMessage newMessage = new RuntimeMessage(m);
if (MessageReceived != null)
{
await MessageReceived.Invoke(newMessage);
}
};
Client.JoinedGuild += async(g) =>
{
Task.Run(async() =>
{
RuntimeGuild guild = new RuntimeGuild(g);
await GuildJoin?.Invoke(guild);
});
};
Client.LeftGuild += async(g) =>
{
RuntimeGuild guild = new RuntimeGuild(g);
await GuildLeave?.Invoke(guild);
};
foreach (var shard in Client.Shards)
{
shard.Disconnected += async(ex) =>
{
await OnShardDisconnect?.Invoke(ex, shard.ShardId);
};
shard.Connected += async() =>
{
if (OnShardConnect != null)
{
await OnShardConnect.Invoke(shard.ShardId);
}
};
}
}
/// <summary>
/// Clears the current session, removing any users being tracked.
/// This should be called whenever the current session changes, to reset this class
/// and handle a new current session.
/// </summary>
private void ClearCurrentSession()
{
for (int i = 0; i < CurrentUsers.Count; i++)
{
UserLeft.RaiseEvent(CurrentUsers[i]);
}
CurrentUsers.Clear();
}
private void OnUserLeft(Session session, User user)
{
UserLeft.RaiseEvent(session, user);
if (IsLocalUser(user))
{
CurrentUserLeft.RaiseEvent(session);
}
}
public void RemoveUser(string sid)
{
var user = joinedUsers.FirstOrDefault(x => x.Id == sid);
if (user != null)
{
joinedUsers.Remove(user);
UserLeft?.Invoke(user);
}
}
private void _TwitchClient_OnUserLeft(object sender, OnUserLeftArgs e)
{
UserLeft?.Invoke(this, new ChatUserInfoEventArgs
{
ChannelId = 0,
ServiceName = "Twitch",
UserId = 0,
UserName = e.Username
});
}
public void RemoveUser(string sid)
{
var findedUser = _joinedUsersList.SingleOrDefault(item => item.Id == sid);
if (findedUser != null)
{
_joinedUsersList.Remove(findedUser);
UserLeft?.Invoke(findedUser);
}
}
public void OnUserLeft(string userName)
{
if (users.Remove(userName))
{
if (notifyOnUserListChange)
{
AddMessage(new ChatMessage(userName + " has left from " + UIName + "."));
}
UserLeft?.Invoke(this, new UserNameEventArgs(userName));
}
}
public async Task OnUserLeft(SocketGuildUser user)
{
if (!CanProcessEvent("UserLeft"))
{
return;
}
var method = new UserLeft(Client, Config);
await method.ProcessAsync(user).ConfigureAwait(false);
EventPostProcess("UserLeft");
}
private void OnUserLeftSession(Session session, User user)
{
if (!session.IsJoined())
{
return;
}
if (CurrentUsers.RemoveAll(x => x.GetID() == user.GetID()) > 0)
{
//Debug.LogFormat("User {0} left current session.", user.GetName());
UserLeft.RaiseEvent(user);
}
}
public static UserLeft AddUserLeftEventHandler <T>(
this RoomWatcher <T> rw,
Action <int> callback)
where T : IWebSocket
{
callback.ThrowIfNull(nameof(callback));
var eventProcessor = new UserLeft();
eventProcessor.OnEvent += callback;
rw.EventRouter.AddProcessor(eventProcessor);
return(eventProcessor);
}
void OnUserLeft(ChatChannel twitchchannel, string user)
{
try
{
UserLeft?.Invoke(this, new UserInformation
{
Service = Service,
Username = user
});
}
catch (Exception e)
{
Logger.Error(this, "Error triggering UserLeft event", e);
}
}
public void OnUserLeft(string userName)
{
int index = users.FindIndex(u => u.IRCUser.Name == userName);
if (index == -1)
{
return;
}
if (notifyOnUserListChange)
{
AddMessage(new ChatMessage(userName + " has left from " + UIName + "."));
}
users.RemoveAt(index);
UserLeft?.Invoke(this, new UserNameIndexEventArgs(index, userName));
}
private void OnUserLeftSession(Session session, User user)
{
if (!session.IsJoined())
{
return;
}
for (int i = CurrentUsers.Count - 1; i >= 0; i--)
{
if (CurrentUsers[i].GetID() == user.GetID())
{
CurrentUsers.RemoveAt(i);
UserLeft.RaiseEvent(user);
// Debug.LogFormat("User {0} left current session.", user.GetName());
}
}
}
private void btnLogin_Click(object sender, EventArgs e)
{
if (!string.IsNullOrEmpty(txtUserName.Text.Trim()))
{
try
{
// Register an event
NewJoin += new UserJoined(ChatClient_NewJoin);
MessageSent += new UserSendMessage
(ChatClient_MessageSent);
RemoveUser += new UserLeft(ChatClient_RemoveUser);
channel = null;
this.userName = txtUserName.Text.Trim();
// Create InstanceContext to handle call back interface
// Pass the object of the CallbackContract implementor
InstanceContext context = new InstanceContext(
new ChatClient(txtUserName.Text.Trim()));
// We create a participant with the given end point
// The communication is managed with CHAT MESH and
// each client creates a duplex
// end point with the mesh. Mesh is nothing but the
// named collection of nodes.
factory =
new DuplexChannelFactory <IChatChannel>(context, "ChatEndPoint");
channel = factory.CreateChannel();
channel.Open();
channel.Join(this.userName);
grpMessageWindow.Enabled = true;
grpUserList.Enabled = true;
grpUserCredentials.Enabled = false;
this.AcceptButton = btnSend;
rtbMessages.AppendText
("****WEL-COME to Chat Application*****\r\n");
txtSendMessage.Select();
txtSendMessage.Focus();
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString());
}
}
}
public static UserLeft AddUserLeftEventHandler <T>(
this RoomWatcher <T> rw,
Action <Chat.User> callback)
where T : IWebSocket
{
callback.ThrowIfNull(nameof(callback));
var eventProcessor = new UserLeft();
eventProcessor.OnEvent += id =>
{
var user = new Chat.User(rw.Host, id, rw.Auth);
callback(user);
};
rw.EventRouter.AddProcessor(eventProcessor);
return(eventProcessor);
}
public void LoadEvents()
{
Client.UserJoined += async(u) =>
{
await MeruUtils.TryAsync(async() =>
{
Task.Run(() => UserJoin?.Invoke(new RuntimeUser(u)));
});
};
Client.UserLeft += async(u) =>
{
await MeruUtils.TryAsync(async() =>
{
Task.Run(() => UserLeft?.Invoke(new RuntimeUser(u)));
});
};
Client.UserUpdated += async(u, unew) =>
{
RuntimeUser userOld = new RuntimeUser(u);
RuntimeUser userNew = new RuntimeUser(unew);
Task.Run(() => UserUpdated?.Invoke(userOld, userNew));
};
Client.MessageReceived += async(m) =>
{
Task.Run(async() =>
{
await MeruUtils.TryAsync(async() =>
{
RuntimeMessage newMessage = new RuntimeMessage(m);
await MessageReceived?.Invoke(newMessage);
});
});
};
}
private void btnLogin_Click(object sender, EventArgs e)
{
if (!string.IsNullOrEmpty(txtUserName.Text.Trim()))
{
try
{
NewJoin += new UserJoined(ChatClient_NewJoin);
MessageSent += new UserSendMessage(ChatClient_MessageSent);
RemoveUser += new UserLeft(ChatClient_RemoveUser);
channel = null;
this.userName = txtUserName.Text.Trim();
InstanceContext context = new InstanceContext(
new ChatClient(txtUserName.Text.Trim()));
factory =
new DuplexChannelFactory<IChatChannel>(context, "ChatEndPoint");
channel = factory.CreateChannel();
IOnlineStatus status = channel.GetProperty<IOnlineStatus>();
status.Offline += new EventHandler(Offline);
status.Online += new EventHandler(Online);
channel.Open();
channel.Join(this.userName);
grpMessageWindow.Enabled = true;
grpUserList.Enabled = true;
grpUserCredentials.Enabled = false;
this.AcceptButton = btnSend;
rtbMessages.AppendText("*****************************WEL-COME to Chat Application*****************************\r\n");
txtSendMessage.Select();
txtSendMessage.Focus();
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString());
}
}
}
public Task OnMessageReceived(string clientId, ReadOnlySpan <byte> data)
{
var messageType = (EventType)BitConverter.ToInt32(data.Slice(Constants.EventTypeOffset));
_logger.LogDebug("Client[{clientId}] send {messageType} message", clientId, messageType);
switch (messageType)
{
case EventType.UserJoined:
var joinMessage = _serializer.Deserialize <UserJoined>(data);
return(PublishMessage(clientId, joinMessage));
case EventType.UserLeft:
var leftMessage = new UserLeft(LeftReason.Voluntarily);
return(PublishMessage(clientId, leftMessage));
case EventType.UserSendMessage:
var textMessage = _serializer.Deserialize <TextMessage>(data);
return(PublishMessage(clientId, textMessage));
}
_logger.LogWarning("Unknown EventType: {messageType}", messageType);
return(Task.CompletedTask);
}
private void HandleUserData(string sender, string[] content, string data)
{
var username = sender.Substring(0, sender.IndexOf('!'));
if (!_cachedUsers.TryGetValue(username, out var user))
{
user = new User(this)
{
Username = username
};
_cachedUsers.TryAdd(username, user);
}
switch (content[0])
{
case "JOIN":
{
if (!_cachedChannels.TryGetValue(content[1], out var channel))
{
channel = new Channel(this)
{
Name = content[1]
};
_cachedChannels.TryAdd(content[1], channel);
Send($"MODE {channel.Name}");
Send($"NAMES {channel.Name}");
Send($"MODE {channel.Name} +b");
}
var channelUser = new ChannelUser(this, user, channel);
if (channel._users.All(x => x != user))
{
channel._users.Add(channelUser);
}
if (user._channels.All(x => x != channel))
{
user._channels.Add(channel);
}
UserJoined?.Invoke(new UserJoinedEventArgs
{
Client = this,
CurrentUser = CurrentUser,
Channel = channel,
User = channelUser
});
return;
}
case "PART":
{
var channelName = content[1];
if (channelName.StartsWith(':'))
{
channelName = channelName.Substring(1);
}
if (!_cachedChannels.TryGetValue(channelName, out var channel))
{
channel = new Channel(this)
{
Name = channelName
};
_cachedChannels.TryAdd(channelName, channel);
}
if (user._channels.Any(x => x == channel))
{
user._channels.Remove(channel);
}
if (channel._users.Any(x => x == user))
{
channel._users.RemoveAll(x => x == user);
}
UserLeft?.Invoke(new UserLeftEventArgs
{
Client = this,
CurrentUser = CurrentUser,
Channel = channel,
User = user,
Reason = content.Length > 2 ? data.Substring(data.IndexOf(':') + 1) : ""
});
return;
}
case "QUIT":
{
_cachedUsers.TryRemove(user.Username, out _);
foreach (var channel in _cachedChannels.Values)
{
channel._users.RemoveAll(x => x == user);
}
var reason = "";
var idof = data.IndexOf(':');
if (idof != -1)
{
reason = data.Substring(idof + 1);
}
UserQuit?.Invoke(new UserQuitEventArgs
{
Client = this,
CurrentUser = CurrentUser,
User = user,
Reason = reason
});
return;
}
case "NICK":
{
_cachedUsers.TryRemove(user.Username, out var oldUser);
user.Username = content[1].Substring(1);
_cachedUsers.TryRemove(user.Username, out _);
_cachedUsers.TryAdd(user.Username, user);
NicknameChanged?.Invoke(new NicknameChangedEventArgs
{
Client = this,
CurrentUser = CurrentUser,
User = user,
OldUsername = oldUser.Username,
NewUsername = user.Username
});
return;
}
case "PRIVMSG":
{
var cnt = data.Substring(1);
var message = cnt.Substring(cnt.IndexOf(':') + 1);
if (!user._channelMessages.TryGetValue(content[1], out var list))
{
list = new List <string> {
message
};
user._channelMessages.TryAdd(content[1], list);
}
else
{
list.Add(message);
}
if (content[1][0] == '#')
{
if (!_cachedChannels.TryGetValue(content[1], out var channel))
{
channel = new Channel(this)
{
Name = content[1]
};
_cachedChannels.TryAdd(content[1], channel);
}
channel._messages.Add((user, message));
MessageReceived?.Invoke(new MessageReceivedEventArgs
{
Client = this,
Channel = channel,
CurrentUser = CurrentUser,
Message = message,
User = channel.Users.FirstOrDefault(x => x == user) ?? user
});
return;
}
MessageReceived?.Invoke(new MessageReceivedEventArgs
{
Client = this,
Channel = null,
CurrentUser = CurrentUser,
Message = message,
User = user
});
return;
}
case "NOTICE":
{
var message = data.Substring(data.IndexOf(':') + 1);
if (!user._channelMessages.TryGetValue(content[1], out var list))
{
list = new List <string> {
message
};
user._channelMessages.TryAdd(content[1], list);
}
else
{
list.Add(message);
}
NoticeReceived?.Invoke(new NoticeReceivedEventArgs
{
Client = this,
CurrentUser = CurrentUser,
Message = message,
User = user
});
return;
}
case "MODE":
{
if (!_cachedChannels.TryGetValue(content[1], out var channel))
{
channel = new Channel(this)
{
Name = content[1]
};
_cachedChannels.TryAdd(content[1], channel);
}
var iofplus = content[2].IndexOf('+');
var iofminus = content[2].IndexOf('-');
var modesPlus = Array.Empty <char>();
var modesMinus = Array.Empty <char>();
if (iofplus != -1)
{
modesPlus = content[2].Substring(iofplus + 1).ToCharArray();
}
if (iofminus != -1)
{
modesMinus = iofplus != -1
? content[2].Substring(iofminus + 1, content[2].Length - iofplus - 1).ToCharArray()
: content[2].Substring(iofminus + 1).ToCharArray();
}
for (var i = 0; i < modesPlus.Length; i++)
{
if (!channel._modes.Contains(modesPlus[i]) && modesPlus[i] != 'b')
{
channel._modes.Add(modesPlus[i]);
}
}
for (var i = 0; i < modesMinus.Length; i++)
{
if (!channel._modes.Contains(modesMinus[i]) && modesMinus[i] != 'b')
{
channel._modes.Add(modesMinus[i]);
}
}
var complexModes = modesMinus.Where(x => _configuration.ComplexChanModes.Any(y => y == x && x != 'l')).ToList();
complexModes.AddRange(modesPlus.Where(x => _configuration.ComplexChanModes.Any(y => y == x)));
var extraArgs = content.Skip(3).ToList();
var modesArgs = new Dictionary <char, (char, string)>();
for (var i = 0; i < complexModes.Count && i < extraArgs.Count; i++)
{
modesArgs.Add(complexModes[i], (modesMinus.Contains(complexModes[i]) ? '-' : '+', extraArgs[i]));
}
foreach (var complexMod in modesArgs)
{
switch (complexMod.Key)
{
case 'b':
if (complexMod.Value.Item1 == '-')
{
channel._banList.RemoveWhere(x => x.Host == complexMod.Value.Item2);
}
else
{
channel._banList.Add(new ChannelBan
{
IssuedBy = user.Username,
Host = complexMod.Value.Item2,
IssuedOn = DateTimeOffset.UtcNow
});
}
break;
case 'l':
channel.Limit = int.Parse(complexMod.Value.Item2);
break;
case 'k':
channel.Key = complexMod.Value.Item1 == '+' ? complexMod.Value.Item2 : "";
break;
}
}
ChannelModeUpdated?.Invoke(new ChannelModesUpdatedEventArgs
{
Client = this,
CurrentUser = CurrentUser,
Channel = channel,
ModesAdded = new ReadOnlyCollection <char>(modesPlus),
ModesRemoved = new ReadOnlyCollection <char>(modesMinus),
ModesArgs = new ReadOnlyDictionary <char, (char, string)>(modesArgs),
User = channel.Users.FirstOrDefault(x => x == user)
});
return;
}
internal async Task OnUserLeft(SocketGuildUser user) => await(UserLeft?.Invoke(user) ?? Task.CompletedTask);
public override void Update(IEnumerable <Body> bodies)
{
base.Update(bodies);
var trackingIds = new HashSet <ulong>();
foreach (var body in bodies)
{
if (body.IsTracked)
{
trackingIds.Add(body.TrackingId);
}
}
var currentCount = trackingIds.Count;
var previousCount = _trackingIds.Count;
if (currentCount != previousCount)
{
_consecutiveFrames++;
if (_consecutiveFrames >= WindowSize)
{
// The users that entered or left.
var users = new HashSet <ulong>();
if (currentCount > previousCount)
{
// ONE OR MORE USERS ENTERED
foreach (var id in trackingIds)
{
if (!_trackingIds.Contains(id))
{
users.Add(id);
}
}
_args.Users = users;
UserEntered?.Invoke(this, _args);
}
else
{
// ONE OR MORE USERS LEFT
foreach (var id in _trackingIds)
{
if (!trackingIds.Contains(id))
{
users.Add(id);
}
}
_args.Users = users;
UserLeft?.Invoke(this, _args);
}
_trackingIds = trackingIds;
_consecutiveFrames = 0;
}
}
}
protected void OnUserLeft(UserInfo userInfo, string channel)
{
UserLeft?.Invoke(userInfo, channel);
}
void OnChannelUserLeft(IChatChannel channel, UserInformation information)
{
UserLeft?.Invoke(information);
}
public Task Handle(UserLeft notification, CancellationToken cancellationToken)
{
ClearCacheEntry(notification.Guild);
return(Task.CompletedTask);
}
