Code runs

Aurora/Services/ClientService/ClientService.cs

@@ -0,0 +1,110 @@
+using System;
+using System.Threading.Tasks;
+using System.Threading;
+using Grpc.Core;
+using Aurora.Proto.Events;
+using Aurora.Proto.Party;
+using Aurora.Proto.Playback;
+using Aurora.Services.ClientService;
+
+namespace Aurora.Services.ClientService
+{
+    public class ClientService : BaseService<ClientService>
+    {
+        private RemotePartyService.RemotePartyServiceClient _remotePartyClient;
+        private RemotePlaybackService.RemotePlaybackServiceClient _remotePlaybackClient;
+        private RemoteEventService.RemoteEventServiceClient _remoteEventsClient;
+        private Channel _channel;
+        CancellationTokenSource _eventCancellationTokenSource;
+
+        public ClientService()
+        {
+
+        }
+
+        public EventReceivedEventHandler EventReceived;
+
+        public RemotePartyService.RemotePartyServiceClient RemotePartyClient
+        {
+            get
+            {
+                return _remotePartyClient;
+            }
+        }
+
+        public RemotePlaybackService.RemotePlaybackServiceClient RemotePlaybackServiceClient
+        {
+            get
+            {
+                return _remotePlaybackClient;
+            }
+        }
+
+        public RemoteEventService.RemoteEventServiceClient RemoteEventClient
+        {
+            get { return _remoteEventsClient; }
+        }
+
+        public bool IsStarted
+        {
+            get
+            {
+                return _remoteEventsClient != null &&
+                    _remotePartyClient != null &&
+                    _remotePlaybackClient != null;
+            }
+        }
+
+        public void Start(string hostname, string port)
+        {
+            _channel = new Channel(string.Format("{0}:{1}", hostname, port), ChannelCredentials.Insecure);
+
+            _remotePartyClient = new RemotePartyService.RemotePartyServiceClient(_channel);
+            _remotePlaybackClient = new RemotePlaybackService.RemotePlaybackServiceClient(_channel);
+            _remoteEventsClient = new RemoteEventService.RemoteEventServiceClient(_channel);
+
+            //Assign but don't start task
+            _eventCancellationTokenSource = new CancellationTokenSource();
+        }
+
+        public async void Close()
+        {
+            _eventCancellationTokenSource.Cancel();
+            await _channel.ShutdownAsync();
+
+            _remotePartyClient = null;
+            _remotePlaybackClient = null;
+            _remoteEventsClient = null;
+        }
+
+        /// <summary>
+        /// Asynchronous function for processing events off of the event stream.
+        /// </summary>
+        /// <returns></returns>
+        public async Task GetEvents()
+        {
+            string clientId = SettingsService.Instance.ClientId;
+            Console.WriteLine(string.Format("CLIENT {0} - GetEvents called from client with id", clientId));
+            using (AsyncServerStreamingCall<BaseEvent> eventStream = _remoteEventsClient
+                .GetEvents(new EventsRequest { ClientId = SettingsService.Instance.ClientId }))
+            {
+                try
+                {
+                    while (!_eventCancellationTokenSource.Token.IsCancellationRequested &&
+                        await eventStream.ResponseStream.MoveNext(_eventCancellationTokenSource.Token))
+                    {
+                        BaseEvent e = new BaseEvent(eventStream.ResponseStream.Current);
+                        if (this.EventReceived != null)
+                        {
+                            this.EventReceived.Invoke(this, new EventReceivedEventArgs(e));
+                        }
+                    }
+                }
+                catch (Exception ex)
+                {
+                    Console.WriteLine(string.Format("EXCEPTION --- " + ex.Message));
+                }
+            }
+        }
+    }
+}

Aurora/Services/ClientService/EventReceivedEvent.cs

@@ -0,0 +1,16 @@
+using System;
+using Aurora.Proto.Events;
+
+namespace Aurora.Services.ClientService
+{
+    public delegate void EventReceivedEventHandler(object sender, EventReceivedEventArgs e);
+
+    public class EventReceivedEventArgs
+    {
+        public BaseEvent BaseEvent { get; private set; }
+        public EventReceivedEventArgs(BaseEvent e)
+        {
+            BaseEvent = e;
+        }
+    }
+}