* QControlKit.csproj:

* MainPage.xaml.cs:
* AppDelegate.cs:
* QControlKitXamDemo.csproj:
* QCueViewModel.cs:
* QControlKitXamDemo.iOS.csproj:
* QControlKitXamDemo.Android.csproj: Update Packages

* QServer.cs:
* QBrowser.cs:
* QWorkspace.cs:
* QEventArgs.cs:
* QEventHandlers.cs: Refine Server Found/Lost and Workspace
  Added/Removed

QControlKit/Events/QEventArgs.cs

@@ -9,6 +9,17 @@ namespace QControlKit.Events
         public QServer server { get; set; }
     }
 
+    public class QServerWorkspaceChangedArgs : EventArgs
+    {
+        public QServer server { get; set; }
+        public QWorkspace workspace { get; set; }
+    }
+
+    public class QServerLostArgs : EventArgs
+    {
+        public QServer server { get; set; }
+    }
+
     public class QServerUpdatedArgs : EventArgs
     {
         public QServer server { get; set; }

QControlKit/Events/QEventHandlers.cs

@@ -1,7 +1,10 @@
 namespace QControlKit.Events
 {
     public delegate void QServerFoundHandler(object source, QServerFoundArgs args);
+    public delegate void QServerLostHandler(object source, QServerLostArgs args);
     public delegate void QServerUpdatedHandler(object source, QServerUpdatedArgs args);
+    public delegate void QServerWorkspaceAddedHandler(object source, QServerWorkspaceChangedArgs args);
+    public delegate void QServerWorkspaceRemovedHandler(object source, QServerWorkspaceChangedArgs args);
 
     public delegate void QWorkspacesUpdatedHandler(object source, QWorkspacesUpdatedArgs args);
 

QControlKit/QBrowser.cs

@@ -5,61 +5,79 @@ using Serilog;
 
 using QControlKit.Constants;
 using QControlKit.Events;
+using System;
+using System.Collections.Generic;
+using System.Linq;
 
 namespace QControlKit
 {
     public class QBrowser
     {
-
-        ZeroconfResolver.ResolverListener zeroconfTCPBrowser;
-
         public ObservableCollection<QServer> servers = new ObservableCollection<QServer>();
 
         public event QServerFoundHandler ServerFound;
+        public event QServerLostHandler ServerLost;
         public event QServerUpdatedHandler ServerUpdatedWorkspaces;
 
         public QBrowser()
         {
-            zeroconfTCPBrowser = ZeroconfResolver.CreateListener(QBonjour.TCPService);
-            zeroconfTCPBrowser.ServiceFound += ZeroconfHostFound;
-            zeroconfTCPBrowser.ServiceLost += ZeroconfHostLost;
+            ProbeForQLabInstances();
         }
 
-        private void ZeroconfHostLost(object sender, IZeroconfHost e)
+        public async void ProbeForQLabInstances()
         {
-            Log.Information($"[browser] Lost {e.DisplayName} : {e.IPAddress}");
+            IReadOnlyList<IZeroconfHost> results = await
+                    ZeroconfResolver.ResolveAsync(QBonjour.TCPService,TimeSpan.FromSeconds(3));
 
-        }
-
-        private void ZeroconfHostFound(object sender, IZeroconfHost e)
-        {
-            
-            
-            foreach(var service in e.Services)
+            foreach (var zeroconfHost in results)
             {
-                if (service.Key.Equals(QBonjour.TCPService))
+                foreach (var service in zeroconfHost.Services)
                 {
-                    Log.Information($"Found {e.DisplayName} : {e.IPAddress} : {service.Value.Port}");
-
-                    QServer server = serverForAddress(e.IPAddress);
-
-                    if(server == null)
+                    if (service.Key.Equals(QBonjour.TCPService))
                     {
-                        QServer serverToAdd = new QServer(e.IPAddress, service.Value.Port);
-                        serverToAdd.name = e.DisplayName;
-                        serverToAdd.zeroconfHost = e;
-                        servers.Add(serverToAdd);
-                        serverToAdd.refreshWorkspaces();
-                        serverToAdd.ServerUpdated += OnServerUpdatedWorkspace;
-                        OnServerFound(serverToAdd);
-                    }
-                    else
-                    {
-                        server.name = e.DisplayName;
+
+                        QServer server = serverForAddress(zeroconfHost.IPAddress);
+
+                        if (server == null)
+                        {
+                            Log.Information($"[qbrowser] Found {zeroconfHost.DisplayName} : {zeroconfHost.IPAddress} : {service.Value.Port}");
+                            QServer serverToAdd = new QServer(zeroconfHost.IPAddress, service.Value.Port);
+                            serverToAdd.name = zeroconfHost.DisplayName;
+                            serverToAdd.zeroconfHost = zeroconfHost;
+                            servers.Add(serverToAdd);
+                            serverToAdd.refreshWorkspaces();
+                            serverToAdd.ServerUpdated += OnServerUpdatedWorkspace;
+                            OnServerFound(serverToAdd);
+                        }
+                        else
+                        {
+                            server.name = zeroconfHost.DisplayName;
+                            server.refreshWorkspaces();
+                        }
                     }
                 }
             }
 
+            List<QServer> qServers = servers.ToList();
+
+            foreach(var server in qServers)
+            {
+                bool serverToBeRemoved = true;
+                foreach(var zeroconfHost in results){
+                    QServer existingServer = serverForAddress(zeroconfHost.IPAddress);
+                    if(server != null)
+                    {
+                        serverToBeRemoved = false;
+                    }
+                }
+                if (serverToBeRemoved)
+                {
+                    server.disconnect();
+                    servers.Remove(server);
+                    Log.Information($"[qbrowser] Lost {server.name} : {server.host} : {server.port}");
+                    OnServerLost(server);
+                }
+            }
         }
 
         public QServer serverForAddress(string address)
@@ -93,6 +111,11 @@ namespace QControlKit
             ServerFound?.Invoke(this, new QServerFoundArgs { server = server });
         }
 
+        protected virtual void OnServerLost(QServer server)
+        {
+            ServerLost?.Invoke(this, new QServerLostArgs { server = server });
+        }
+
         protected virtual void OnServerUpdatedWorkspace(object source, QServerUpdatedArgs args)
         {
             ServerUpdatedWorkspaces?.Invoke(this, args);
@@ -104,7 +127,6 @@ namespace QControlKit
             {
                 server.disconnect();
             }
-            zeroconfTCPBrowser.Dispose();
         }
     }
 }

QControlKit/QControlKit.csproj

@@ -6,7 +6,7 @@
     <Authors>Joel Wetzell</Authors>
     <Version>1.0.0-devel</Version>
     <PackOnBuild>true</PackOnBuild>
-    <PackageVersion>0.0.6</PackageVersion>
+    <PackageVersion>0.0.11</PackageVersion>
     <PackageId>QControlKit</PackageId>
   </PropertyGroup>
 

QControlKit/QServer.cs

@@ -3,12 +3,16 @@ using System.Collections.Generic;
 using Zeroconf;
 
 using QControlKit.Events;
+using System.Collections.ObjectModel;
+using System.Linq;
 
 namespace QControlKit
 {
     public class QServer
     {
         public event QServerUpdatedHandler ServerUpdated;
+        public event QServerWorkspaceAddedHandler WorkspaceAdded;
+        public event QServerWorkspaceRemovedHandler WorkspaceRemoved;
 
         private QClient client;
 
@@ -17,7 +21,7 @@ namespace QControlKit
         public string name { get; set; }
         public string version { get; set; }
         public IZeroconfHost zeroconfHost;
-        public List<QWorkspace> workspaces = new List<QWorkspace>();
+        public ObservableCollection<QWorkspace> workspaces = new ObservableCollection<QWorkspace>();
 
         public QServer(string host, int port)
         {
@@ -61,14 +65,44 @@ namespace QControlKit
                 {
                     QWorkspace workspaceToAdd = new QWorkspace(workspace, this);
                     workspaces.Add(workspaceToAdd);
+                    OnServerAddedWorkspace(workspaceToAdd);
                     //set server version to the version of first workspace found...kind of hacky but eh
                     if (version == null)
                         version = workspaceToAdd.version;
                 }
             }
+            List<QWorkspace> tempWorkspaces = workspaces.ToList();
+            for(int i = 0;i< tempWorkspaces.Count;i++)
+            {
+                QWorkspace workspace = workspaces[i];
+                bool toBeRemoved = true;
+                foreach (var foundWorkspace in args.Workspaces)
+                {
+                    if(workspace.uniqueID == foundWorkspace.uniqueID)
+                    {
+                        toBeRemoved = false;
+                    }
+                }
+                if (toBeRemoved)
+                {
+                    workspace.disconnect();
+                    workspaces.Remove(workspace);
+                    OnServerRemovedWorkspace(workspace);
+                }
+            }
             OnServerUpdated(this);
         }
 
+        protected virtual void OnServerAddedWorkspace(QWorkspace workspace)
+        {
+            WorkspaceAdded?.Invoke(this, new QServerWorkspaceChangedArgs { server = this, workspace = workspace });
+        }
+
+        protected virtual void OnServerRemovedWorkspace(QWorkspace workspace)
+        {
+            WorkspaceRemoved?.Invoke(this, new QServerWorkspaceChangedArgs { server = this, workspace = workspace });
+        }
+
         protected virtual void OnServerUpdated(QServer server)
         {
             ServerUpdated?.Invoke(this, new QServerUpdatedArgs { server = server });

QControlKit/QWorkspace.cs

@@ -11,7 +11,7 @@ using QControlKit.Constants;
 
 namespace QControlKit
 {
-    public class QWorkspace
+    public class QWorkspace: IEquatable<QWorkspace>
     {
 
         private QServer server;
@@ -216,6 +216,8 @@ namespace QControlKit
         public void disconnect()
         {
             Log.Information($"[workspace] disconnecting from <{name}>");
+            if (!connected)
+                return;
             if (heartbeatTimer != null)
                 stopHeartbeat();
             stopReceivingUpdates();
@@ -578,6 +580,25 @@ namespace QControlKit
                 cueList.Print();
             }
         }
+
         #endregion
+
+        public override bool Equals(object obj)
+        {
+            if (obj == null) return false;
+            QWorkspace objAsPart = obj as QWorkspace;
+            if (objAsPart == null) return false;
+            else return Equals(objAsPart);
+        }
+
+        public override int GetHashCode()
+        {
+            return this.uniqueID.GetHashCode();
+        }
+
+        public bool Equals(QWorkspace other)
+        {
+            return this.uniqueID.Equals(other.uniqueID);
+        }
     }
 }