/// <summary>
/// Updates the Connected property when the connection state changes
/// </summary>
private static void ConnectionStateChanged(object sender, ConnectionState state)
{
if (state == ConnectionState.Disconnected && Online)
{
DependencyService.Get <Toast>().Show("De socket verbinding wordt hersteld");
pusher.ConnectAsync();
}
else if (state == ConnectionState.Connected && !Online)
{
DependencyService.Get <Toast>().Show("De socket verbinding wordt verbroken");
pusher.DisconnectAsync();
}
}
public async Task BindToGlobalEventAsync()
{
#region Code snippet
// Create client
Pusher pusher = new Pusher(Config.AppKey, new PusherOptions
{
Authorizer = new FakeAuthoriser(),
Cluster = Config.Cluster,
});
pusher.Error += ErrorHandler;
// Global event listener
void GlobalListener(string eventName, PusherEvent eventData)
{
if (eventName == "client-chat-event")
{
ChatMessage data = JsonConvert.DeserializeObject <ChatMessage>(eventData.Data);
Trace.TraceInformation($"Message from '{data.Name}': {data.Message}");
}
}
// Bind global event listener
pusher.BindAll(GlobalListener);
// Unbind global event listener
pusher.Unbind(GlobalListener);
// Unbind all event listeners associated with the Pusher client
pusher.UnbindAll();
#endregion Code snippet
await pusher.DisconnectAsync().ConfigureAwait(false);
}
public async Task ConnectThenSubscribePublicChannelAsync()
{
#region Code snippet
// Create client
Pusher pusher = new Pusher(Config.AppKey, new PusherOptions
{
Cluster = Config.Cluster,
});
pusher.Error += ErrorHandler;
// Connect
await pusher.ConnectAsync().ConfigureAwait(false);
// Subscribe
try
{
Channel channel = await pusher.SubscribeAsync("public-channel-1").ConfigureAwait(false);
Assert.AreEqual(true, channel.IsSubscribed);
}
catch (Exception)
{
// Handle error
}
#endregion Code snippet
await pusher.DisconnectAsync().ConfigureAwait(false);
}
public async Task ConnectedAndDisconnectedDelegatesAsync()
{
Pusher pusher = new Pusher(Config.AppKey, new PusherOptions
{
Cluster = Config.Cluster,
Encrypted = true,
});
void OnConnected(object sender)
{
Console.WriteLine("Connected: " + ((Pusher)sender).SocketID);
}
void OnDisconnected(object sender)
{
Console.WriteLine("Disconnected: " + ((Pusher)sender).SocketID);
}
pusher.Connected += OnConnected;
pusher.Disconnected += OnDisconnected;
await pusher.ConnectAsync().ConfigureAwait(false);
await pusher.DisconnectAsync().ConfigureAwait(false);
}
public async Task TriggerClientEventAsync()
{
#region Code snippet
// Create client
Pusher pusher = new Pusher(Config.AppKey, new PusherOptions
{
Authorizer = new FakeAuthoriser(),
Cluster = Config.Cluster,
});
pusher.Error += ErrorHandler;
// Connect
await pusher.ConnectAsync().ConfigureAwait(false);
// Subscribe
Channel channel = await pusher.SubscribeAsync("private-chat-channel-1").ConfigureAwait(false);
// Trigger event
channel.Trigger("client-chat-event", new ChatMessage
{
Name = "Joe",
Message = "Hello from Joe!",
});
#endregion Code snippet
await pusher.DisconnectAsync().ConfigureAwait(false);
}
async Task OnApplicationQuit()
{
if (_pusher != null)
{
await _pusher.DisconnectAsync();
}
}
public async Task ConnectThenSubscribePrivateChannelAsync()
{
#region Code snippet
// Create client
Pusher pusher = new Pusher(Config.AppKey, new PusherOptions
{
Authorizer = new FakeAuthoriser(),
Cluster = Config.Cluster,
});
pusher.Error += ErrorHandler;
// Connect
await pusher.ConnectAsync().ConfigureAwait(false);
try
{
// Subscribe
Channel channel = await pusher.SubscribeAsync("private-chat-channel-1").ConfigureAwait(false);
Assert.AreEqual(true, channel.IsSubscribed);
}
catch (ChannelUnauthorizedException)
{
// Handle client unauthorized error
}
catch (Exception)
{
// Handle other errors
}
#endregion Code snippet
await pusher.DisconnectAsync().ConfigureAwait(false);
}
static void Main()
{
// Get the user's name
Console.WriteLine("What is your name?");
_name = Console.ReadLine();
var connectResult = Task.Run(() => InitPusher());
Task.WaitAll(connectResult);
// Read input in loop
string line;
do
{
line = Console.ReadLine();
if (line == "quit")
{
break;
}
_chatChannel.Trigger("client-my-event", new ChatMessage(message: line, name: _name));
} while (line != null);
var disconnectResult = Task.Run(() => _pusher.DisconnectAsync());
Task.WaitAll(disconnectResult);
}
public async Task PusherSubscribedDelegateAsync()
{
#region Code snippet
// Lists all current presence channel members
void ListMembers(GenericPresenceChannel <ChatMember> channel)
{
Dictionary <string, ChatMember> members = channel.GetMembers();
foreach (var member in members)
{
Trace.TraceInformation($"Id: {member.Key}, Name: {member.Value.Name}");
}
}
// Subscribed event handler
void SubscribedHandler(object sender, Channel channel)
{
if (channel is GenericPresenceChannel <ChatMember> presenceChannel)
{
ListMembers(presenceChannel);
}
else if (channel.Name == "private-chat-channel-1")
{
// Trigger event
channel.Trigger("client-chat-event", new ChatMessage
{
Name = "Joe",
Message = "Hello from Joe!",
});
}
}
// Create client
Pusher pusher = new Pusher(Config.AppKey, new PusherOptions
{
Authorizer = new FakeAuthoriser(),
Cluster = Config.Cluster,
});
pusher.Error += ErrorHandler;
// Add subcribed event handler
pusher.Subscribed += SubscribedHandler;
// Create subscriptions
await pusher.SubscribeAsync("public-channel-1").ConfigureAwait(false);
await pusher.SubscribeAsync("private-chat-channel-1").ConfigureAwait(false);
await pusher.SubscribePresenceAsync <ChatMember>("presence-channel-1").ConfigureAwait(false);
// Connect
await pusher.ConnectAsync().ConfigureAwait(false);
#endregion Code snippet
await pusher.DisconnectAsync().ConfigureAwait(false);
}
public void Disconnect()
{
if (Cache.Queue != null)
{
Cache.Queue = null;
Cache.WsServer.Ping();
}
_pusher.DisconnectAsync();
}
private void Disconnect()
{
try
{
Task.WaitAll(_client.DisconnectAsync());
}
catch (Exception e)
{
_error = e;
}
}
private void StopPusher()
{
_channel?.UnbindAll();
_channel?.Unsubscribe();
#pragma warning disable VSTHRD002 // Avoid problematic synchronous waits
_pusher.DisconnectAsync().Wait();
#pragma warning restore VSTHRD002 // Avoid problematic synchronous waits
_pusher.ConnectionStateChanged -= ConnectionStateChanged;
_pusher.Error -= PusherError;
}
public async Task ConstructionOfAPublicChannelOnlySubscriberAsync()
{
Pusher pusher = new Pusher(Config.AppKey, new PusherOptions
{
Cluster = Config.Cluster,
Encrypted = true,
});
await pusher.ConnectAsync().ConfigureAwait(false);
await pusher.DisconnectAsync().ConfigureAwait(false);
}
public static async Task DisposePusherClientAsync(Pusher pusher)
{
if (pusher != null)
{
((IPusher)pusher).PusherOptions.ClientTimeout = TimeSpan.FromSeconds(30);
await pusher.UnsubscribeAllAsync().ConfigureAwait(false);
await pusher.ConnectAsync().ConfigureAwait(false);
await pusher.DisconnectAsync().ConfigureAwait(false);
}
}
public async Task SubscribeThenConnectPresenceChannelAsync()
{
#region Code snippet
// Create client
Pusher pusher = new Pusher(Config.AppKey, new PusherOptions
{
Authorizer = new FakeAuthoriser(),
Cluster = Config.Cluster,
});
pusher.Error += ErrorHandler;
// Lists all current presence channel members
void ListMembers(GenericPresenceChannel <ChatMember> channel)
{
Dictionary <string, ChatMember> members = channel.GetMembers();
foreach (var member in members)
{
Trace.TraceInformation($"Id: {member.Key}, Name: {member.Value.Name}");
}
}
// MemberAdded event handler
void ChatMemberAdded(object sender, KeyValuePair <string, ChatMember> member)
{
Trace.TraceInformation($"Member {member.Value.Name} has joined");
ListMembers(sender as GenericPresenceChannel <ChatMember>);
}
// MemberRemoved event handler
void ChatMemberRemoved(object sender, KeyValuePair <string, ChatMember> member)
{
Trace.TraceInformation($"Member {member.Value.Name} has left");
ListMembers(sender as GenericPresenceChannel <ChatMember>);
}
// Subscribe
GenericPresenceChannel <ChatMember> memberChannel =
await pusher.SubscribePresenceAsync <ChatMember>("presence-channel-1").ConfigureAwait(false);
memberChannel.MemberAdded += ChatMemberAdded;
memberChannel.MemberRemoved += ChatMemberRemoved;
Assert.AreEqual(false, memberChannel.IsSubscribed);
// Connect
await pusher.ConnectAsync().ConfigureAwait(false);
#endregion Code snippet
await pusher.DisconnectAsync().ConfigureAwait(false);
}
public async Task ConstructionOfAnAuthorizedChannelSubscriberAsync()
{
Pusher pusher = new Pusher(Config.AppKey, new PusherOptions
{
Authorizer = new HttpAuthorizer("http://localhost:8888/auth/Jane"),
Cluster = Config.Cluster,
Encrypted = true,
});
await pusher.ConnectAsync().ConfigureAwait(false);
await pusher.DisconnectAsync().ConfigureAwait(false);
}
public async Task SpecifyingAClientTimeoutAsync()
{
Pusher pusher = new Pusher(Config.AppKey, new PusherOptions
{
Authorizer = new HttpAuthorizer("http://localhost:8888/auth/Jane"),
Cluster = Config.Cluster,
Encrypted = true,
ClientTimeout = TimeSpan.FromSeconds(20),
});
await pusher.ConnectAsync().ConfigureAwait(false);
await pusher.DisconnectAsync().ConfigureAwait(false);
}
public async Task BindToChannelEventAsync()
{
#region Code snippet
// Create client
Pusher pusher = new Pusher(Config.AppKey, new PusherOptions
{
Authorizer = new FakeAuthoriser(),
Cluster = Config.Cluster,
});
pusher.Error += ErrorHandler;
// Channel event listener
void ChannelListener(PusherEvent eventData)
{
ChatMessage data = JsonConvert.DeserializeObject <ChatMessage>(eventData.Data);
Trace.TraceInformation($"Message from '{data.Name}': {data.Message}");
}
// Subscribe
Channel channel = await pusher.SubscribeAsync("private-chat-channel-1")
.ConfigureAwait(false);
// Bind event listener to channel
channel.Bind("client-chat-event", ChannelListener);
// Unbind event listener from channel
channel.Unbind("client-chat-event", ChannelListener);
// Unbind all "client-chat-event" event listeners from the channel
channel.Unbind("client-chat-event");
// Unbind all event listeners from the channel
channel.UnbindAll();
#endregion Code snippet
await pusher.DisconnectAsync().ConfigureAwait(false);
}
public async Task SubscribeThenConnectPrivateChannelAsync()
{
#region Code snippet
// Create client
Pusher pusher = new Pusher(Config.AppKey, new PusherOptions
{
Authorizer = new FakeAuthoriser(),
Cluster = Config.Cluster,
});
pusher.Error += ErrorHandler;
// Subscribe
Channel channel = await pusher.SubscribeAsync("private-chat-channel-1").ConfigureAwait(false);
Assert.AreEqual(false, channel.IsSubscribed);
// Connect
await pusher.ConnectAsync().ConfigureAwait(false);
#endregion Code snippet
await pusher.DisconnectAsync().ConfigureAwait(false);
}
public static void Disconnect()
{
var disconnectResult = Task.Run(() => _pusher.DisconnectAsync());
Task.WaitAll(disconnectResult);
}
private Task DeadlockBugShutdown(Channel channel, Pusher pusherClient)
{
channel.UnbindAll();
channel.Unsubscribe();
return(pusherClient.DisconnectAsync());
}
protected override void OnDestroy()
{
base.OnDestroy();
pusher.UnbindAll();
pusher.DisconnectAsync();
}
public async Task ApiOverviewAsync()
{
#region API Overview
// Raised when Pusher is ready
AutoResetEvent readyEvent = new AutoResetEvent(false);
// Raised when Pusher is done
AutoResetEvent doneEvent = new AutoResetEvent(false);
// Create Pusher client ready to subscribe to public, private and presence channels
Pusher pusher = new Pusher(Config.AppKey, new PusherOptions
{
Authorizer = new FakeAuthoriser(),
Cluster = Config.Cluster,
Encrypted = true,
});
// Lists all current presence channel members
void ListMembers(GenericPresenceChannel <ChatMember> channel)
{
Dictionary <string, ChatMember> members = channel.GetMembers();
foreach (var member in members)
{
Trace.TraceInformation($"Id: {member.Key}, Name: {member.Value.Name}");
}
}
// MemberAdded event handler
void ChatMemberAdded(object sender, KeyValuePair <string, ChatMember> member)
{
Trace.TraceInformation($"Member {member.Value.Name} has joined");
if (sender is GenericPresenceChannel <ChatMember> channel)
{
ListMembers(channel);
}
}
// MemberRemoved event handler
void ChatMemberRemoved(object sender, KeyValuePair <string, ChatMember> member)
{
Trace.TraceInformation($"Member {member.Value.Name} has left");
if (sender is GenericPresenceChannel <ChatMember> channel)
{
ListMembers(channel);
}
}
// Handle errors
void HandleError(object sender, PusherException error)
{
if ((int)error.PusherCode < 5000)
{
// Error recevied from Pusher cluster, use PusherCode to filter.
}
else
{
if (error is ChannelUnauthorizedException unauthorizedAccess)
{
// Private and Presence channel failed authorization with Forbidden (403)
}
else if (error is ChannelAuthorizationFailureException httpError)
{
// Authorization endpoint returned an HTTP error other than Forbidden (403)
}
else if (error is OperationTimeoutException timeoutError)
{
// A client operation has timed-out. Governed by PusherOptions.ClientTimeout
}
else if (error is ChannelDecryptionException decryptionError)
{
// Failed to decrypt the data for a private encrypted channel
}
else
{
// Handle other errors
}
}
Trace.TraceError($"{error}");
}
// Subscribed event handler
void SubscribedHandler(object sender, Channel channel)
{
if (channel is GenericPresenceChannel <ChatMember> presenceChannel)
{
ListMembers(presenceChannel);
}
else if (channel.Name == "private-chat-channel-1")
{
// Trigger event
channel.Trigger("client-chat-event", new ChatMessage
{
Name = "Joe",
Message = "Hello from Joe!",
});
}
}
// Connection state change event handler
void StateChangedEventHandler(object sender, ConnectionState state)
{
Trace.TraceInformation($"SocketId: {((Pusher)sender).SocketID}, State: {state}");
if (state == ConnectionState.Connected)
{
readyEvent.Set();
readyEvent.Reset();
}
if (state == ConnectionState.Disconnected)
{
doneEvent.Set();
doneEvent.Reset();
}
}
// Bind events
void BindEvents(object sender)
{
Pusher _pusher = sender as Pusher;
Channel _channel = _pusher.GetChannel("private-chat-channel-1");
_channel.Bind("client-chat-event", (PusherEvent eventData) =>
{
ChatMessage data = JsonConvert.DeserializeObject <ChatMessage>(eventData.Data);
Trace.TraceInformation($"[{data.Name}] {data.Message}");
});
}
// Unbind events
void UnbindEvents(object sender)
{
((Pusher)sender).UnbindAll();
}
// Add event handlers
pusher.Connected += BindEvents;
pusher.Disconnected += UnbindEvents;
pusher.Subscribed += SubscribedHandler;
pusher.ConnectionStateChanged += StateChangedEventHandler;
pusher.Error += HandleError;
// Create subscriptions
await pusher.SubscribeAsync("public-channel-1").ConfigureAwait(false);
await pusher.SubscribeAsync("private-chat-channel-1").ConfigureAwait(false);
GenericPresenceChannel <ChatMember> memberChannel =
await pusher.SubscribePresenceAsync <ChatMember>("presence-channel-1").ConfigureAwait(false);
memberChannel.MemberAdded += ChatMemberAdded;
memberChannel.MemberRemoved += ChatMemberRemoved;
// Connect
try
{
await pusher.ConnectAsync().ConfigureAwait(false);
}
catch (Exception)
{
// We failed to connect, handle the error.
// You will also receive the error via
// HandleError(object sender, PusherException error)
throw;
}
Assert.AreEqual(ConnectionState.Connected, pusher.State);
Assert.IsTrue(readyEvent.WaitOne(TimeSpan.FromSeconds(5)));
// Remove subscriptions
await pusher.UnsubscribeAllAsync().ConfigureAwait(false);
// Disconnect
await pusher.DisconnectAsync().ConfigureAwait(false);
Assert.AreEqual(ConnectionState.Disconnected, pusher.State);
Assert.IsTrue(doneEvent.WaitOne(TimeSpan.FromSeconds(5)));
#endregion API Overview
}
