feat!: pass result to callback (#91)

* feat!: pass result to callback

BREAKING CHANGE: changes public interface for Post callbacks

* fix: build error for IExceptionReporter implementation

* fix: sharing violation attaching editor and user logs

* fix: don't skip posting first report

* fix: don't attempt to post with destroyed game object (#92)

* fix: don't attempt to post with destroyed game object

* fix: windows build

* fix: updated sample

* feat: add support response to sample

* fix: open web browser on linux

* fix: invoke callback in webgl

* fix: remove support response from webgl

* chore: update readme

* chore: update README.md

Author: bobbyg603

README.md

@@ -196,6 +196,69 @@ bugsplat.ShouldPostException = (ex) =>
 };
 ```
 
+### Support Response
+
+BugSplat has the ability to display a support response to users who encounter a crash. You can show your users a generalized support response for all crashes, or a custom support response that corresponds to the type of crash that occurred. Defining a support response allows you to alert users that bug has been fixed in a new version, or that they need to update their graphics drivers.
+
+Next, pass a callback to `bugsplat.Post`. In the callback handler add code to open the support response in the user's browser. A full example can be seen in [ErrorGenerator.cs](https://github.com/BugSplat-Git/bugsplat-unity/blob/main/Samples~/my-unity-crasher/Scripts/ErrorGenerator.cs).
+
+```cs
+private string infoUrl = "";
+
+public void Event_CatchExceptionThenPostNewBugSplat()
+{
+    try
+    {
+        GenerateSampleStackFramesAndThrow();
+    }
+    catch (Exception ex)
+    {
+        var options = new ReportPostOptions()
+        {
+            Description = "a new description"
+        };
+
+        StartCoroutine(bugsplat.Post(ex, options, ExceptionCallback));
+    }
+}
+
+void ExceptionCallback(ExceptionReporterPostResult result)
+{
+    UnityEngine.Debug.Log($"Exception post callback result: {result.Message}");
+
+    if (result.Response == null) {
+        return;
+    }
+
+    UnityEngine.Debug.Log($"BugSplat Status: {result.Response.status}");
+    UnityEngine.Debug.Log($"BugSplat Crash ID: {result.Response.crashId}");
+    UnityEngine.Debug.Log($"BugSplat Support URL: {result.Response.infoUrl}");
+
+    infoUrl = result.Response.infoUrl;
+}
+
+private void OpenUrl(string url)
+{
+    var escaped = url.Replace("?", "\\?").Replace("&", "\\&").Replace(" ", "%20").Replace("!", "\\!");
+
+#if UNITY_STANDALONE_WIN || UNITY_EDITOR_WIN || UNITY_WSA
+    Process.Start(url);
+#elif UNITY_STANDALONE_OSX || UNITY_EDITOR_OSX
+    Process.Start("open", escaped);
+#elif UNITY_STANDALONE_LINUX || UNITY_EDITOR_LINUX
+    Process.Start("xdg-open", escaped);
+#else
+    UnityEngine.Debug.Log($"OpenUrl unsupported platform: {Application.platform}");
+#endif
+}
+```
+
+When an exception occurs, a page similar to the following will open in the user's browser on Windows, macOS, and Linux.
+
+<img width="1086" alt="image" src="https://github.com/user-attachments/assets/3a3d6f82-e3bf-42bc-ae7f-582ba35cd499">
+
+More information on support responses can be found [here](https://docs.bugsplat.com/introduction/production/setting-up-custom-support-responses).
+
 ## 🪟 Windows
 
 BugSplat can be configured to upload Windows minidumps created by the `UnityCrashHandler`. BugSplat will automatically pull Unity Player symbols from the [Unity Symbol Server](https://docs.unity3d.com/Manual/WindowsDebugging.html). If your game contains Native Windows C++ plugins, `.dll` and `.pdb` files in the `Assets/Plugins/x86` and `Assets/Plugins/x86_64` folders will be uploaded by BugSplat's PostBuild script and used in symbolication.

Runtime/BugSplat.cs

@@ -6,7 +6,6 @@
 using System.Collections;
 using System.Collections.Generic;
 using System.IO;
-using System.Linq;
 using System.Net.Http;
 using System.Runtime.CompilerServices;
 #if UNITY_IOS && !UNITY_EDITOR
@@ -201,28 +200,23 @@ bool useNativeLibAndroid
                 throw new ArgumentException("BugSplat error: version cannot be null or empty");
             }
 
-            var gameObject = new GameObject();
-
-#if UNITY_STANDALONE_WIN || UNITY_WSA           
-            var bugsplat = new BugSplatDotNetStandard.BugSplat(database, application, version);
-            bugsplat.MinidumpType = BugSplatDotNetStandard.BugSplat.MinidumpTypeId.UnityNativeWindows;
-            bugsplat.ExceptionType = BugSplatDotNetStandard.BugSplat.ExceptionTypeId.Unity;
+#if UNITY_STANDALONE_WIN || UNITY_WSA        
+            var bugsplat = new BugSplatDotNetStandard.BugSplat(database, application, version)
+            {
+                MinidumpType = BugSplatDotNetStandard.BugSplat.MinidumpTypeId.UnityNativeWindows,
+                ExceptionType = BugSplatDotNetStandard.BugSplat.ExceptionTypeId.Unity
+            };
             var dotNetStandardClientSettings = new DotNetStandardClientSettingsRepository(bugsplat);
             var dotNetStandardClient = new DotNetStandardClient(bugsplat);
-            var dotNetStandardExceptionReporter = DotNetStandardExceptionReporter.Create(dotNetStandardClientSettings, dotNetStandardClient, gameObject);
+            var dotNetStandardExceptionReporter = new DotNetStandardExceptionReporter(dotNetStandardClientSettings, dotNetStandardClient);
             var windowsReporter = new WindowsReporter(dotNetStandardClientSettings, dotNetStandardExceptionReporter, dotNetStandardClient);
-
             clientSettings = dotNetStandardClientSettings;
             exceptionReporter = windowsReporter;
             nativeCrashReporter = windowsReporter;
 #elif UNITY_WEBGL
             var webGLClientSettings = new WebGLClientSettingsRepository();
             var webGLExceptionClient = new WebGLExceptionClient(database, application, version);
-            var webGLReporter = WebGLReporter.Create(
-                webGLClientSettings,
-                webGLExceptionClient,
-                gameObject
-            );
+            var webGLReporter = new WebGLReporter(webGLClientSettings, webGLExceptionClient);
             clientSettings = webGLClientSettings;
             exceptionReporter = webGLReporter;
 #elif UNITY_IOS && !UNITY_EDITOR
@@ -241,13 +235,13 @@ bool useNativeLibAndroid
                 javaClass.CallStatic("initBugSplat", activity, database, application, version);
             }
 
-            UseDotNetHandler(database, application, version, gameObject);
+            UseDotNetHandler(database, application, version);
 #else
-            UseDotNetHandler(database, application, version, gameObject);
+            UseDotNetHandler(database, application, version);
 #endif
         }
 
-        private void UseDotNetHandler(string database, string application, string version, GameObject gameObject)
+        private void UseDotNetHandler(string database, string application, string version)
         {
             var bugsplat = new BugSplatDotNetStandard.BugSplat(database, application, version)
             {
@@ -256,7 +250,7 @@ private void UseDotNetHandler(string database, string application, string versio
             };
             var dotNetStandardClientSettings = new DotNetStandardClientSettingsRepository(bugsplat);
             var dotNetStandardClient = new DotNetStandardClient(bugsplat);
-            var dotNetStandardExceptionReporter = DotNetStandardExceptionReporter.Create(dotNetStandardClientSettings, dotNetStandardClient, gameObject);
+            var dotNetStandardExceptionReporter = new DotNetStandardExceptionReporter(dotNetStandardClientSettings, dotNetStandardClient);
 
             clientSettings = dotNetStandardClientSettings;
             exceptionReporter = dotNetStandardExceptionReporter;
@@ -270,24 +264,27 @@ public static BugSplat CreateFromOptions(BugSplatOptions options)
         {
             var application = string.IsNullOrEmpty(options.Application) ? Application.productName : options.Application;
             var version = string.IsNullOrEmpty(options.Version) ? Application.version : options.Version;
-            
+
+
             var bugSplat = new BugSplat(
                 options.Database,
                 application,
-                version, 
+                version,
+
                 options.UseNativeCrashReportingForIos,
                 options.UseNativeCrashReportingForAndroid
-            );
-
-            bugSplat.Description = options.Description;
-            bugSplat.Email = options.Email;
-            bugSplat.Key = options.Key;
-            bugSplat.Notes = options.Notes;
-            bugSplat.User = options.User;
-            bugSplat.CaptureEditorLog = options.CaptureEditorLog;
-            bugSplat.CapturePlayerLog = options.CapturePlayerLog;
-            bugSplat.CaptureScreenshots = options.CaptureScreenshots;
-            bugSplat.PostExceptionsInEditor = options.PostExceptionsInEditor;
+            )
+            {
+                Description = options.Description,
+                Email = options.Email,
+                Key = options.Key,
+                Notes = options.Notes,
+                User = options.User,
+                CaptureEditorLog = options.CaptureEditorLog,
+                CapturePlayerLog = options.CapturePlayerLog,
+                CaptureScreenshots = options.CaptureScreenshots,
+                PostExceptionsInEditor = options.PostExceptionsInEditor
+            };
 
             if (options.PersistentDataFileAttachmentPaths != null)
 			{
@@ -309,9 +306,9 @@ public static BugSplat CreateFromOptions(BugSplatOptions options)
         /// <param name="logMessage">logMessage provided by logMessageReceived event that will be used as post description</param>
         /// <param name="stackTrace">stackTrace provided by logMessageReceived event</param>
         /// <param name="type">type provided by logMessageReceived event</param>
-        public void LogMessageReceived(string logMessage, string stackTrace, LogType type)
+        public IEnumerator LogMessageReceived(string logMessage, string stackTrace, LogType type)
         {
-            exceptionReporter.LogMessageReceived(logMessage, stackTrace, type);
+            yield return exceptionReporter.LogMessageReceived(logMessage, stackTrace, type);
         }
 
         /// <summary>
@@ -320,7 +317,7 @@ public void LogMessageReceived(string logMessage, string stackTrace, LogType typ
         /// <param name="exception">The Exception that will be serialized and posted to BugSplat</param>
         /// <param name="options">Optional parameters that will override the defaults if provided</param>
         /// <param name="callback">Optional callback that will be invoked with an HttpResponseMessage after exception is posted to BugSplat</param>
-        public IEnumerator Post(Exception exception, IReportPostOptions options = null, Action callback = null)
+        public IEnumerator Post(Exception exception, IReportPostOptions options = null, Action<ExceptionReporterPostResult> callback = null)
         {
             return exceptionReporter.Post(exception, options, callback);
         }

Runtime/Client/DotNetStandardClient.cs

@@ -6,7 +6,14 @@
 
 namespace BugSplatUnity.Runtime.Client
 {
-    internal class DotNetStandardClient : INativeCrashReportClient, IExceptionClient<Task<HttpResponseMessage>>
+    internal interface IDotNetStandardExceptionClient
+    {
+        Task<HttpResponseMessage> Post(string stackTrace, IReportPostOptions options = null);
+        Task<HttpResponseMessage> Post(Exception ex, IReportPostOptions options = null);
+        Task<HttpResponseMessage> Post(FileInfo minidumpFileInfo, IReportPostOptions options = null);
+    }
+
+    internal class DotNetStandardClient : INativeCrashReportClient, IDotNetStandardExceptionClient
     {
         private readonly BugSplatDotNetStandard.BugSplat _bugsplat;
 

Runtime/Client/IExceptionClient.cs

@@ -1,11 +1,18 @@
 using System;
 using System.Collections;
 using System.Collections.Generic;
+using BugSplatUnity.Runtime.Reporter;
 using UnityEngine;
 
 namespace BugSplatUnity.Runtime.Client
 {
-    internal class WebGLExceptionClient : IExceptionClient<IEnumerator>
+    internal interface IWebGlExceptionClient
+    {
+        IEnumerator Post(string stackTrace, IReportPostOptions options = null, Action<ExceptionReporterPostResult> callback = null);
+        IEnumerator Post(Exception ex, IReportPostOptions options = null, Action<ExceptionReporterPostResult> callback = null);
+    }
+
+    internal class WebGLExceptionClient : IWebGlExceptionClient
     {
         private readonly string _database;
         private readonly string _application;
@@ -20,17 +27,17 @@ public WebGLExceptionClient(string database, string application, string version)
             _version = version;
         }
 
-        public IEnumerator Post(string stackTrace, IReportPostOptions options = null)
+        public IEnumerator Post(string stackTrace, IReportPostOptions options = null, Action<ExceptionReporterPostResult> callback = null)
         {
-            return PostException(stackTrace, options);
+            return PostException(stackTrace, options, callback);
         }
 
-        public IEnumerator Post(Exception ex, IReportPostOptions options = null)
+        public IEnumerator Post(Exception ex, IReportPostOptions options = null, Action<ExceptionReporterPostResult> callback = null)
         {
-            return PostException(ex.ToString(), options);
+            return PostException(ex.ToString(), options, callback);
         }
 
-        private IEnumerator PostException(string exception, IReportPostOptions options = null)
+        private IEnumerator PostException(string exception, IReportPostOptions options = null, Action<ExceptionReporterPostResult> callback = null)
         {
             options = options ?? new ReportPostOptions();
 
@@ -45,19 +52,37 @@ private IEnumerator PostException(string exception, IReportPostOptions options =
                 { "appKey", options.Key },
                 { "user", options.User },
                 { "callstack", exception },
-                { "crashTypeId", $"{(int)options.CrashTypeId}" }
+                { "crashTypeId", $"{options.CrashTypeId}" }
             };
 
             var request = UnityWebClient.Post(url, formData);
             yield return request.SendWebRequest();
 
+            var responseCode = request.ResponseCode;
+
             if (!request.Success)
             {
                 Debug.LogError($"BugSplat error: Could not post exception {request.Error}");
+
+                callback?.Invoke(new ExceptionReporterPostResult() {
+                    Uploaded = false,
+                    Exception = exception,
+                    Message = $"BugSplat upload failed with code {responseCode}"
+                });
+
                 yield break;
             }
 
-            Debug.Log($"BugSplat info: status {request.ResponseCode}\n {request.DownloadHandler.Text}");
+            var responseText = request.DownloadHandler.Text;
+            var response = JsonUtility.FromJson<BugSplatResponse>(responseText);
+            Debug.Log($"BugSplat info: status {responseCode}\n {responseText}");
+
+            callback?.Invoke(new ExceptionReporterPostResult() {
+                Uploaded = true,
+                Exception = exception,
+                Message =  "Crash successfully uploaded to BugSplat!",
+                Response = response
+            });
         }
     }
 }

Runtime/Client/WebGLExceptionClient.cs

@@ -1,3 +1,4 @@
+using System;
 using BugSplatUnity.Runtime.Client;
 using UnityEngine;
 
@@ -15,15 +16,30 @@ public sealed class BugSplatManager : MonoBehaviour
 
 		[SerializeField]
 		[Tooltip("Register BugSplat to capture LogType.Exceptions on initialization.")]
-		private bool registerLogMessageRecieved;
+		private bool registerLogMessageReceived = true;
 
-		private BugSplatManagerImpl _impl;
-		public BugSplat BugSplat => _impl.BugSplat;
+		private BugSplatRef bugsplatRef;
+		public BugSplat BugSplat => bugsplatRef.BugSplat;
 
 		private void Awake()
 		{
-			_impl = new BugSplatManagerImpl(bugSplatOptions, registerLogMessageRecieved, dontDestroyManagerOnSceneLoad, gameObject);
-			_impl.Instantiate();
+			if (bugSplatOptions == null)
+			{
+				throw new ArgumentException("BugSplat error: BugSplatOptions is null! BugSplat will not be initialized.");
+			}
+
+			var bugsplat = BugSplat.CreateFromOptions(bugSplatOptions);
+			bugsplatRef = new BugSplatRef(bugsplat);
+
+			if (registerLogMessageReceived)
+			{
+				Application.logMessageReceived += (logMessage, stackTrace, type) => StartCoroutine(bugsplat.LogMessageReceived(logMessage, stackTrace, type));
+			}
+			
+			if (dontDestroyManagerOnSceneLoad)
+			{
+                DontDestroyOnLoad(this);
+			}
 		}
 	}
 }