Worker connector update (#56)

Author: Paul Balaji

CHANGELOG.md

@@ -2,6 +2,10 @@
 
 ## Unreleased
 
+### Changed
+
+- Upgraded project to the new worker abstraction. [#56](https://github.com/spatialos/gdk-for-unity-blank-project/pull/56)
+
 ## `0.2.3` - 2019-06-12
 
 ### Changed

gdk.pinned

@@ -1 +1 @@
-eae6cf5dcdb72655bde2121614001cdf1dde51bf
+84243525d98aff511e7aa1f7703c37347017e386

workers/unity/Assets/Scripts/MetricSendSystem.cs

@@ -9,7 +9,7 @@ namespace BlankProject
     [DisableAutoCreation]
     public class MetricSendSystem : ComponentSystem
     {
-        private Connection connection;
+        private WorkerSystem worker;
 
         private DateTime timeOfNextUpdate;
         private DateTime timeOfLastUpdate;
@@ -32,7 +32,7 @@ public class MetricSendSystem : ComponentSystem
         protected override void OnCreate()
         {
             base.OnCreate();
-            connection = World.GetExistingSystem<WorkerSystem>().Connection;
+            worker = World.GetExistingSystem<WorkerSystem>();
 
             targetFps = Application.targetFrameRate == -1
                 ? DefaultTargetFrameRate
@@ -47,7 +47,7 @@ protected override void OnCreate()
 
         protected override void OnUpdate()
         {
-            if (connection == null)
+            if (worker == null)
             {
                 return;
             }
@@ -59,7 +59,7 @@ protected override void OnUpdate()
                 WorkerMetrics.GaugeMetrics["Unity used heap size"] = GC.GetTotalMemory(false);
                 WorkerMetrics.Load = CalculateLoad();
 
-                connection.SendMetrics(WorkerMetrics);
+                worker.SendMetrics(WorkerMetrics);
 
                 timeOfLastUpdate = DateTime.Now;
                 timeOfNextUpdate = timeOfLastUpdate.AddSeconds(TimeBetweenMetricUpdatesSecs);

workers/unity/Assets/Scripts/Workers/MobileClientWorkerConnector.cs

@@ -1,21 +1,66 @@
+using System;
 using Improbable.Gdk.Core;
 using Improbable.Gdk.Mobile;
 using Improbable.Gdk.PlayerLifecycle;
+using UnityEngine;
 
 namespace BlankProject
 {
-    public class MobileClientWorkerConnector : DefaultMobileWorkerConnector
+    public class MobileClientWorkerConnector : WorkerConnector, MobileConnectionFlowInitializer.IMobileSettingsProvider
     {
+#pragma warning disable 649
+        [SerializeField] private string ipAddress;
+#pragma warning restore 649
+
         public const string WorkerType = "MobileClient";
 
-        private async void Start()
+        public async void Start()
         {
-            await Connect(WorkerType, new ForwardingDispatcher()).ConfigureAwait(false);
+            var connParams = CreateConnectionParameters(WorkerType, new MobileConnectionParametersInitializer());
+
+            var flowInitializer = new MobileConnectionFlowInitializer(
+                new MobileConnectionFlowInitializer.CommandLineSettingsProvider(),
+                new MobileConnectionFlowInitializer.PlayerPrefsSettingsProvider(),
+                this);
+
+            var builder = new SpatialOSConnectionHandlerBuilder()
+                .SetConnectionParameters(connParams);
+
+            switch (flowInitializer.GetConnectionService())
+            {
+                case ConnectionService.Receptionist:
+                    builder.SetConnectionFlow(new ReceptionistFlow(CreateNewWorkerId(WorkerType),
+                        flowInitializer));
+                    break;
+                case ConnectionService.AlphaLocator:
+                    builder.SetConnectionFlow(new AlphaLocatorFlow(flowInitializer));
+                    break;
+                default:
+                    throw new ArgumentException("Received unsupported connection service.");
+            }
+
+            await Connect(builder, new ForwardingDispatcher()).ConfigureAwait(false);
         }
 
         protected override void HandleWorkerConnectionEstablished()
         {
             PlayerLifecycleHelper.AddClientSystems(Worker.World);
         }
+
+        public Option<string> GetReceptionistHostIp()
+        {
+            return string.IsNullOrEmpty(ipAddress) ? Option<string>.Empty : new Option<string>(ipAddress);
+        }
+
+        public Option<string> GetDevAuthToken()
+        {
+            var token = Resources.Load<TextAsset>("DevAuthToken")?.text.Trim();
+            return token ?? Option<string>.Empty;
+        }
+
+        public Option<ConnectionService> GetConnectionService()
+        {
+            return Option<ConnectionService>.Empty;
+        }
     }
 }

workers/unity/Assets/Scripts/Workers/UnityClientConnector.cs

@@ -1,26 +1,52 @@
-using Improbable.Gdk.Core;
+using System;
+using Improbable.Gdk.Core;
 using Improbable.Gdk.PlayerLifecycle;
 using Improbable.Worker.CInterop;
+using UnityEngine;
 
 namespace BlankProject
 {
-    public class UnityClientConnector : DefaultWorkerConnector
+    public class UnityClientConnector : WorkerConnector
     {
         public const string WorkerType = "UnityClient";
-        
+
         private async void Start()
         {
-            await Connect(WorkerType, new ForwardingDispatcher()).ConfigureAwait(false);
+            var connParams = CreateConnectionParameters(WorkerType);
+            connParams.Network.ConnectionType = NetworkConnectionType.Kcp;
+
+            var builder = new SpatialOSConnectionHandlerBuilder()
+                .SetConnectionParameters(connParams);
+
+            if (!Application.isEditor)
+            {
+                var initializer = new CommandLineConnectionFlowInitializer();
+                switch (initializer.GetConnectionService())
+                {
+                    case ConnectionService.Receptionist:
+                        builder.SetConnectionFlow(new ReceptionistFlow(CreateNewWorkerId(WorkerType), initializer));
+                        break;
+                    case ConnectionService.Locator:
+                        builder.SetConnectionFlow(new LocatorFlow(initializer));
+                        break;
+                    case ConnectionService.AlphaLocator:
+                        builder.SetConnectionFlow(new AlphaLocatorFlow(initializer));
+                        break;
+                    default:
+                        throw new ArgumentOutOfRangeException();
+                }
+            }
+            else
+            {
+                builder.SetConnectionFlow(new ReceptionistFlow(CreateNewWorkerId(WorkerType)));
+            }
+
+            await Connect(builder, new ForwardingDispatcher()).ConfigureAwait(false);
         }
 
         protected override void HandleWorkerConnectionEstablished()
         {
             PlayerLifecycleHelper.AddClientSystems(Worker.World);
         }
-
-        protected override string SelectDeploymentName(DeploymentList deployments)
-        {
-            return deployments.Deployments[0].DeploymentName;
-        }
     }
 }

workers/unity/Assets/Scripts/Workers/UnityGameLogicConnector.cs

@@ -2,17 +2,40 @@
 using Improbable.Gdk.Core;
 using Improbable.Gdk.PlayerLifecycle;
 using Improbable.Gdk.TransformSynchronization;
+using Improbable.Worker.CInterop;
+using UnityEngine;
 
 namespace BlankProject
 {
-    public class UnityGameLogicConnector : DefaultWorkerConnector
+    public class UnityGameLogicConnector : WorkerConnector
     {
         public const string WorkerType = "UnityGameLogic";
-        
+
         private async void Start()
         {
             PlayerLifecycleConfig.CreatePlayerEntityTemplate = CreatePlayerEntityTemplate;
-            await Connect(WorkerType, new ForwardingDispatcher()).ConfigureAwait(false);
+
+            IConnectionFlow flow;
+            ConnectionParameters connectionParameters;
+
+            if (Application.isEditor)
+            {
+                flow = new ReceptionistFlow(CreateNewWorkerId(WorkerType));
+                connectionParameters = CreateConnectionParameters(WorkerType);
+            }
+            else
+            {
+                flow = new ReceptionistFlow(CreateNewWorkerId(WorkerType),
+                    new CommandLineConnectionFlowInitializer());
+                connectionParameters = CreateConnectionParameters(WorkerType,
+                    new CommandLineConnectionParameterInitializer());
+            }
+
+            var builder = new SpatialOSConnectionHandlerBuilder()
+                .SetConnectionFlow(flow)
+                .SetConnectionParameters(connectionParameters);
+
+            await Connect(builder, new ForwardingDispatcher()).ConfigureAwait(false);
         }
 
         protected override void HandleWorkerConnectionEstablished()