Generate valid machine id

Runtime/Common/GuidHelper.cs

@@ -1,4 +1,6 @@
 using System;
+using System.Security.Cryptography;
+using System.Text;
 
 namespace Backtrace.Unity.Extensions
 {
@@ -23,5 +25,20 @@ public static bool IsNullOrEmpty(string guid)
             const string emptyGuid = "00000000-0000-0000-0000-000000000000";
             return string.IsNullOrEmpty(guid) || guid == emptyGuid;
         }
+
+        /// <summary>
+        /// Converts a random string into a guid representation.
+        /// </summary>
+        public static Guid FromString(string value)
+        {
+            if (string.IsNullOrEmpty(value))
+            {
+                return Guid.Empty;
+            }
+            // to make sure we're supporting old version of Unity that can use .NET 3.5 
+            // we're using an older API to generate a GUID.
+            MD5 md5 = new MD5CryptoServiceProvider();
+            return new Guid(md5.ComputeHash(Encoding.UTF8.GetBytes(value)));
+        }
     }
 }

Runtime/Model/Attributes/MachineAttributeProvider.cs

@@ -1,5 +1,4 @@
 using Backtrace.Unity.Common;
-using Backtrace.Unity.Extensions;
 using System;
 using System.Collections.Generic;
 using System.Globalization;

Runtime/Model/DataProvider/IMachineIdentifierDataProvider.cs

@@ -0,0 +1,8 @@
+[assembly: System.Runtime.CompilerServices.InternalsVisibleTo("Backtrace.Unity.Tests.Runtime")]
+namespace Backtrace.Unity.Model.DataProvider
+{
+    internal interface IMachineIdentifierDataProvider
+    {
+        string Get();
+    }
+}

Runtime/Model/DataProvider/ISessionStorageDataProvider.cs

@@ -0,0 +1,9 @@
+[assembly: System.Runtime.CompilerServices.InternalsVisibleTo("Backtrace.Unity.Tests.Runtime")]
+namespace Backtrace.Unity.Model.DataProvider
+{
+    internal interface ISessionStorageDataProvider
+    {
+        void SetString(string key, string value);
+        string GetString(string key);
+    }
+}

Runtime/Model/DataProvider/NetworkIdentifierDataProvider.cs

@@ -0,0 +1,35 @@
+using Backtrace.Unity.Extensions;
+using System;
+using System.Linq;
+using System.Net.NetworkInformation;
+
+namespace Backtrace.Unity.Model.DataProvider
+{
+    internal class NetworkIdentifierDataProvider : IMachineIdentifierDataProvider
+    {
+        public string Get()
+        {
+            var interfaces = NetworkInterface.GetAllNetworkInterfaces()
+               .Where(n => n.OperationalStatus == OperationalStatus.Up);
+
+            foreach (var @interface in interfaces)
+            {
+                var physicalAddress = @interface.GetPhysicalAddress();
+                if (physicalAddress == null)
+                {
+                    continue;
+                }
+                var macAddress = physicalAddress.ToString();
+                if (string.IsNullOrEmpty(macAddress))
+                {
+                    continue;
+                }
+                string hex = macAddress.Replace(":", string.Empty);
+                var value = Convert.ToInt64(hex, 16);
+                return GuidHelper.FromLong(value).ToString();
+            }
+
+            return null;
+        }
+    }
+}

Runtime/Model/DataProvider/SessionStorageDataProvider.cs

@@ -0,0 +1,17 @@
+using UnityEngine;
+
+namespace Backtrace.Unity.Model.DataProvider
+{
+    internal class SessionStorageDataProvider : ISessionStorageDataProvider
+    {
+        public string GetString(string key)
+        {
+            return PlayerPrefs.GetString(key);
+        }
+
+        public void SetString(string key, string value)
+        {
+            PlayerPrefs.SetString(key, value);
+        }
+    }
+}

Runtime/Model/DataProvider/UnityMachineIdentifierProvider.cs

@@ -0,0 +1,37 @@
+using Backtrace.Unity.Extensions;
+using System;
+using System.Linq;
+using System.Net.NetworkInformation;
+using UnityEngine;
+
+namespace Backtrace.Unity.Model.DataProvider
+{
+    internal class UnityMachineIdentifierProvider : IMachineIdentifierDataProvider
+    {
+        private readonly string _deviceUniqueIdentifier;
+        internal UnityMachineIdentifierProvider() : this(SystemInfo.deviceUniqueIdentifier) { }
+
+        internal UnityMachineIdentifierProvider(string machineIdentifier)
+        {
+            _deviceUniqueIdentifier = machineIdentifier;
+        }
+        public string Get()
+        {
+            if (!IsValidIdentifier())
+            {
+                return null;
+            }
+
+            if (Guid.TryParse(_deviceUniqueIdentifier, out Guid unityUuidGuid))
+            {
+                return unityUuidGuid.ToString();
+            }
+            return GuidHelper.FromString(_deviceUniqueIdentifier).ToString();
+        }
+
+        private bool IsValidIdentifier()
+        {
+            return _deviceUniqueIdentifier != SystemInfo.unsupportedIdentifier && !string.IsNullOrEmpty(_deviceUniqueIdentifier);
+        }
+    }
+}

Runtime/Model/MachineIdStorage.cs

@@ -1,8 +1,6 @@
 using Backtrace.Unity.Extensions;
+using Backtrace.Unity.Model.DataProvider;
 using System;
-using System.Linq;
-using System.Net.NetworkInformation;
-using UnityEngine;
 
 [assembly: System.Runtime.CompilerServices.InternalsVisibleTo("Backtrace.Unity.Tests.Runtime")]
 namespace Backtrace.Unity.Model
@@ -17,6 +15,19 @@ internal class MachineIdStorage
         /// </summary>
         internal const string MachineIdentifierKey = "backtrace-machine-id";
 
+        private readonly ISessionStorageDataProvider _sessionStorageDataProvider;
+        private readonly IMachineIdentifierDataProvider[] _machineIdentifierDataProviders;
+
+        internal MachineIdStorage() : this(
+            new IMachineIdentifierDataProvider[] { new UnityMachineIdentifierProvider(), new NetworkIdentifierDataProvider() },
+            new SessionStorageDataProvider())
+        { }
+        internal MachineIdStorage(IMachineIdentifierDataProvider[] machineIdentifierDataProviders, ISessionStorageDataProvider sessionStorageDataProvider)
+        {
+            _machineIdentifierDataProviders = machineIdentifierDataProviders;
+            _sessionStorageDataProvider = sessionStorageDataProvider;
+        }
+
         /// <summary>
         /// Generate unique machine id. 
         /// </summary>
@@ -30,17 +41,14 @@ internal string GenerateMachineId()
             }
 
 #if !UNITY_WEBGL && !UNITY_SWITCH
-            var unityIdentifier = UseUnityIdentifier();
-            if (!GuidHelper.IsNullOrEmpty(unityIdentifier))
+            foreach (var machineIdentifierProvider in _machineIdentifierDataProviders)
             {
-                StoreMachineId(unityIdentifier);
-                return unityIdentifier;
-            }
-            var networkIdentifier = UseNetworkingIdentifier();
-            if (!GuidHelper.IsNullOrEmpty(networkIdentifier))
-            {
-                StoreMachineId(networkIdentifier);
-                return networkIdentifier;
+                var identifier = machineIdentifierProvider.Get();
+                if (!GuidHelper.IsNullOrEmpty(identifier))
+                {
+                    StoreMachineId(identifier);
+                    return identifier;
+                }
             }
 #endif
             var backtraceRandomIdentifier = Guid.NewGuid().ToString();
@@ -55,7 +63,17 @@ internal string GenerateMachineId()
         /// <returns>machine identifier in the GUID string format</returns>
         private string FetchMachineIdFromStorage()
         {
-            return PlayerPrefs.GetString(MachineIdentifierKey);
+            var storedMachineId = _sessionStorageDataProvider.GetString(MachineIdentifierKey);
+            // in the previous version of the SDK, the stored machine id could be invalid
+            // to fix the problem, we want to verify if the id is valid and if isn't, fix it.
+            if (string.IsNullOrEmpty(storedMachineId) || Guid.TryParse(storedMachineId, out Guid _))
+            {
+                return storedMachineId;
+            }
+
+            var machineId = GuidHelper.FromString(storedMachineId).ToString();
+            StoreMachineId(machineId);
+            return machineId;
         }
 
         /// <summary>
@@ -64,49 +82,7 @@ private string FetchMachineIdFromStorage()
         /// <param name="machineId">machine identifier</param>
         private void StoreMachineId(string machineId)
         {
-            PlayerPrefs.SetString(MachineIdentifierKey, machineId);
-        }
-
-        /// <summary>
-        /// Use Unity device identifier to generate machine identifier
-        /// </summary>
-        /// <returns>Unity machine identifier if the device identifier is supported. Otherwise null</returns>
-        protected virtual string UseUnityIdentifier()
-        {
-            if (SystemInfo.deviceUniqueIdentifier == SystemInfo.unsupportedIdentifier)
-            {
-                return null;
-            }
-            return SystemInfo.deviceUniqueIdentifier;
-        }
-
-        /// <summary>
-        /// Use Networking interface to generate machine identifier - MAC number from the networking interface.
-        /// </summary>
-        /// <returns>Machine id - MAC in a GUID format. If the networking interface is not available then it returns null.</returns>
-        protected virtual string UseNetworkingIdentifier()
-        {
-            var interfaces = NetworkInterface.GetAllNetworkInterfaces()
-                .Where(n => n.OperationalStatus == OperationalStatus.Up);
-
-            foreach (var @interface in interfaces)
-            {
-                var physicalAddress = @interface.GetPhysicalAddress();
-                if (physicalAddress == null)
-                {
-                    continue;
-                }
-                var macAddress = physicalAddress.ToString();
-                if (string.IsNullOrEmpty(macAddress))
-                {
-                    continue;
-                }
-                string hex = macAddress.Replace(":", string.Empty);
-                var value = Convert.ToInt64(hex, 16);
-                return GuidHelper.FromLong(value).ToString();
-            }
-
-            return null;
+            _sessionStorageDataProvider.SetString(MachineIdentifierKey, machineId);
         }
     }
 }