update

Making adjustments based on peer review of this branch's PR.

Author: NoelStephensUnity

com.unity.netcode.gameobjects/Runtime/Connection/NetworkConnectionManager.cs

@@ -1459,7 +1459,6 @@ internal void Initialize(NetworkManager networkManager)
                 Transport.NetworkMetrics = NetworkManager.MetricsManager.NetworkMetrics;
                 Transport.OnTransportEvent += HandleNetworkEvent;
                 Transport.Initialize(networkManager);
-                Transport.CreateDisconnectEventMap();
             }
         }
 
@@ -1470,9 +1469,9 @@ internal void Shutdown()
         {
             if (Transport && IsListening)
             {
+                Transport.ShuttingDown();
                 var clientId = NetworkManager ? NetworkManager.LocalClientId : NetworkManager.ServerClientId;
                 var transportId = ClientIdToTransportId(clientId);
-                Transport.SetDisconnectEvent(NetworkTransport.DisconnectEvents.TransportShutdown);
                 GenerateDisconnectInformation(clientId, transportId, $"{nameof(NetworkConnectionManager)} was shutdown.");
             }
 
@@ -1526,7 +1525,6 @@ internal void Shutdown()
                 try
                 {
                     Transport?.DisconnectLocalClient();
-                    Transport?.CleanDisconnectEventMap();
                 }
                 catch (Exception ex)
                 {
@@ -1556,7 +1554,6 @@ internal void Shutdown()
                 var transport = NetworkManager.NetworkConfig?.NetworkTransport;
                 if (transport != null)
                 {
-                    transport.CleanDisconnectEventMap();
                     transport.Shutdown();
                     if (NetworkManager.LogLevel <= LogLevel.Developer)
                     {

com.unity.netcode.gameobjects/Runtime/Transports/NetworkTransport.cs

@@ -1,5 +1,4 @@
 using System;
-using System.Collections.Generic;
 using UnityEngine;
 
 namespace Unity.Netcode
@@ -172,7 +171,7 @@ internal NetworkTopologyTypes CurrentTopology()
         /// <remarks>
         /// <see cref="AddDisconnectEventMap"/> provides you with the ability to register the transport's disconnect event types with the local equivalent.
         /// </remarks>
-        public enum DisconnectEvents : byte
+        public enum DisconnectEvents
         {
             /// <summary>
             /// If transport has mapped its disconnect events, this event signifies that the transport closed the connection due to a locally invoked shutdown.
@@ -219,98 +218,52 @@ public enum DisconnectEvents : byte
         /// </summary>
         public string DisconnectEventMessage { get; private set; }
 
-        private Dictionary<byte, DisconnectEvents> m_DisconnectEventMap = new Dictionary<byte, DisconnectEvents>();
-        private Dictionary<DisconnectEvents, string> m_DisconnectEventMessageMap = new Dictionary<DisconnectEvents, string>();
-
         /// <summary>
         /// This should be invoked by the <see cref="NetworkTransport"/> derived class when a transport level disconnect event occurs.<br />
-        /// If there is a map for the specific transport event id, then <see cref="DisconnectEvent"/> will be set to the equivalent <see cref="DisconnectEvents"/> value.
+        /// It is up to the <see cref="NetworkTransport"/> derived class to create a map between the transport's disconnect events and the
+        /// pre-defined <see cref="DisconnectEvents"/> enum values.
         /// </summary>
-        /// <param name="disconnectEventId">The transport's disconnect event identifer.</param>
-        /// <param name="messageOverride">Optional message to override any existing registered one for the transport specific disconnection event identifier.</param>
-        public void SetDisconnectEvent(byte disconnectEventId, string messageOverride = null)
-        {
-            if (m_DisconnectEventMap.ContainsKey(disconnectEventId))
-            {
-                DisconnectEvent = m_DisconnectEventMap[disconnectEventId];
-            }
-            else // If there are no maps, then this will always report just disconnected.
-            {
-                DisconnectEvent = DisconnectEvents.Disconnected;
-            }
-            DisconnectEventMessage = string.Empty;
-            if (messageOverride != null)
-            {
-                DisconnectEventMessage = messageOverride;
-            }
-            else if (m_DisconnectEventMessageMap.ContainsKey(DisconnectEvent))
-            {
-                DisconnectEventMessage = m_DisconnectEventMessageMap[DisconnectEvent];
-            }
-        }
-
-        internal void SetDisconnectEvent(DisconnectEvents disconnectEvent, string message = null)
+        /// <param name="disconnectEvent">The <see cref="DisconnectEvents"/> type to set.</param>
+        /// <param name="message">An optional message override.</param>
+        protected void SetDisconnectEvent(DisconnectEvents disconnectEvent, string message = null)
         {
             DisconnectEvent = disconnectEvent;
             DisconnectEventMessage = string.Empty;
+
             if (message != null)
             {
                 DisconnectEventMessage = message;
             }
-            else if (m_DisconnectEventMessageMap.ContainsKey(disconnectEvent))
+            else
             {
-                DisconnectEventMessage = m_DisconnectEventMessageMap[disconnectEvent];
+                DisconnectEventMessage = OnGetDisconnectEventMessage(disconnectEvent);
             }
         }
 
         /// <summary>
-        /// Adds a map between the <see cref="DisconnectEvents"/> value and the transports equivalent event identifier.
+        /// Override this method to provide additional information about the disconnection event.
         /// </summary>
-        /// <param name="disconnectEvents">The <see cref="DisconnectEvents"/> value to be mapped.</param>
-        /// <param name="targetEventId">The transport's equivalent event identifier value.</param>
-        /// <param name="message">Optional message to use for this disconnect event.</param>
-        protected void AddDisconnectEventMap(DisconnectEvents disconnectEvents, byte targetEventId, string message = null)
+        /// <param name="disconnectEvent">The disconnect event to get from the <see cref="NetworkTransport"/> derived class.</param>
+        /// <returns><see cref="string.Empty"/> as a default or if overridden the <see cref="string"/> returned.</returns>
+        protected virtual string OnGetDisconnectEventMessage(DisconnectEvents disconnectEvent)
         {
-            if (!m_DisconnectEventMap.ContainsKey(targetEventId))
-            {
-                m_DisconnectEventMap.Add(targetEventId, disconnectEvents);
-            }
-
-            if (message != null && !m_DisconnectEventMessageMap.ContainsKey(disconnectEvents))
-            {
-                m_DisconnectEventMessageMap.Add(disconnectEvents, message);
-            }
+            return string.Empty;
         }
 
         /// <summary>
-        /// Override this method to create a disconnect event mapping table that will translate the transport's equivalent for each enum in <see cref="DisconnectEvents"/>.<br />
-        /// This method is invoked during <see cref="NetworkConnectionManager.Initialize(NetworkManager)"/> just after <see cref="Initialize(NetworkManager)"/> has been invoked.
+        /// Invoked when the local <see cref="NetworkManager"/> forces the transport to close a remote connection.
         /// </summary>
-        /// <remarks>
-        /// You can use <see cref="AddDisconnectEventMap"/> to register a map between <see cref="DisconnectEvents"/> and the transport's disconnect event equivalent.
-        /// </remarks>
-        protected virtual void OnCreateDisconnectEventMap()
-        {
-
-        }
-
-        internal void CreateDisconnectEventMap()
-        {
-            DisconnectEvent = DisconnectEvents.Disconnected;
-            DisconnectEventMessage = string.Empty;
-            OnCreateDisconnectEventMap();
-        }
-
-        internal void CleanDisconnectEventMap()
+        internal void ClosingRemoteConnection()
         {
-            DisconnectEvent = DisconnectEvents.Disconnected;
-            m_DisconnectEventMap.Clear();
-            m_DisconnectEventMessageMap.Clear();
+            SetDisconnectEvent(DisconnectEvents.ClosedRemoteConnection);
         }
 
-        internal void ClosingRemoteConnection()
+        /// <summary>
+        /// Invoked just before the transport is shutdown.
+        /// </summary>
+        internal void ShuttingDown()
         {
-            SetDisconnectEvent(DisconnectEvents.ClosedRemoteConnection);
+            SetDisconnectEvent(DisconnectEvents.TransportShutdown);
         }
     }
 

com.unity.netcode.gameobjects/Runtime/Transports/UTP/UnityTransport.cs

@@ -1058,7 +1058,8 @@ private bool ProcessEvent()
                         }
 
                         // Set the disconnect event error code
-                        SetDisconnectEvent(reader.ReadByte());
+                        var errorCode = m_UnityTransportNotificationHandler.GetDisconnectEvent(reader.ReadByte());
+                        SetDisconnectEvent(errorCode);
 
                         m_ServerClientId = default;
                         m_ReliableReceiveQueues.Remove(clientId);
@@ -1369,37 +1370,6 @@ public override void DisconnectRemoteClient(ulong clientId)
             }
         }
 
-        private const byte k_ClosedRemoteConnection = 128;
-        private const byte k_TransportShutdown = 129;
-
-        internal const string DisconnectedMessage = "Gracefully disconnected.";
-        internal const string TimeoutMessage = "Connection closed due to timed out.";
-        internal const string MaxConnectionAttemptsMessage = "Connection closed due to maximum connection attempts reached.";
-        internal const string ClosedByRemoteMessage = "Connection was closed by remote endpoint.";
-        internal const string AuthenticationFailureMessage = "Connection closed due to authentication failure.";
-        internal const string ProtocolErrorMessage = "Gracefully disconnected.";
-        internal const string ClosedRemoteConnectionMessage = "Local transport closed the remote endpoint connection.";
-        internal const string TransportShutdownMessage = "The transport was shutdown.";
-
-        /// <inheritdoc/>
-        protected override void OnCreateDisconnectEventMap()
-        {
-            // Implemented in UTP
-
-            AddDisconnectEventMap(DisconnectEvents.Disconnected, (byte)DisconnectReason.Default, DisconnectedMessage);
-            AddDisconnectEventMap(DisconnectEvents.ProtocolTimeout, (byte)DisconnectReason.Timeout, TimeoutMessage);
-            AddDisconnectEventMap(DisconnectEvents.MaxConnectionAttempts, (byte)DisconnectReason.MaxConnectionAttempts, MaxConnectionAttemptsMessage);
-            AddDisconnectEventMap(DisconnectEvents.ClosedByRemote, (byte)DisconnectReason.ClosedByRemote, ClosedByRemoteMessage);
-            AddDisconnectEventMap(DisconnectEvents.AuthenticationFailure, (byte)DisconnectReason.AuthenticationFailure, AuthenticationFailureMessage);
-            AddDisconnectEventMap(DisconnectEvents.ProtocolError, (byte)DisconnectReason.ProtocolError, ProtocolErrorMessage);
-
-            // Not implemented in UTP
-            AddDisconnectEventMap(DisconnectEvents.ClosedRemoteConnection, k_ClosedRemoteConnection, ClosedRemoteConnectionMessage);
-            AddDisconnectEventMap(DisconnectEvents.TransportShutdown, k_TransportShutdown, TransportShutdownMessage);
-
-            base.OnCreateDisconnectEventMap();
-        }
-
         /// <summary>
         /// Gets the current RTT for a specific client
         /// </summary>
@@ -1449,30 +1419,6 @@ public NetworkEndpoint GetEndpoint(ulong clientId)
             return new NetworkEndpoint();
         }
 
-        /// <summary>
-        /// Initializes the transport
-        /// </summary>
-        /// <param name="networkManager">The NetworkManager that initialized and owns the transport</param>
-        public override void Initialize(NetworkManager networkManager = null)
-        {
-#if DEBUG
-            if (sizeof(ulong) != UnsafeUtility.SizeOf<NetworkConnection>())
-            {
-                Debug.LogWarning($"Netcode connection id size {sizeof(ulong)} does not match UTP connection id size {UnsafeUtility.SizeOf<NetworkConnection>()}!");
-                return;
-            }
-#endif
-
-            m_NetworkManager = networkManager;
-
-            if (m_NetworkManager && m_NetworkManager.PortOverride.Overidden)
-            {
-                ConnectionData.Port = m_NetworkManager.PortOverride.Value;
-            }
-
-            m_RealTimeProvider = m_NetworkManager ? m_NetworkManager.RealTimeProvider : new RealTimeProvider();
-        }
-
         /// <summary>
         /// Polls for incoming events, with an extra output parameter to report the precise time the event was received.
         /// </summary>
@@ -1626,6 +1572,39 @@ public override bool StartServer()
             return succeeded;
         }
 
+        private UnityTransportNotificationHandler m_UnityTransportNotificationHandler;
+
+        /// <inheritdoc/>
+        protected override string OnGetDisconnectEventMessage(DisconnectEvents disconnectEvent)
+        {
+            return m_UnityTransportNotificationHandler.GetDisconnectEventMessage(disconnectEvent);
+        }
+
+        /// <summary>
+        /// Initializes the transport
+        /// </summary>
+        /// <param name="networkManager">The NetworkManager that initialized and owns the transport</param>
+        public override void Initialize(NetworkManager networkManager = null)
+        {
+#if DEBUG
+            if (sizeof(ulong) != UnsafeUtility.SizeOf<NetworkConnection>())
+            {
+                Debug.LogWarning($"Netcode connection id size {sizeof(ulong)} does not match UTP connection id size {UnsafeUtility.SizeOf<NetworkConnection>()}!");
+                return;
+            }
+#endif
+
+            m_NetworkManager = networkManager;
+
+            if (m_NetworkManager && m_NetworkManager.PortOverride.Overidden)
+            {
+                ConnectionData.Port = m_NetworkManager.PortOverride.Value;
+            }
+
+            m_RealTimeProvider = m_NetworkManager ? m_NetworkManager.RealTimeProvider : new RealTimeProvider();
+            m_UnityTransportNotificationHandler = new UnityTransportNotificationHandler();
+        }
+
         /// <summary>
         /// Shuts down the transport
         /// </summary>
@@ -1663,6 +1642,8 @@ public override void Shutdown()
 
             // We must reset this to zero because UTP actually re-uses clientIds if there is a clean disconnect
             m_ServerClientId = default;
+
+            m_UnityTransportNotificationHandler = null;
         }
 
         /// <inheritdoc cref="NetworkTransport.OnCurrentTopology"/>
@@ -1849,4 +1830,67 @@ internal static FixedString128Bytes ErrorToFixedString(int error)
             }
         }
     }
+
+    /// <summary>
+    /// Handles mapping <see cref="DisconnectReason"/> to <see cref="NetworkTransport.DisconnectEvents"/> as well
+    /// as mapping additional disconnect event message information to each <see cref="NetworkTransport.DisconnectEvents"/>.
+    /// </summary>
+    internal class UnityTransportNotificationHandler
+    {
+        private const int k_ClosedRemoteConnection = 128;
+        private const int k_TransportShutdown = 129;
+
+        internal const string DisconnectedMessage = "Gracefully disconnected.";
+        internal const string TimeoutMessage = "Connection closed due to timed out.";
+        internal const string MaxConnectionAttemptsMessage = "Connection closed due to maximum connection attempts reached.";
+        internal const string ClosedByRemoteMessage = "Connection was closed by remote endpoint.";
+        internal const string AuthenticationFailureMessage = "Connection closed due to authentication failure.";
+        internal const string ProtocolErrorMessage = "Gracefully disconnected.";
+        internal const string ClosedRemoteConnectionMessage = "Local transport closed the remote endpoint connection.";
+        internal const string TransportShutdownMessage = "The transport was shutdown.";
+
+        private Dictionary<int, NetworkTransport.DisconnectEvents> m_DisconnectEventMap = new Dictionary<int, NetworkTransport.DisconnectEvents>();
+        private Dictionary<NetworkTransport.DisconnectEvents, string> m_DisconnectEventMessageMap = new Dictionary<NetworkTransport.DisconnectEvents, string>();
+
+        internal NetworkTransport.DisconnectEvents GetDisconnectEvent(int disconnectEventId)
+        {
+            return m_DisconnectEventMap.ContainsKey(disconnectEventId) ? m_DisconnectEventMap[disconnectEventId] : NetworkTransport.DisconnectEvents.Disconnected;
+        }
+
+        public string GetDisconnectEventMessage(NetworkTransport.DisconnectEvents disconnectEvent)
+        {
+            return string.Empty;
+        }
+
+        public void ClosingRemoteConnection()
+        {
+
+        }
+
+        private void AddDisconnectEventMap(NetworkTransport.DisconnectEvents disconnectEvent, int disconnectReason, string message)
+        {
+            m_DisconnectEventMap.Add(disconnectReason, disconnectEvent);
+            m_DisconnectEventMessageMap.Add(disconnectEvent, message);
+        }
+
+        private void AddDisconnectEventMap(NetworkTransport.DisconnectEvents disconnectEvent, DisconnectReason disconnectReason, string message)
+        {
+            AddDisconnectEventMap(disconnectEvent, (int)disconnectReason, message);
+        }
+
+        public UnityTransportNotificationHandler()
+        {
+            // Implemented in UTP
+            AddDisconnectEventMap(NetworkTransport.DisconnectEvents.Disconnected, DisconnectReason.Default, DisconnectedMessage);
+            AddDisconnectEventMap(NetworkTransport.DisconnectEvents.ProtocolTimeout, DisconnectReason.Timeout, TimeoutMessage);
+            AddDisconnectEventMap(NetworkTransport.DisconnectEvents.MaxConnectionAttempts, DisconnectReason.MaxConnectionAttempts, MaxConnectionAttemptsMessage);
+            AddDisconnectEventMap(NetworkTransport.DisconnectEvents.ClosedByRemote, DisconnectReason.ClosedByRemote, ClosedByRemoteMessage);
+            AddDisconnectEventMap(NetworkTransport.DisconnectEvents.AuthenticationFailure, DisconnectReason.AuthenticationFailure, AuthenticationFailureMessage);
+            AddDisconnectEventMap(NetworkTransport.DisconnectEvents.ProtocolError, DisconnectReason.ProtocolError, ProtocolErrorMessage);
+
+            // Not implemented in UTP
+            AddDisconnectEventMap(NetworkTransport.DisconnectEvents.ClosedRemoteConnection, k_ClosedRemoteConnection, ClosedRemoteConnectionMessage);
+            AddDisconnectEventMap(NetworkTransport.DisconnectEvents.TransportShutdown, k_TransportShutdown, TransportShutdownMessage);
+        }
+    }
 }