private async void Dispatch(Dictionary <string, Message[]> topics)
{
foreach (var topic in topics)
{
#if NET40
await TaskEx.Yield();
#else
await Task.Yield();
#endif
if (callbacks.TryGetValue(topic.Key, out var callback))
{
if (topic.Value == null)
{
callbacks.TryRemove(topic.Key, out callback);
OnUnsubscribe?.Invoke(topic.Key);
}
else
{
foreach (var message in topic.Value)
{
callback(message);
}
}
}
}
}
public NetEventIOServer_Options(OnPasswordLogin onPasswordLogin, OnTokenLogin onTokenLogin, OnSubscribe onSubscribe,
OnUnsubscribe onUnsubscribe, OnUnsubscribeAll onUnsubscribeAll) : this(onPasswordLogin, onTokenLogin)
{
this.onSubscribe = onSubscribe;
this.onUnsubscribe = onUnsubscribe;
this.onUnsubscribeAll = onUnsubscribeAll;
}
public NetEventIOServer_Options(OnPasswordLogin onPasswordLogin, OnTokenLogin onTokenLogin) : this()
{
this.onPasswordLogin = onPasswordLogin;
this.onTokenLogin = onTokenLogin;
this.onSubscribe = (NetEventIO sender, string topicName) => { return(false); };
this.onUnsubscribe = (NetEventIO sender, string topicName) => { return(false); };
this.onUnsubscribeAll = (NetEventIO sender) => { return(false); };
}
protected bool Offline(ConcurrentDictionary <string, BlockingCollection <Message> > topics, string id, string topic, ServiceContext context)
{
if (topics.TryRemove(topic, out var messages))
{
OnUnsubscribe?.Invoke(id, topic, messages?.ToArray(), context);
messages?.Dispose();
Response(id);
return(true);
}
return(false);
}
public async Task <bool> Unsubscribe(string topic)
{
if (Id != null && Id.Length > 0)
{
bool result = await Client.InvokeAsync <bool>("-", new object[] { topic }).ConfigureAwait(false);
callbacks.TryRemove(topic, out var callback);
OnUnsubscribe?.Invoke(topic);
return(result);
}
return(false);
}
public NetEventIOServer_Options()
{
onPasswordLogin = (NetEventIO client, string pwd) =>
{
return(false);
};
onTokenLogin = (NetEventIO client, string token, string addr) =>
{
return(false);
};
onSubscribe = (NetEventIO sender, string topicName) =>
{
return(false);
};
onUnsubscribe = (NetEventIO sender, string topicName) =>
{
return(false);
};
}
void HandleUnsubscription(IEventSubscription subscription)
{
lock (subscription)
{
foreach (var channel in subscription.Channels ?? EventSubscription.UnknownChannel)
{
UnRegisterSubscription(subscription, channel, ChannelSubcriptions);
}
UnRegisterSubscription(subscription, subscription.SubscriptionId, Subcriptions);
UnRegisterSubscription(subscription, subscription.UserId, UserIdSubcriptions);
UnRegisterSubscription(subscription, subscription.UserName, UserNameSubcriptions);
UnRegisterSubscription(subscription, subscription.SessionId, SessionSubcriptions);
OnUnsubscribe?.Invoke(subscription);
subscription.Dispose();
if (NotifyChannelOfSubscriptions && subscription.Channels != null)
{
NotifyLeave?.Invoke(subscription);
}
}
}
public void Unsubscribe()
{
OnUnsubscribe?.Invoke(this);
}
/// <summary>
/// Processes the message, updating our internal state and then invokes the events.
/// </summary>
/// <param name="message"></param>
private void ProcessMessage(IMessage message)
{
if (message == null)
{
return;
}
switch (message.Type)
{
//We got a update, so we will update our current presence
case MessageType.PresenceUpdate:
lock (_sync)
{
PresenceMessage pm = message as PresenceMessage;
if (pm != null)
{
//We need to merge these presences together
if (CurrentPresence == null)
{
CurrentPresence = pm.Presence;
}
else if (pm.Presence == null)
{
CurrentPresence = null;
}
else
{
CurrentPresence.Merge(pm.Presence);
}
//Update the message
pm.Presence = CurrentPresence;
}
}
break;
//Update our configuration
case MessageType.Ready:
ReadyMessage rm = message as ReadyMessage;
if (rm != null)
{
lock (_sync)
{
Configuration = rm.Configuration;
CurrentUser = rm.User;
}
//Resend our presence and subscription
SynchronizeState();
}
break;
//Update the request's CDN for the avatar helpers
case MessageType.JoinRequest:
if (Configuration != null)
{
//Update the User object within the join request if the current Cdn
JoinRequestMessage jrm = message as JoinRequestMessage;
if (jrm != null)
{
jrm.User.SetConfiguration(Configuration);
}
}
break;
case MessageType.Subscribe:
lock (_sync)
{
SubscribeMessage sub = message as SubscribeMessage;
Subscription |= sub.Event;
}
break;
case MessageType.Unsubscribe:
lock (_sync)
{
UnsubscribeMessage unsub = message as UnsubscribeMessage;
Subscription &= ~unsub.Event;
}
break;
//We got a message we dont know what to do with.
default:
break;
}
//Invoke the appropriate methods
switch (message.Type)
{
case MessageType.Ready:
if (OnReady != null)
{
OnReady.Invoke(this, message as ReadyMessage);
}
break;
case MessageType.Close:
if (OnClose != null)
{
OnClose.Invoke(this, message as CloseMessage);
}
break;
case MessageType.Error:
if (OnError != null)
{
OnError.Invoke(this, message as ErrorMessage);
}
break;
case MessageType.PresenceUpdate:
if (OnPresenceUpdate != null)
{
OnPresenceUpdate.Invoke(this, message as PresenceMessage);
}
break;
case MessageType.Subscribe:
if (OnSubscribe != null)
{
OnSubscribe.Invoke(this, message as SubscribeMessage);
}
break;
case MessageType.Unsubscribe:
if (OnUnsubscribe != null)
{
OnUnsubscribe.Invoke(this, message as UnsubscribeMessage);
}
break;
case MessageType.Join:
if (OnJoin != null)
{
OnJoin.Invoke(this, message as JoinMessage);
}
break;
case MessageType.Spectate:
if (OnSpectate != null)
{
OnSpectate.Invoke(this, message as SpectateMessage);
}
break;
case MessageType.JoinRequest:
if (OnJoinRequested != null)
{
OnJoinRequested.Invoke(this, message as JoinRequestMessage);
}
break;
case MessageType.ConnectionEstablished:
if (OnConnectionEstablished != null)
{
OnConnectionEstablished.Invoke(this, message as ConnectionEstablishedMessage);
}
break;
case MessageType.ConnectionFailed:
if (OnConnectionFailed != null)
{
OnConnectionFailed.Invoke(this, message as ConnectionFailedMessage);
}
break;
default:
//This in theory can never happen, but its a good idea as a reminder to update this part of the library if any new messages are implemented.
Logger.Error("Message was queued with no appropriate handle! {0}", message.Type);
break;
}
}
/// <summary>
/// 退订
/// 实际上用户无法收到非订阅账号的消息，所以这里可以随便写。
/// unsubscribe事件的意义在于及时删除网站应用中已经记录的OpenID绑定，消除冗余数据。并且关注用户流失的情况。
/// </summary>
public override IResponseMessageBase OnEvent_UnsubscribeRequest(RequestMessageEvent_Unsubscribe requestMessage)
{
OnUnsubscribe?.Invoke(null, requestMessage);
return(new SuccessResponseMessage());
}
/// <summary>
/// Dequeues all the messages from Discord and invokes appropriate methods. This will process the message and update the internal state before invoking the events. Returns the messages that were invoked and in the order they were invoked.
/// </summary>
/// <returns>Returns the messages that were invoked and in the order they were invoked.</returns>
public IMessage[] Invoke()
{
//Dequeue all the messages and process them
IMessage[] messages = connection.DequeueMessages();
for (int i = 0; i < messages.Length; i++)
{
//Do a bit of pre-processing
var message = messages[i];
HandleMessage(message);
//Invoke the appropriate methods
switch (message.Type)
{
case MessageType.Ready:
if (OnReady != null)
{
OnReady.Invoke(this, message as ReadyMessage);
}
break;
case MessageType.Close:
if (OnClose != null)
{
OnClose.Invoke(this, message as CloseMessage);
}
break;
case MessageType.Error:
if (OnError != null)
{
OnError.Invoke(this, message as ErrorMessage);
}
break;
case MessageType.PresenceUpdate:
if (OnPresenceUpdate != null)
{
OnPresenceUpdate.Invoke(this, message as PresenceMessage);
}
break;
case MessageType.Subscribe:
if (OnSubscribe != null)
{
OnSubscribe.Invoke(this, message as SubscribeMessage);
}
break;
case MessageType.Unsubscribe:
if (OnUnsubscribe != null)
{
OnUnsubscribe.Invoke(this, message as UnsubscribeMessage);
}
break;
case MessageType.Join:
if (OnJoin != null)
{
OnJoin.Invoke(this, message as JoinMessage);
}
break;
case MessageType.Spectate:
if (OnSpectate != null)
{
OnSpectate.Invoke(this, message as SpectateMessage);
}
break;
case MessageType.JoinRequest:
if (OnJoinRequested != null)
{
OnJoinRequested.Invoke(this, message as JoinRequestMessage);
}
break;
case MessageType.ConnectionEstablished:
if (OnConnectionEstablished != null)
{
OnConnectionEstablished.Invoke(this, message as ConnectionEstablishedMessage);
}
break;
case MessageType.ConnectionFailed:
if (OnConnectionFailed != null)
{
OnConnectionFailed.Invoke(this, message as ConnectionFailedMessage);
}
break;
default:
//This in theory can never happen, but its a good idea as a reminder to update this part of the library if any new messages are implemented.
Logger.Error("Message was queued with no appropriate handle! {0}", message.Type);
break;
}
}
//Finally, return the messages
return(messages);
}
internal void Unsubscribe(MqttMessage message)
{
OnUnsubscribe?.Invoke(this, new MqttMessageEventArgs(message));
}
