SharingStage.cs

Go to the documentation of this file.

// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License. See LICENSE in the project root for license information.

using System;
using UnityEngine;
using HoloToolkit.Sharing.Utilities;
using HoloToolkit.Unity;

namespace HoloToolkit.Sharing
{
    public class SharingStage : Singleton<SharingStage>
    {
        public event EventHandler SharingManagerConnected;

        public event EventHandler SharingManagerDisconnected;

        private const string DefaultUserName = "User ";

        public ClientRole ClientRole = ClientRole.Primary;

        [Tooltip("Address of the sharing server")]
        public string ServerAddress = "localhost";

        public string SessionName
        {
            get
            {
                return Manager.GetSessionManager() != null && Manager.GetSessionManager().GetCurrentSession() != null
                    ? Manager.GetSessionManager().GetCurrentSession().GetName().GetString()
                    : defaultSessionName;
            }
        }

        [SerializeField]
        [Tooltip("Name of the session to join.")]
        private string defaultSessionName = "DefaultSession";

        public string RoomName
        {
            get
            {
                return CurrentRoomManager != null && CurrentRoomManager.GetCurrentRoom() != null
                    ? CurrentRoomManager.GetCurrentRoom().GetName().GetString()
                    : defaultRoomName;
            }
        }

        [SerializeField]
        [Tooltip("Name of the room to join.")]
        private string defaultRoomName = "DefaultRoom";

        public bool KeepRoomAlive;

        [Tooltip("Port of the sharing server")]
        public int ServerPort = 20602;

        [Tooltip("Should the app connect to the server at startup")]
        [SerializeField]
        private bool connectOnAwake = true;

        public SharingManager Manager { get; private set; }

        public bool AutoDiscoverServer;

        [Tooltip("Determines how often the discovery service should ping the network in search of a server.")]
        public float PingIntervalSec = 2;

        public bool IsAudioEndpoint = true;

        private ConsoleLogWriter logWriter;

        public SyncRoot Root { get; private set; }

        public ServerSessionsTracker SessionsTracker { get; private set; }

        public SessionUsersTracker SessionUsersTracker { get; private set; }

        public SyncStateListener SyncStateListener { get; private set; }

        public string AppInstanceUniqueId { get; private set; }

        public event Action<string> UserNameChanged;

        private DiscoveryClient discoveryClient;

        private DiscoveryClientAdapter discoveryClientAdapter;

        private float pingIntervalCurrent;

        private bool isTryingToFindServer;

        [Tooltip("Show Detailed Information for sharing services.")]
        public bool ShowDetailedLogs;

        public string UserName
        {
            get
            {
                using (User user = Manager.GetLocalUser())
                {
                    using (XString userName = user.GetName())
                    {
                        return userName.GetString();
                    }
                }
            }
            set
            {
                using (var userName = new XString(value))
                {
                    Manager.SetUserName(userName);
                }

                UserNameChanged.RaiseEvent(value);
            }
        }

        public RoomManagerAdapter RoomManagerAdapter;

        public RoomManager CurrentRoomManager { get { return Manager != null ? Manager.GetRoomManager() : null; } }

        public Room CurrentRoom
        {
            get { return CurrentRoomManager != null ? CurrentRoomManager.GetCurrentRoom() : null; }
        }

        private NetworkConnectionAdapter networkConnectionAdapter;

        public NetworkConnection Connection
        {
            get { return Manager != null ? Manager.GetServerConnection() : null; }
        }

        public bool IsConnected
        {
            get { return Manager != null && Connection != null && Connection.IsConnected(); }
        }

        #region Unity Methods

        protected override void Awake()
        {
            base.Awake();

            AppInstanceUniqueId = Guid.NewGuid().ToString();
            logWriter = new ConsoleLogWriter { ShowDetailedLogs = ShowDetailedLogs };

            if (AutoDiscoverServer)
            {
                AutoDiscoverInit();
            }
            else
            {
                ManagerInit(connectOnAwake);
            }
        }

        private void OnEnable()
        {
            Application.logMessageReceived += OnLogReceived;
        }

        private void LateUpdate()
        {
            if (isTryingToFindServer)
            {
                AutoDiscoverUpdate();
            }

            if (Manager != null)
            {
                // Update the Sharing Manager to processes any network messages that have arrived.
                Manager.Update();
            }
        }

        private void OnDisable()
        {
            Application.logMessageReceived -= OnLogReceived;
        }

        protected override void OnDestroy()
        {
            if (discoveryClient != null)
            {
                discoveryClient.RemoveListener(discoveryClientAdapter);
                discoveryClient.Dispose();
                discoveryClient = null;

                if (discoveryClientAdapter != null)
                {
                    discoveryClientAdapter.Dispose();
                    discoveryClientAdapter = null;
                }
            }

            if (SessionUsersTracker != null)
            {
                SessionUsersTracker.Dispose();
                SessionUsersTracker = null;
            }

            if (SessionsTracker != null)
            {
                SessionsTracker.Dispose();
                SessionsTracker = null;
            }

            if (Connection != null)
            {
                Connection.RemoveListener((byte)MessageID.StatusOnly, networkConnectionAdapter);
                Connection.Dispose();

                if (networkConnectionAdapter != null)
                {
                    networkConnectionAdapter.Dispose();
                    networkConnectionAdapter = null;
                }
            }

            if (Manager != null)
            {
                // Force a disconnection so that we can stop and start Unity without connections hanging around.
                Manager.GetPairedConnection().Disconnect();
                Manager.GetServerConnection().Disconnect();
                Manager.Dispose();
                Manager = null;
            }

            // Forces a garbage collection to try to clean up any additional reference to SWIG-wrapped objects.
            GC.Collect();

            base.OnDestroy();
        }

        #endregion // Unity Methods

        #region Event Callbacks

        private void OnNetworkConnectionChanged(NetworkConnection networkConnection)
        {
            if (IsConnected)
            {
                if (SharingManagerConnected != null)
                {
                    SharingManagerConnected(this, EventArgs.Empty);
                }
            }
            else
            {
                if (SharingManagerDisconnected != null)
                {
                    SharingManagerDisconnected(this, EventArgs.Empty);
                }
            }
        }

        private void OnSystemDiscovered(DiscoveredSystem system)
        {
            if (system.GetRole() != SystemRole.SessionDiscoveryServerRole) { return; }

            // Found a server. Stop pinging the network and connect.
            discoveryClientAdapter.DiscoveredEvent -= OnSystemDiscovered;
            isTryingToFindServer = false;
            ServerAddress = system.GetAddress();

            if (ShowDetailedLogs)
            {
                Debug.Log("Server discovered at: " + ServerAddress);
            }

            ManagerInit(true);

            if (ShowDetailedLogs)
            {
                Debug.LogFormat("Connected to: {0}:{1}", ServerAddress, ServerPort.ToString());
            }
        }

        private void OnLogReceived(string logString, string stackTrace, LogType type)
        {
            switch (type)
            {
                case LogType.Error:
                case LogType.Assert:
                case LogType.Exception:
                    Log.Error(string.Format("{0} \n {1}", logString, stackTrace));
                    break;

                case LogType.Warning:
                    Log.Warning(string.Format("{0} \n {1}", logString, stackTrace));
                    break;

                case LogType.Log:
                    if (ShowDetailedLogs)
                    {
                        Log.Info(logString);
                    }
                    break;
                default:
                    throw new ArgumentOutOfRangeException("type", type, "Invalid Message Type");
            }
        }

        #endregion // Event Callbacks

        private void ManagerInit(bool setConnection)
        {
            var config = new ClientConfig(ClientRole);
            config.SetIsAudioEndpoint(IsAudioEndpoint);
            config.SetLogWriter(logWriter);

            if (setConnection)
            {
                config.SetServerAddress(ServerAddress);
                config.SetServerPort(ServerPort);
            }

            Manager = SharingManager.Create(config);

            // Set up callbacks so that we know when we've connected successfully.
            networkConnectionAdapter = new NetworkConnectionAdapter();
            networkConnectionAdapter.ConnectedCallback += OnNetworkConnectionChanged;
            networkConnectionAdapter.DisconnectedCallback += OnNetworkConnectionChanged;
            Connection.AddListener((byte)MessageID.StatusOnly, networkConnectionAdapter);

            SyncStateListener = new SyncStateListener();
            Manager.RegisterSyncListener(SyncStateListener);

            Root = new SyncRoot(Manager.GetRootSyncObject());

            SessionsTracker = new ServerSessionsTracker(Manager.GetSessionManager());
            SessionUsersTracker = new SessionUsersTracker(SessionsTracker);

            RoomManagerAdapter = new RoomManagerAdapter();

            CurrentRoomManager.AddListener(RoomManagerAdapter);

            using (var userName = new XString(DefaultUserName))
            {
#if UNITY_WSA && !UNITY_EDITOR
                Manager.SetUserName(SystemInfo.deviceName);
#else
                if (!string.IsNullOrEmpty(Environment.UserName))
                {
                    Manager.SetUserName(Environment.UserName);
                }
                else
                {
                    User localUser = Manager.GetLocalUser();
                    Manager.SetUserName(userName + localUser.GetID().ToString());
                }
#endif
            }
        }

        private void AutoDiscoverInit()
        {
            if (ShowDetailedLogs)
            {
                Debug.Log("Looking for servers...");
            }

            discoveryClientAdapter = new DiscoveryClientAdapter();
            discoveryClientAdapter.DiscoveredEvent += OnSystemDiscovered;

            discoveryClient = DiscoveryClient.Create();
            discoveryClient.AddListener(discoveryClientAdapter);

            // Start Finding Server.
            isTryingToFindServer = true;
        }

        private void AutoDiscoverUpdate()
        {
            // Searching Enabled-> Update DiscoveryClient to check results, Wait Interval then Ping network.
            pingIntervalCurrent += Time.deltaTime;
            if (pingIntervalCurrent > PingIntervalSec)
            {
                if (ShowDetailedLogs)
                {
                    Debug.Log("Looking for servers...");
                }

                pingIntervalCurrent = 0;
                discoveryClient.Ping();
            }

            discoveryClient.Update();
        }

        public void ConnectToServer(string serverAddress, int port)
        {
            ServerAddress = serverAddress;
            ServerPort = port;
            ConnectToServer();
        }

        public void ConnectToServer()
        {
            SessionsTracker.LeaveCurrentSession();
            Manager.SetServerConnectionInfo(ServerAddress, (uint)ServerPort);
        }
    }
}