/// <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();
     }
 }
示例#2
0
        public async Task TestPusherEventsAsync()
        {
            var factory = new FakeConnectionFactory();
            var pusher  = new Pusher(factory, "abcd1234", new Options {
                RaiseAllEventsOnPusher = true
            });

            var events = new List <IIncomingEvent>();

            pusher.GetEventSubscription <ConnectionEstablishedEventArgs>().EventEmitted += (sender, evt) =>
            {
                Assert.AreEqual(evt.DataObject.SocketId, "a");
                Assert.AreEqual(evt.EventName, "pusher:connection_established");
                events.Add(evt);
            };
            await pusher.ConnectAsync();

            Assert.AreEqual(1, events.Count);
            events.Clear();

            pusher.GetEventSubscription <SubscriptionSucceededEventArgs>().EventEmitted += (sender, evt) =>
            {
                Assert.AreEqual(evt.Channel, "foo");
                Assert.AreEqual(evt.EventName, "pusher_internal:subscription_succeeded");
                events.Add(evt);
            };

            await pusher.SubscribeToChannelAsync("foo");

            Assert.AreEqual(1, events.Count);
        }
示例#3
0
        // Pusher Initiation / Connection
        private static async Task InitPusher()
        {
            _pusher = new Pusher(Config.AppKey, new PusherOptions
            {
                Authorizer = new HttpAuthorizer("http://localhost:8888/auth/" + HttpUtility.UrlEncode(_name))
            });
            _pusher.ConnectionStateChanged += _pusher_ConnectionStateChanged;
            _pusher.Error += _pusher_Error;

            // Setup private channel
            _chatChannel             = _pusher.SubscribeAsync("private-channel").Result;
            _chatChannel.Subscribed += ChatChannel_Subscribed;

            // Inline binding!
            _chatChannel.Bind("client-my-event", (dynamic data) =>
            {
                Console.WriteLine("[" + data.name + "] " + data.message);
            });

            // Setup presence channel
            _presenceChannel                = (PresenceChannel)_pusher.SubscribeAsync("presence-channel").Result;
            _presenceChannel.Subscribed    += PresenceChannel_Subscribed;
            _presenceChannel.MemberAdded   += PresenceChannel_MemberAdded;
            _presenceChannel.MemberRemoved += PresenceChannel_MemberRemoved;

            await _pusher.ConnectAsync();
        }
示例#4
0
        static void Main(string[] args)
        {
            Console.WriteLine("Ingrese el nombre del usuario.");
            var usernameInput = Console.ReadLine();

            using (HttpClient client = new HttpClient())
            {
                string url       = "http://localhost:64952/Auth/Login";
                var    dataModel = new LoginRequest();
                dataModel.username = usernameInput;

                var data = JsonConvert.SerializeObject(dataModel);

                StringContent requestData = new StringContent(data);
                var           response    = client.PostAsync(url, requestData).Result;

                var userDataJson = response.Content.ReadAsStringAsync().Result;
                var userData     = JsonConvert.DeserializeObject <User>(userDataJson);

                //  Obtener la lista de rooms

                var _pusher = new Pusher("04016b8df0172af7d6fd");
                _pusher.ConnectionStateChanged += _pusher_ConnectionStateChanged;
                _pusher.Error += _pusher_Error;
                _pusher.ConnectAsync();
            }
        }
示例#5
0
    private async Task InitialisePusher()
    {
        if (pusher == null)
        {
            pusher = new Pusher(PUSHER_KEY, new PusherOptions()
            {
                Cluster   = PUSHER_CLUSTER,
                Encrypted = true
            });

            pusher.Error += OnPusherOnError;
            pusher.ConnectionStateChanged += PusherOnConnectionStateChanged;
            pusher.Connected += PusherOnConnected;

            try
            {
                channel = await pusher.SubscribeAsync(PUSHER_CHANNEL_NAME);
            }
            catch (Exception e)
            {
                Debug.LogError($"{e.GetType()} - {e.Message}\n{e.StackTrace}");
            }


            channel.Subscribed += OnChannelOnSubscribed;
            await pusher.ConnectAsync();
        }
    }
示例#6
0
    private async Task InitialisePusher()
    {
        //Environment.SetEnvironmentVariable("PREFER_DNS_IN_ADVANCE", "true");

        if (_pusher == null && (APP_KEY != "APP_KEY") && (APP_CLUSTER != "APP_CLUSTER"))
        {
            _pusher = new Pusher(APP_KEY, new PusherOptions()
            {
                Cluster   = APP_CLUSTER,
                Encrypted = true
            });

            _pusher.Error += OnPusherOnError;
            _pusher.ConnectionStateChanged += PusherOnConnectionStateChanged;
            _pusher.Connected += PusherOnConnected;

            _channel = await _pusher.SubscribeAsync("my-channel");

            _channel.Subscribed += OnChannelOnSubscribed;

            await _pusher.ConnectAsync();
        }
        else
        {
            Debug.LogError("APP_KEY and APP_CLUSTER must be correctly set. Find how to set it at https://dashboard.pusher.com");
        }
    }
示例#7
0
        private async Task StartPusherAsync()
        {
            var smintIoSettingsDatabaseModel = await _smintIoSettingsDatabaseProvider.GetSmintIoSettingsDatabaseModelAsync();

            smintIoSettingsDatabaseModel.ValidateForPusher();

            var pusherAuthEndpoint = $"https://{smintIoSettingsDatabaseModel.TenantId}.clapi.smint.io/consumer/v1/notifications/pusher/auth";

            var tokenDatabaseModel = await _smintIoTokenDatabaseProvider.GetTokenDatabaseModelAsync();

            tokenDatabaseModel.ValidateForPusher();

            var authorizer = new HttpAuthorizer(pusherAuthEndpoint, tokenDatabaseModel.AccessToken);

            _pusher = new Pusher("32f31c26a83e09dc401b", new PusherOptions()
            {
                Cluster    = "eu",
                Authorizer = authorizer
            });

            _pusher.ConnectionStateChanged += ConnectionStateChanged;
            _pusher.Error += PusherError;

            var connectionState = await _pusher.ConnectAsync();

            if (connectionState == ConnectionState.Connected)
            {
                await SubscribeToPusherChannelAsync((int)smintIoSettingsDatabaseModel.ChannelId);
            }
        }
示例#8
0
        protected override async Task Run()
        {
            _pusher.ConnectionStateChanged += (_, state) =>
            {
                _logger.Information("Pusher connection state changed: {PusherConnectionState}", state);
            };

            _pusher.Subscribed += (_, channel) =>
            {
                _logger.Information("Pusher subscribed to channel: {PusherChannelName}", channel.Name);
            };

            await _pusher.ConnectAsync();

            await Task.WhenAll(
                _pusher.SubscribeAsync("sim-data"),
                _pusher.SubscribeAsync("temporal"),
                _pusher.SubscribeAsync("ticker")
                );

            _pusher.BindAll(GlobalHandler);
            _pusher.Bind("sim-data", WrapHandler(SimDataHandler));
            _pusher.Bind("temporal-message", WrapHandler(TemporalHandler));
            _pusher.Bind("ticker-message", WrapHandler(TickerHandler));
            _pusher.Bind("game-data", WrapHandler(GameDataHandler));

            // Wait forever
            await SubscribeLoop();
        }
        public async Task TriggerNotSubscribedErrorTestAsync()
        {
            // Arrange
            ChannelTypes channelType = ChannelTypes.Private;
            Pusher localPusher = PusherFactory.GetPusher(channelType: ChannelTypes.Presence, saveTo: _clients);
            string testEventName = "client-pusher-event-test";
            PusherEvent pusherEvent = CreatePusherEvent(channelType, testEventName);
            await localPusher.ConnectAsync().ConfigureAwait(false);
            Channel localChannel = await localPusher.SubscribeAsync(pusherEvent.ChannelName).ConfigureAwait(false);
            TriggerEventException exception = null;

            // Act
            await localPusher.UnsubscribeAllAsync().ConfigureAwait(false);
            try
            {
                await localChannel.TriggerAsync(testEventName, pusherEvent.Data);
            }
            catch (TriggerEventException error)
            {
                exception = error;
            }

            // Assert
            Assert.IsNotNull(exception, $"Expected a {nameof(TriggerEventException)}");
            Assert.AreEqual(ErrorCodes.TriggerEventNotSubscribedError, exception.PusherCode);
        }
示例#10
0
        protected override void OnCreate(Bundle savedInstanceState)
        {
            base.OnCreate(savedInstanceState);
            SetContentView(Resource.Layout.Main);
            var infoTb = FindViewById <EditText>(Resource.Id.infoTb);

            pusher = new Pusher("dc777df44df8be24ae85", new Handler(Looper.MainLooper));
            pusher.ConnectAsync(15000, ConnectionTimeoutAction.CloseConnection, 20000, NetworkUnavailableAction.Ignore);
            pusher.Connected += (sender) =>
            {
                RunOnUiThread(() =>
                {
                    infoTb.AppendLine("Connected!");
                    channel = pusher.Subscribe("my-channel");
                    channel.Bind("my-event", (obj) =>
                    {
                        var car = Pusher.ParseMessageToObject(obj.message.Value as string, new Car());
                        infoTb.AppendLine($"{car.Name}, {car.Color}, {car.Make}");
                    });
                });
            };
            pusher.ConnectionStateChanged += (s, state) =>
            {
                switch (state)
                {
                case ConnectionState.Disconnected:
                    channel.Unbind("my-event");
                    break;
                }
            };
        }
示例#11
0
    private async Task InitialisePusher()
    {
        //Environment.SetEnvironmentVariable("PREFER_DNS_IN_ADVANCE", "true");

        if (_pusher == null && (APP_KEY != "APP_KEY") && (APP_CLUSTER != "APP_CLUSTER"))
        {
            _pusher = new Pusher(APP_KEY, new PusherOptions()
            {
                Cluster   = APP_CLUSTER,
                Encrypted = true
            });

            _pusher.Error += OnPusherOnError;
            _pusher.ConnectionStateChanged += PusherOnConnectionStateChanged;
            _pusher.Connected += PusherOnConnected;

            _channel = await _pusher.SubscribeAsync(GameMaster.Instance.game.getPin());

            _channel.Subscribed += OnChannelOnSubscribed;
            await _pusher.ConnectAsync();
        }
        else
        {
            Debug.LogError("APP_KEY and APP_CLUSTER must be correctly set.");
        }
    }
示例#12
0
        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);
        }
示例#13
0
        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);
        }
示例#14
0
        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);
        }
示例#15
0
        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);
        }
示例#16
0
        public async Task TestMissingAuthenticatorThrowsExceptionAsync()
        {
            var factory = new FakeConnectionFactory();
            var pusher  = new Pusher(factory, "abcd1234");
            await pusher.ConnectAsync();

            Assert.ThrowsException <AggregateException>(() => pusher.SubscribeToChannelAsync("private-foo").Wait());
        }
示例#17
0
        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 async void Connect()
 {
     _pusher = new Pusher("6f6586ea2b39f7d8e6e1", new PusherOptions()
     {
         Cluster = "eu"
     });
     _pusher.ConnectionStateChanged += pusher_ConnectionStateChanged;
     _pusher.Error += pusher_Error;
     await _pusher.ConnectAsync();
 }
        public async Task PusherEventEmitterPrivateEncryptedChannelTestAsync()
        {
            // Arrange
            byte[] encryptionKey = GenerateEncryptionMasterKey();
            var    pusherServer  = new PusherServer.Pusher(Config.AppId, Config.AppKey, Config.AppSecret, new PusherServer.PusherOptions
            {
                Cluster             = Config.Cluster,
                EncryptionMasterKey = encryptionKey,
            });

            ChannelTypes   channelType          = ChannelTypes.PrivateEncrypted;
            Pusher         localPusher          = PusherFactory.GetPusher(channelType: ChannelTypes.Presence, saveTo: _clients, encryptionKey: encryptionKey);
            string         testEventName        = "private-encrypted-event-test";
            AutoResetEvent globalEventReceived  = new AutoResetEvent(false);
            AutoResetEvent channelEventReceived = new AutoResetEvent(false);
            PusherEvent    globalEvent          = null;
            PusherEvent    channelEvent         = null;
            PusherEvent    pusherEvent          = CreatePusherEvent(channelType, testEventName);

            await localPusher.ConnectAsync().ConfigureAwait(false);

            Channel localChannel = await localPusher.SubscribeAsync(pusherEvent.ChannelName).ConfigureAwait(false);

            void GeneralListener(string eventName, PusherEvent eventData)
            {
                if (eventName == testEventName)
                {
                    globalEvent = eventData;
                    globalEventReceived.Set();
                }
            }

            void Listener(PusherEvent eventData)
            {
                channelEvent = eventData;
                channelEventReceived.Set();
            }

            EventTestData data = new EventTestData
            {
                TextField    = ExpectedTextField,
                IntegerField = ExpectedIntegerField,
            };

            // Act
            localPusher.BindAll(GeneralListener);
            localChannel.Bind(testEventName, Listener);
            await pusherServer.TriggerAsync(pusherEvent.ChannelName, testEventName, data).ConfigureAwait(false);

            // Assert
            Assert.IsTrue(globalEventReceived.WaitOne(TimeSpan.FromSeconds(5)));
            Assert.IsTrue(channelEventReceived.WaitOne(TimeSpan.FromSeconds(5)));
            AssertPusherEventsAreEqual(channelType, pusherEvent, globalEvent);
            AssertPusherEventsAreEqual(channelType, pusherEvent, channelEvent);
        }
        public async Task PusherShouldSuccessfullyConnectTwiceWhenGivenAValidAppKeyAsync()
        {
            // Once
            Pusher pusher = await ConnectTestAsync().ConfigureAwait(false);

            Assert.IsNotNull(pusher);

            // Twice
            await pusher.ConnectAsync().ConfigureAwait(false);

            Assert.AreEqual(ConnectionState.Connected, pusher.State);
        }
示例#21
0
        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);
            }
        }
示例#22
0
        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);
        }
示例#23
0
        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);
        }
示例#24
0
        private static async Task SubscribeMultipleChannelsTestAsync(bool connectBeforeSubscribing, Pusher pusher, IList <string> channelNames)
        {
            // Arrange
            var subscribedEvent = new AutoResetEvent(false);
            int subscribedCount = 0;

            pusher.Subscribed += (sender, channelName) =>
            {
                subscribedCount++;
                if (subscribedCount == channelNames.Count)
                {
                    subscribedEvent.Set();
                }
            };

            // Act
            if (connectBeforeSubscribing)
            {
                await pusher.ConnectAsync().ConfigureAwait(false);

                foreach (string channelName in channelNames)
                {
                    await pusher.SubscribeAsync(channelName).ConfigureAwait(false);
                }
            }
            else
            {
                foreach (string channelName in channelNames)
                {
                    await pusher.SubscribeAsync(channelName).ConfigureAwait(false);
                }
                AssertIsDisconnected(pusher, channelNames);
                await pusher.ConnectAsync().ConfigureAwait(false);
            }

            // Assert
            Assert.IsTrue(subscribedEvent.WaitOne(TimeSpan.FromSeconds(5)));
            AssertIsSubscribed(pusher, channelNames);
        }
示例#25
0
        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);
        }
示例#26
0
        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);
        }
示例#27
0
        private async void BeginPusherEventReceptionSession()
        {
            // The previous Extended Execution must be closed before a new one can be requested.
            // This code is redundant here because the sample doesn't allow a new extended
            // execution to begin until the previous one ends, but we leave it here for illustration.
            EndPusherEventReceptionSession();

            var newSession = new ExtendedExecutionSession();

            newSession.Reason      = ExtendedExecutionReason.Unspecified;
            newSession.Description = "Checking for Pusher events";
            newSession.Revoked    += PusherEventReceptionSessionRevoked;
            ExtendedExecutionResult result = await newSession.RequestExtensionAsync();

            switch (result)
            {
            case ExtendedExecutionResult.Allowed:
                Debug.WriteLine("Extended execution was allowed");
                foreach (PusherEventConfig config in EventConfigs)
                {
                    var pusher = new Pusher(config.AppKey, new PusherOptions()
                    {
                        Cluster = config.AppCluster
                    });
                    pusher.ConnectionStateChanged += PusherConnectionStateChanged;
                    pusher.Error += PusherError;
                    ConnectionState connectionState = await pusher.ConnectAsync();

                    Channel myChannel = await pusher.SubscribeAsync(config.ChannelName);

                    myChannel.Bind(config.EventName, async(PusherClient.PusherEvent eventData) =>
                    {
                        await OnPusherEventReceptionAsync(config, eventData);
                    });
                }
                pusherEventReceptionSession = newSession;
                break;

            default:
            case ExtendedExecutionResult.Denied:
                Debug.WriteLine("Extended execution was denied");
                newSession.Dispose();
                break;
            }
        }
示例#28
0
        // Pusher Initiation / Connection
        private async void InitPusher()
        {
            _pusher = new Pusher("625e6f2e093b6e564050", new PusherOptions()
            {
                Encrypted = true,
                Cluster   = "ap1"
            });

            // Setup private channel
            _tableChannel = _pusher.SubscribeAsync("mobile").Result;

            // Inline binding!
            _tableChannel.Bind("changeStateTable-event", (dynamic data) =>
            {
                UpdateTables();
            });
            await _pusher.ConnectAsync();
        }
示例#29
0
        private async Task InitPusher()
        {
            var options = new PusherOptions {
                Cluster = "us2", Encrypted = true
            };

            _pusher = new Pusher(ConfigurationManager.AppSettings["pusher_app_key"], options);
            _pusher.ConnectionStateChanged += _pusher_ConnectionStateChanged;
            _pusher.Error += _pusher_Error;

            _channel             = _pusher.SubscribeAsync(ConfigurationManager.AppSettings["pusher_channel"]).Result;
            _channel.Subscribed += ChatChannel_Subscribed;

            _channel.Bind("lista-contratados", (dynamic data) => { setarContratados(JsonConvert.DeserializeObject(data.data.ToString())); });
            _channel.Bind("lista-demitidos", (dynamic data) => { setarDemitidos(JsonConvert.DeserializeObject(data.data.ToString())); });

            await _pusher.ConnectAsync();
        }
        private async Task DynamicEventEmitterTestAsync(ChannelTypes channelType)
        {
            // Arrange
            Pusher         localPusher          = PusherFactory.GetPusher(channelType: ChannelTypes.Presence, saveTo: _clients);
            string         testEventName        = "client-dynamic-event-test";
            AutoResetEvent globalEventReceived  = new AutoResetEvent(false);
            AutoResetEvent channelEventReceived = new AutoResetEvent(false);
            dynamic        globalEvent          = null;
            dynamic        channelEvent         = null;
            dynamic        dynamicEventData     = CreateDynamicEventData();
            string         channelName          = ChannelNameFactory.CreateUniqueChannelName(channelType: channelType);

            await localPusher.ConnectAsync().ConfigureAwait(false);

            Channel remoteChannel = await _remoteClient.SubscribeAsync(channelName).ConfigureAwait(false);

            Channel localChannel = await localPusher.SubscribeAsync(channelName).ConfigureAwait(false);

            void GeneralListener(string eventName, dynamic eventData)
            {
                if (eventName == testEventName)
                {
                    globalEvent = eventData;
                    globalEventReceived.Set();
                }
            }

            void Listener(dynamic eventData)
            {
                channelEvent = eventData;
                channelEventReceived.Set();
            }

            // Act
            localPusher.BindAll(GeneralListener);
            localChannel.Bind(testEventName, Listener);
            remoteChannel.Trigger(testEventName, dynamicEventData);

            // Assert
            Assert.IsTrue(globalEventReceived.WaitOne(TimeSpan.FromSeconds(5)));
            Assert.IsTrue(channelEventReceived.WaitOne(TimeSpan.FromSeconds(5)));
            ValidateDynamicEvent(channelName, testEventName, globalEvent);
            ValidateDynamicEvent(channelName, testEventName, channelEvent);
        }
		private async void ConnectAsync()
		{
			var options = new Options {Scheme = WebServiceScheme.Secure};
			if (AuthenticationRequired)
			{
				options.Authenticator = new Authenticator(AuthenticationUrl, new Dictionary<string, string>
					{
						{"channel", Channel}
					});
			}

            var synchronizationContext = SynchronizationContext.Current;

            _pusher = new Pusher(new WebSocketConnectionFactory(), AppKey, options);
			_pusher.Logger = _logger;
		    _pusher.ExceptionOccured +=
		        (sender, args) => synchronizationContext.Post(
		            x => _logger.Debug("Exception occured: {0}", args.Exception.Message), null);

			_logger.Debug("Connecting...");
			await _pusher.ConnectAsync();
			_logger.Debug("Connected!");
			_logger.Debug("Subscribing to {0}!", Channel);
			var channel = await _pusher.SubscribeToChannelAsync(Channel);

			channel.GetEventSubscription<SubscriptionSucceededEventArgs>().EventEmitted += async (sender, evt) =>
				{
					synchronizationContext.Post(async channelName =>
						{
							var d = new MessageDialog(string.Format("Subscribed to {0}!", channelName));
							await d.ShowAsync();
						}, evt.Channel);
				};
		}
		public async Task TestRaiseAllEventsOnPusherAsync()
		{
			var factory = new FakeConnectionFactory();
			var pusher = new Pusher(factory, "abcd1234", new Options { RaiseAllEventsOnPusher = false });

			await pusher.ConnectAsync();

			var eventsOnPusher = 0;
			pusher.EventEmitted += (sender, evt) => eventsOnPusher++;
			var eventsOnChannel = 0;
			var channel = await pusher.SubscribeToChannelAsync("foo");
			channel.EventEmitted += (sender, evt) => eventsOnChannel++;

			// the subscribe successful event is raised on channel, but it is raised before we can hook up the event
			Assert.AreEqual(0, eventsOnChannel);
			// RaiseAllEventsOnPusher = false prevents the subscribe successful event from being raised on pusher
			Assert.AreEqual(0, eventsOnPusher);
		}
		public async Task TestMissingAuthenticatorThrowsExceptionAsync()
		{
			var factory = new FakeConnectionFactory();
			var pusher = new Pusher(factory, "abcd1234");
			await pusher.ConnectAsync();

			Assert.ThrowsException<AggregateException>(() => pusher.SubscribeToChannelAsync("private-foo").Wait());
		}
		public async Task TestChannelTypesAsync()
		{
			var factory = new FakeConnectionFactory();
			var pusher = new Pusher(factory, "abcd1234", new Options() { Authenticator = new FakeAuthenticator() });
			await pusher.ConnectAsync();

			var privateChannel = await pusher.SubscribeToChannelAsync("private-foo");
			var presenceChannel = await pusher.SubscribeToChannelAsync("presence-foo");
			var normalChannel = await pusher.SubscribeToChannelAsync("foo");

			Assert.AreEqual(typeof(PrivateChannel), privateChannel.GetType());
			Assert.AreEqual(typeof(PresenceChannel), presenceChannel.GetType());
			Assert.AreEqual(typeof(Channel), normalChannel.GetType());
		}
		public async Task TestEventContractAsync()
		{
			var factory = new FakeConnectionFactory();
			var pusher = new Pusher(factory, "abcd1234", new Options() { Authenticator = new FakeAuthenticator() });
			pusher.AddContract(EventContract.Create<FakeEvent>("fooHappened"));
			await pusher.ConnectAsync();

			var sentEvent = new IncomingEvent<FakeEvent>
				{
					Channel = "foo",
					DataObject = new FakeEvent {Id = 1, Text = "foo"},
					EventName = "fooHappened"
				};
			var channel = await pusher.SubscribeToChannelAsync("foo");
			var eventsReceived = 0;
			channel.GetEventSubscription<FakeEvent>().EventEmitted += (sender, receivedEvent) =>
				{
					Assert.AreEqual(sentEvent.DataObject.Id, receivedEvent.DataObject.Id);
					Assert.AreEqual(sentEvent.DataObject.Text, receivedEvent.DataObject.Text);
					Assert.AreEqual(sentEvent.EventName, receivedEvent.EventName);
					Assert.AreEqual(sentEvent.Channel, receivedEvent.Channel);
					eventsReceived++;
				};

			channel.EventEmitted += (sender, receivedEvent) =>
				{
					Assert.AreEqual(sentEvent.EventName, receivedEvent.EventName);
					Assert.AreEqual(sentEvent.Channel, receivedEvent.Channel);
					eventsReceived++;

					Assert.AreEqual(typeof(IncomingEvent<FakeEvent>), receivedEvent.GetType());
				};

			factory.LastCreated.SendData(JsonConvert.SerializeObject(sentEvent));
			Assert.AreEqual(2, eventsReceived);
		}
		public async Task TestPusherEventsAsync()
		{
			var factory = new FakeConnectionFactory();
			var pusher = new Pusher(factory, "abcd1234", new Options { RaiseAllEventsOnPusher = true });

			var events = new List<IIncomingEvent>();

			pusher.GetEventSubscription<ConnectionEstablishedEventArgs>().EventEmitted += (sender, evt) =>
				{
					Assert.AreEqual(evt.DataObject.SocketId, "a");
					Assert.AreEqual(evt.EventName, "pusher:connection_established");
					events.Add(evt);
				};
			await pusher.ConnectAsync();

			Assert.AreEqual(1, events.Count);
			events.Clear();

			pusher.GetEventSubscription<SubscriptionSucceededEventArgs>().EventEmitted += (sender, evt) =>
			{
				Assert.AreEqual(evt.Channel, "foo");
				Assert.AreEqual(evt.EventName, "pusher_internal:subscription_succeeded");
				events.Add(evt);
			};

			await pusher.SubscribeToChannelAsync("foo");

			Assert.AreEqual(1, events.Count);
		}