First pass at events almost buttoned up.

The goal is to get the members list to update when new users enter and leave the party.

Aurora/Executors/BaseExecutor.cs

@@ -2,8 +2,7 @@ using System;
 using System.Reflection;
 using System.Linq;
 using System.Collections.ObjectModel;
-using Aurora.Proto;
-
+using Aurora.Proto.Party;
 namespace Aurora.Executors
 {
     public abstract class BaseExecutor

Aurora/Executors/ClientExecutor.cs

@@ -1,8 +1,13 @@
 using System;
 using System.Collections.ObjectModel;
+using System.Threading.Tasks;
+using System.Threading;
 using Grpc.Core;
-using Aurora.Proto;
-using Aurora.Models;
+using wellKnown = Google.Protobuf.WellKnownTypes;
+using Aurora.Proto.General;
+using Aurora.Proto.Party;
+using Aurora.Proto.Playback;
+using Aurora.Proto.Events;
 using Aurora.Services;
 namespace Aurora.Executors
 {
@@ -11,6 +16,8 @@ namespace Aurora.Executors
         private Channel _channel;
         private RemotePartyService.RemotePartyServiceClient _remotePartyClient;
         private RemotePlaybackService.RemotePlaybackServiceClient _remotePlaybackClient;
+        private RemoteEventService.RemoteEventServiceClient _remoteEventsClient;
+        private Task _eventsTask;
 
         private ObservableCollection<PartyMember> _partyMembers;
 
@@ -27,16 +34,28 @@ namespace Aurora.Executors
 
         #endregion Properties
 
+        /// <summary>
+        /// Initiates the connection to a party.
+        /// </summary>
+        /// <param name="hostname">The hostname of the gRPC server</param>
         public override void Connect(string hostname)
         {
             _channel = new Channel(string.Format("{0}:{1}", hostname, SettingsService.Instance.DefaultPort), ChannelCredentials.Insecure);
 
             _remotePartyClient = new RemotePartyService.RemotePartyServiceClient(_channel);
             _remotePlaybackClient = new RemotePlaybackService.RemotePlaybackServiceClient(_channel);
+            _remoteEventsClient = new RemoteEventService.RemoteEventServiceClient(_channel);
+
+            //Assign but don't start task
+            _eventsTask = new Task(GetEvents);
 
             JoinParty();
         }
 
+        /// <summary>
+        /// Shutdown Connections
+        /// </summary>
+        /// <returns></returns>
         public override async void Close()
         {
             await _channel.ShutdownAsync();
@@ -69,6 +88,28 @@ namespace Aurora.Executors
                 UserName = SettingsService.Instance.Username,
             });
 
+            RefreshMembers();
+
+            //Subscribe to events
+            SubscribeRequest req = new SubscribeRequest();
+            req.EventTypes.Add(EventType.PartyMemberJoined);
+            req.EventTypes.Add(EventType.PartyMemberLeft);
+            try
+            {
+                _remoteEventsClient.SubscribeToEvents(req);
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine("Error subscribing to events: " + ex.Message);
+            }
+
+
+            _eventsTask.Start();
+
+        }
+
+        private void RefreshMembers()
+        {
             MembersResponse resposne = _remotePartyClient.GetPartyMembers(new Empty());
             //Add members
             foreach (PartyMember member in resposne.Members)
@@ -85,5 +126,36 @@ namespace Aurora.Executors
                 }
             }
         }
+
+        private async void GetEvents()
+        {
+
+            CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
+            using (AsyncServerStreamingCall<BaseEvent> eventStream = _remoteEventsClient.GetEvents(new Empty()))
+            {
+                while (await eventStream.ResponseStream.MoveNext(cancellationTokenSource.Token))
+                {
+                    //Convert derived event type
+                    BaseEvent e = eventStream.ResponseStream.Current;
+                    switch (e.DerivedEventCase)
+                    {
+                        case BaseEvent.DerivedEventOneofCase.None:
+                            {
+                                throw new InvalidOperationException();
+                            }
+                        case BaseEvent.DerivedEventOneofCase.PartyMemberJoinedEvent:
+                            {
+                                PartyMemberJoinedEvent derivedEvent = e.PartyMemberJoinedEvent;
+                                break;
+                            }
+                        case BaseEvent.DerivedEventOneofCase.PartyMemberLeftEvent:
+                            {
+                                PartyMemberJoinedEvent derivedEvent = e.PartyMemberJoinedEvent;
+                                break;
+                            }
+                    }
+                }
+            }
+        }
     }
 }

Aurora/Executors/HostExecutor.cs

@@ -4,7 +4,9 @@ using System.Collections.ObjectModel;
 using Aurora.Models;
 using Aurora.Executors;
 using Aurora.Services;
-using Aurora.Proto;
+using Aurora.Proto.Party;
+using Aurora.Proto.Playback;
+using Aurora.Proto.Events;
 using Aurora.RemoteImpl;
 
 namespace Aurora.Executors
@@ -13,10 +15,12 @@ namespace Aurora.Executors
     {
         RemotePartyServiceImpl _remotePartyServiceImpl;
         RemotePlaybackServiceImpl _remotePlaybackImpl;
+        RemoteEventServiceImpl _remoteEventImpl;
         public HostExecutor()
         {
             _remotePartyServiceImpl = new RemotePartyServiceImpl();
             _remotePlaybackImpl = new RemotePlaybackServiceImpl();
+            _remoteEventImpl = new RemoteEventServiceImpl();
         }
 
         public override void Connect(string hostname)
@@ -27,6 +31,7 @@ namespace Aurora.Executors
             //Register grpc RemoteService with singleton server service
             ServerService.Instance.RegisterService(RemotePartyService.BindService(_remotePartyServiceImpl));
             ServerService.Instance.RegisterService(RemotePlaybackService.BindService(_remotePlaybackImpl));
+            ServerService.Instance.RegisterService(RemoteEventService.BindService(_remoteEventImpl));
 
             //start gRPC server
             ServerService.Instance.Start();