public async Task ShouldRemoveHandlerFromSubscribers()
{
_channel.Subscribe(_handler);
_channel.Unsubscribe(_handler);
await _client.FakeMessageReceived(new Message("test", "best"), _channel.Name);
//Handler should not throw
}
public async Task SendingAMessageAttachesTheChannel_BeforeReceivingTheMessages(Protocol protocol)
{
Logger.LogLevel = LogLevel.Debug;
;
// Arrange
var client = await GetRealtimeClient(protocol);
IRealtimeChannel target = client.Channels.Get("test");
var messagesReceived = new List <Message>();
target.Subscribe(message =>
{
messagesReceived.Add(message);
_resetEvent.Set();
});
// Act
target.Publish("test", "test data");
target.State.Should().Be(ChannelState.Attaching);
_resetEvent.WaitOne(6000);
// Assert
target.State.Should().Be(ChannelState.Attached);
messagesReceived.Count.ShouldBeEquivalentTo(1);
messagesReceived[0].Name.ShouldBeEquivalentTo("test");
messagesReceived[0].Data.ShouldBeEquivalentTo("test data");
}
public async Task ChannelSubscribe()
{
var realtime = new AblyRealtime(new ClientOptions(PlaceholderKey)
{
AutoConnect = false
});
IRealtimeChannel channel = realtime.Channels.Get("test");
// Or ...
IRealtimeChannel channel2 = realtime.Channels.Get("shortcut");
channel.Subscribe(message =>
{
var name = message.Name;
var data = message.Data;
});
channel.On(args =>
{
var state = args.Current; // Current channel State
var error = args.Error; // If the channel error-ed it will be reflected here
});
channel.On(ChannelEvent.Attached, args =>
{
// Do stuff when channel is attached
});
channel.Publish("greeting", "Hello World!");
channel.Publish("greeting", "Hello World!", (success, error) =>
{
// If 'Publish' succeeded 'success' is 'true'
// If 'Publish' failed 'success' is 'false' and 'error' will contain the specific error
});
var result = await channel.PublishAsync("greeting", "Hello World!");
// You can check if the message failed
if (result.IsFailure)
{
var error = result.Error; // The error reason can be accessed as well
}
var secret = Crypto.GenerateRandomKey();
var encryptedChannel = realtime.Channels.Get("encrypted", new ChannelOptions(secret));
encryptedChannel.Subscribe(message =>
{
var data = message.Data; // Sensitive data (encrypted before published)
});
encryptedChannel.Publish("name (not encrypted)", "sensitive data (encrypted before published)");
}
public void Open(string networkAddress)
{
_channel = _ably.Channels.Get(networkAddress);
_channel.Subscribe((Message msg) =>
{
if (_publicAddress != msg.Name)
{
foreach (EventHandler <string> handler in _handlers)
{
handler.Invoke(this, msg.Data.ToString());
}
}
});
}
public async Task TestAttachChannel_Sending3Messages_EchoesItBack(Protocol protocol)
{
Logger.LogLevel = LogLevel.Debug;
;
// Arrange
var client = await GetRealtimeClient(protocol);
await client.WaitForState(ConnectionState.Connected);
ManualResetEvent resetEvent = new ManualResetEvent(false);
IRealtimeChannel target = client.Channels.Get("test" + protocol);
target.Attach();
await target.WaitForState(ChannelState.Attached);
ConcurrentQueue <Message> messagesReceived = new ConcurrentQueue <Message>();
int count = 0;
target.Subscribe(message =>
{
messagesReceived.Enqueue(message);
count++;
if (count == 3)
{
resetEvent.Set();
}
});
// Act
target.Publish("test1", "test 12");
target.Publish("test2", "test 123");
target.Publish("test3", "test 321");
bool result = resetEvent.WaitOne(8000);
await Task.Delay(100);
result.Should().BeTrue();
// Assert
messagesReceived.Count.ShouldBeEquivalentTo(3);
var messages = messagesReceived.ToList();
messages[0].Name.ShouldBeEquivalentTo("test1");
messages[0].Data.ShouldBeEquivalentTo("test 12");
messages[1].Name.ShouldBeEquivalentTo("test2");
messages[1].Data.ShouldBeEquivalentTo("test 123");
messages[2].Name.ShouldBeEquivalentTo("test3");
messages[2].Data.ShouldBeEquivalentTo("test 321");
}
static async Task Main(string[] args)
{
AblyRealtime ably = new AblyRealtime("HG2KVw.AjZP_A:W7VXUG9yw1-Cza6u");
IRealtimeChannel channel = ably.Channels.Get("[?delta=vcdiff]delta-sample-app");
VcdiffDecoder channelDecoder = new VcdiffDecoder();
channel.Subscribe(message =>
{
object data = message.Data;
try
{
if (VcdiffDecoder.IsDelta(data))
{
data = channelDecoder.ApplyDelta(data).AsObject();
}
else
{
channelDecoder.SetBase(data);
}
}
catch (Exception e)
{
/* Delta decoder error */
}
/* Process decoded data */
Console.WriteLine(JsonHelper.DeserializeObject <Data>(data as JObject));
});
ably.Connection.On(ConnectionEvent.Connected, change =>
{
Data data = new Data()
{
foo = "bar",
count = 1,
status = "active"
};
channel.Publish("data", data);
data.count++;
channel.Publish("data", data);
data.status = "inactive";
channel.Publish("data", data);
});
await Task.Run(() =>
{
Console.ReadLine();
});
}
public async Task TestAttachChannel_Sending3Messages_EchoesItBack(Protocol protocol)
{
// Arrange
var client = await GetRealtimeClient(protocol);
ManualResetEvent resetEvent = new ManualResetEvent(false);
IRealtimeChannel target = client.Channels.Get("test" + protocol);
target.Attach();
List <Message> messagesReceived = new List <Message>();
int count = 0;
target.Subscribe(message =>
{
messagesReceived.Add(message);
count++;
if (count == 3)
{
resetEvent.Set();
}
});
// Act
target.Publish("test1", "test 12");
target.Publish("test2", "test 123");
target.Publish("test3", "test 321");
bool result = resetEvent.WaitOne(8000);
result.Should().BeTrue();
// Assert
messagesReceived.Count.ShouldBeEquivalentTo(3);
messagesReceived[0].Name.ShouldBeEquivalentTo("test1");
messagesReceived[0].Data.ShouldBeEquivalentTo("test 12");
messagesReceived[1].Name.ShouldBeEquivalentTo("test2");
messagesReceived[1].Data.ShouldBeEquivalentTo("test 123");
messagesReceived[2].Name.ShouldBeEquivalentTo("test3");
messagesReceived[2].Data.ShouldBeEquivalentTo("test 321");
}
public BrimeRealtimeAPI(string channelName)
{
ClientOptions options = new ClientOptions(ABLY_TOKEN);
options.AutoConnect = false;
options.LogHandler = new AblyLogHandler(Logger);
options.LogLevel = LogLevel.None;
this.ably = new AblyRealtime(options);
this.ably.Connection.On((state) => {
// onOpen / onClose
switch (state.Current)
{
case IO.Ably.Realtime.ConnectionState.Connected:
isConnected = true;
foreach (BrimeRealtimeListener listener in listeners)
{
listener.onOpen();
}
break;
case IO.Ably.Realtime.ConnectionState.Closed:
case IO.Ably.Realtime.ConnectionState.Failed:
isConnected = false;
foreach (BrimeRealtimeListener listener in listeners)
{
listener.onClose();
}
break;
}
});
this.ably.Channels.Get(channelName.ToLower() + "/alerts").Subscribe((message) => {
// Follow Alerts
if (message.Name == "alert")
{
JObject data = JObject.Parse((string)message.Data);
string?type = data.Value <string>("type");
if (type != null)
{
if (type.Equals("follow"))
{
string?follower = data.Value <string>("follower");
string?followerID = data.Value <string>("followerID");
if (follower == null)
{
follower = "";
}
if (followerID == null)
{
followerID = "";
}
foreach (BrimeRealtimeListener listener in listeners)
{
listener.onFollow(follower, followerID);
}
}
else if (type.Equals("subscribe"))
{
string?subscriber = data.Value <string>("subscriber");
string?subscriberID = data.Value <string>("subscriberID");
if (subscriber == null)
{
subscriber = "";
}
if (subscriberID == null)
{
subscriberID = "";
}
foreach (BrimeRealtimeListener listener in listeners)
{
listener.onSubscribe(subscriber, subscriberID, false);
}
}
else if (type.Equals("resubscribe"))
{
string?subscriber = data.Value <string>("subscriber");
string?subscriberID = data.Value <string>("subscriberID");
if (subscriber == null)
{
subscriber = "";
}
if (subscriberID == null)
{
subscriberID = "";
}
foreach (BrimeRealtimeListener listener in listeners)
{
listener.onSubscribe(subscriber, subscriberID, true);
}
}
}
}
});
IRealtimeChannel channel = this.ably.Channels.Get(channelName.ToLower());
IEnumerable <PresenceMessage> msgs = channel.Presence.GetAsync().Result;
int viewCount = 0; foreach (PresenceMessage msg in msgs)
{
viewCount++;
}
ViewCountTracker = new ViewCountTracker(viewCount);
registerListener(ViewCountTracker); // register for tracking updates
Task.Run(() => {
while (isConnected)
{
System.Threading.Thread.Sleep(VIEW_UPDATE);
IEnumerable <PresenceMessage> msgs = channel.Presence.GetAsync().Result;
int viewCount = 0; foreach (PresenceMessage msg in msgs)
{
viewCount++;
}
ViewCountTracker.ViewCount = viewCount;
}
});
channel.Presence.Subscribe((message) => {
// onJoin / onLeave
switch (message.Action)
{
case PresenceAction.Absent:
case PresenceAction.Leave:
foreach (BrimeRealtimeListener listener in listeners)
{
listener.onLeave(message.ClientId);
}
break;
case PresenceAction.Enter:
case PresenceAction.Present:
case PresenceAction.Update:
foreach (BrimeRealtimeListener listener in listeners)
{
listener.onJoin(message.ClientId);
}
break;
}
});
// Deprecated
channel.Subscribe((message) => {
// onChat
if (message.Name == "greeting")
{
Logger.Trace("Message Data: " + message.Data);
BrimeChatMessage chatMessage = new BrimeChatMessage(JObject.Parse((string)message.Data));
foreach (BrimeRealtimeListener listener in listeners)
{
listener.onChat(chatMessage);
}
}
else
{
Logger.Trace("Message Name: " + message.Name);
}
/* TODO: Needs ChannelID, so will need Client-ID to use
* switch (message.Name) {
* case "chat": // updated chat messages
* Logger.Trace("Chat Data: " + message.Data);
* break;
* case "delete": // delete message
* Logger.Trace("Delete Data: " + message.Data);
* break;
* }
*/
});
}