internal void Add(SubscriberCallback callback)
{
lock (itemsLock)
{
if (!callbacks.Contains(callback))
{
callbacks.Add(callback);
}
}
}
/// <summary>
/// This method is used to send a Private message to a user
/// </summary>
/// <param name="args"></param>
/// <param name="toId"></param>
private void SendPrivateMessageClicked(EventArgs args, Guid toId)
{
// Attempt to find the subscriber
SubscriberCallback subscriber = SubscriberService.FindSubscriber(toId);
// If the subscriber object exists
if (NullHelper.Exists(subscriber))
{
// Send a message
SendMessage(true, subscriber);
}
}
/// <summary>
/// This event registers with the chat server
/// </summary>
public void RegisterWithServer()
{
SubscriberCallback callback = new SubscriberCallback(SubscriberName);
callback.Callback = Listen;
callback.Name = SubscriberName;
// Get a message back
SubscriberMessage message = SubscriberService.Subscribe(callback);
// if message.Text exists and equals Subscribed
if ((NullHelper.Exists(message)) && (message.HasText) && (TextHelper.IsEqual(message.Text, "Subscribed")))
{
// Set to true
Connected = true;
// Set the Id the Server assigned
this.Id = message.ToId;
}
// Convert the Subscribers to Names
this.Names = SubscriberService.GetSubscriberNames();
// get the count
int count = NumericHelper.ParseInteger(message.Data.ToString(), 0, -1);
// if there are two people online or more
if (count > 1)
{
// send a message to everyone else this user has joined
SubscriberMessage newMessage = new SubscriberMessage();
// set the text
newMessage.FromId = Id;
newMessage.FromName = SubscriberName;
newMessage.Text = SubscriberName + " has joined the conversation.";
newMessage.ToId = Guid.Empty;
newMessage.ToName = "Room";
newMessage.IsSystemMessage = true;
// Send the message
SubscriberService.BroadcastMessage(newMessage);
// 6.5.2020: Get the Messages as you connect now
this.Messages = SubscriberService.GetBroadcastMessages(this.Id, DisplayMessagesCount);
}
// Update
Refresh();
}
/// <summary>
/// This method returns the Subscriber
/// </summary>
public SubscriberCallback FindSubscriber(Guid id)
{
// initial value
SubscriberCallback subscriber = null;
// if the id Guid is set and the Subscribers exist
if ((id != Guid.Empty) && (HasSubscribers))
{
// Set the return value
subscriber = Subscribers.FirstOrDefault(x => x.Id == id);
}
// return value
return(subscriber);
}
public void Subscribe<T>(string topic, Action<T> callback) where T : Message, new()
{
SubscriberCallback subCallbacks;
if (!subscribers.TryGetValue(topic, out subCallbacks))
{
subCallbacks = new SubscriberCallback
{
messageConstructor = typeof(T).GetConstructor(new Type[0]),
callbacks = new List<Action<Message>> { }
};
subscribers.Add(topic, subCallbacks);
}
subCallbacks.callbacks.Add((Message msg) => { callback((T)msg); });
}
/// <summary>
/// This method Send Private Message
/// </summary>
public void SendPrivateMessage(Guid toId)
{
// if the toId is set
if (toId != Guid.Empty)
{
// Attempt to find the subscriber
SubscriberCallback subscriber = SubscriberService.FindSubscriber(toId);
// If the subscriber object exists
if (NullHelper.Exists(subscriber))
{
// Send the private message
SendMessage(true, subscriber);
}
}
}
public void ImplementService <T>(string topic, Func <T, Message> callback)
where T : Message, new()
{
SubscriberCallback subCallbacks;
if (!subscribers.TryGetValue(topic, out subCallbacks))
{
subCallbacks = new SubscriberCallback
{
messageConstructor = typeof(T).GetConstructor(new Type[0]),
callbacks = new List <Func <Message, Message> > {
}
};
subscribers.Add(topic, subCallbacks);
}
subCallbacks.callbacks.Add((Message msg) => { return(callback((T)msg)); });
}
internal string Register(string query, SubscriberCallback callback,
Func <ConnectionInfo, string, SubscriptionCallbacks> subscribe)
{
SubscriptionCallbacks subscription;
var normalized = query.ToLower();
lock (this.itemsLock)
{
if (!this.subscriptions.TryGetValue(normalized, out subscription))
{
subscription = subscribe(this.connection, query);
this.subscriptions.Add(normalized, subscription);
}
}
subscription.Add(callback);
return(subscription.Uri);
}
/// <summary>
/// This method Send Private Message
/// </summary>
public void SendPrivateMessage(SubscriberCallback subscriber, SubscriberMessage message)
{
// if the message and the subscriber exists and the subscriber has a callback
if ((NullHelper.Exists(message, subscriber)) && (subscriber.HasCallback))
{
// if there are already messages
if (ListHelper.HasOneOrMoreItems(messages))
{
// Insert at the top
Messages.Insert(0, message);
}
else
{
// Add this message
Messages.Add(message);
}
// Send the message to the user
subscriber.Callback(message);
}
}
public string CreateSubscription(ConnectionInfo connectionInfo, string subscriptionQuery, SubscriberCallback callback)
{
if (!connectionInfo.CanCreateSubscription)
throw new InvalidOperationException("This connection doesn't support subscriptions");
SubscriptionInfo subInfo;
if (!proxies.TryGetValue(connectionInfo, out subInfo))
{
var listener = CreateListener(connectionInfo);
subInfo = new SubscriptionInfo() { Proxy = listener };
proxies[connectionInfo] = subInfo;
connectionInfo.ConnectionClosing += ServerConnectionClosing;
}
var subscriptionId = Subscribe(connectionInfo, subscriptionQuery);
subInfo.SubscriptionIDs.Add(subscriptionId);
var key = GetSubscriptionKeyFromUri(subscriptionId);
subscriptions.TryAdd(key, callback);
return subscriptionId;
}
internal void Remove(string subscriptionUri, SubscriberCallback callback)
{
lock (this.itemsLock)
{
var query = this.subscriptions.Where(kv => kv.Value.Uri == subscriptionUri)
.Select(kv => kv.Key)
.FirstOrDefault();
if (String.IsNullOrEmpty(query))
{
return;
}
var subscription = this.subscriptions[query];
subscription.Remove(callback);
if (subscription.Empty)
{
this.subscriptions.Remove(query);
this.Unsubscribe(subscriptionUri);
subscription.CloseProxy();
}
}
}
public void Unsubscribe(ConnectionInfo connectionInfo, string subscriptionUri, SubscriberCallback callback)
{
try
{
SubscriptionInfo subscriptionInfo;
if (proxies.TryGetValue(connectionInfo, out subscriptionInfo))
{
subscriptionInfo.Remove(subscriptionUri, callback);
}
}
catch (FaultException <InfoServiceFaultContract> ex)
{
log.Debug($"Unable to unsubscribe {subscriptionUri}. Must have been deleted already", ex);
}
catch (CommunicationException ex)
{
// also in case connection already disposed
log.Debug("Unable to unsubscribe due to communication error.", ex);
}
}
internal Subscriber(Session session, Int32 subscriberHandle, IntPtr nativeSubscriber, SubscriberCallback userCallback)
{
this._session = session;
this._subscriberHandle = subscriberHandle;
this._nativePtr = nativeSubscriber;
this.UserCallback = userCallback;
}
public string CreateSubscription(ConnectionInfo connectionInfo, string subscriptionQuery, SubscriberCallback callback)
{
if (!connectionInfo.CanCreateSubscription)
{
throw new InvalidOperationException("This connection doesn't support subscriptions");
}
SubscriptionInfo subInfo;
if (!proxies.TryGetValue(connectionInfo, out subInfo))
{
var listener = CreateListener(connectionInfo);
subInfo = new SubscriptionInfo()
{
Proxy = listener
};
proxies[connectionInfo] = subInfo;
connectionInfo.ConnectionClosing += ServerConnectionClosing;
}
var subscriptionId = Subscribe(connectionInfo, subscriptionQuery);
subInfo.SubscriptionIDs.Add(subscriptionId);
var key = GetSubscriptionKeyFromUri(subscriptionId);
subscriptions.TryAdd(key, callback);
return(subscriptionId);
}
public string CreateSubscription(ConnectionInfo connectionInfo, string subscriptionQuery, SubscriberCallback callback)
{
if (!connectionInfo.CanCreateSubscription)
{
throw new InvalidOperationException("This connection doesn't support subscriptions");
}
SubscriptionInfo subInfo;
if (!proxies.TryGetValue(connectionInfo, out subInfo))
{
subInfo = new SubscriptionInfo(connectionInfo);
proxies[connectionInfo] = subInfo;
connectionInfo.ConnectionClosing += ServerConnectionClosing;
}
return(subInfo.Register(subscriptionQuery, callback, Subscribe));
}
public virtual void Unsubscribe <TMessage>(SubscriberCallback <TMessage> subscriber) where TMessage : T
{
Unsubscribe(typeof(TMessage), subscriber);
}
public void Subscribe <TMessage>(SubscriberCallback <TMessage> subscriber) where TMessage : T
{
Subscribe(typeof(TMessage), subscriber);
}
