/// <summary>
    /// Modify the generated cpp code from the firebase crashlytics library to prevent it from handling logged errors or unhandled exceptions
    ///
    /// This is to workaround https://github.com/firebase/quickstart-unity/issues/860
    ///
    /// Instead of letting the library handle this processing on the main thread, our implementation will handle the same data and log it in another thread
    /// </summary>
    public class DisableNativeCrashlyticsListeners : IPostprocessBuildWithReport
    {
        public int callbackOrder => 1;

        public void OnPostprocessBuild(BuildReport report)
        {
            if (report.summary.platform != BuildTarget.iOS)
            {
                return;
            }

            Debug.Log("Disabling the internal crash and error listeners in the Crashlytics library");

            // open the native generated cpp file
            string filePath = Path.Combine(report.summary.outputPath, "Classes", "Native", "Firebase.Crashlytics.cpp");
            string[] lines = File.ReadAllLines(filePath);

            // search for the function to register the exceptionHandler
            int lineToModify = -1;
            for (int i = 0; i < lines.Length; i  )
            {
                if (lines[i] == "// System.Void Firebase.Crashlytics.ExceptionHandler::Register()")
                {
                    // skip over the function declaration and look for the function itself
                    if (!lines[i   1].Contains(";"))
                    {
                        lineToModify = i   2;
                        break;
                    }
                }
            }

            // return immediately, which prevents it from adding listeners
            Debug.Log("Firebase.Crashlytics.cpp Line To Modify: "   lineToModify);
            if (lineToModify > 0)
            {
                string line = lines[lineToModify];
                Debug.Log("Line Before: "   line);
                line  = " return;";
                lines[lineToModify] = line;
                Debug.Log("Line After: "   line);
            }
            else
            {
                Debug.LogError("Unable to find the line to modify in the Firebase.Crashlytics.cpp file");
            }

            // save results
            File.WriteAllLines(filePath, lines);
        }
    }

// listen for Unity log messages and crashes
Application.logMessageReceivedThreaded  = OnLogMessageReceived;
AppDomain.CurrentDomain.UnhandledException  = OnUnhandledException;

// use reflection to get a reference to the static function to let use create the exception crashlytics will flag as a crash
Type classType = Type.GetType("Firebase.Crashlytics.LoggedException, Firebase.Crashlytics, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null");
CreateUnhandledException = classType?.GetMethod("FromException", BindingFlags.Static | BindingFlags.Public);

private static void OnUnhandledException(object sender, UnhandledExceptionEventArgs eArgs)
{
    // move processing off thread
    Task.Run(() =>
    {
        // matching the exact behaviour of the internal crashlytics
        Crashlytics.LogException((Exception)CreateUnhandledException.Invoke(null, new object[] { (Exception)eArgs.ExceptionObject }));
    });
}

private static void OnLogMessageReceived(string logString, string stackTrace, LogType logType)
{
    // only forward errors and exceptions (you could make this warnings or whatever here)
    if (logType == LogType.Error || logType == LogType.Exception)
    {
        // Log as a HandledException
        Task.Run(() =>
        {
             Crashlytics.LogException(new HandledException(logString, stackTrace));
        });
    }
}

// custom exception to match the stack trace of the logged exception
public class HandledException : Exception
{
    public HandledException(string message, string stackTrace) : base(message)
    {
         StackTrace = stackTrace;
    }

    public override string StackTrace { get; }
}