bepin/BepInEx/Logging/UnityLogWriter.cs

using System;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using BepInEx.ConsoleUtil;
using UnityEngine;

namespace BepInEx.Logging
{
	/// <summary>
	/// Logs entries using Unity specific outputs.
	/// </summary>
    public class UnityLogWriter : BaseLogger
	{
	    private static readonly Action<string> WriteStringToUnityLog;

        [DllImport("mono.dll", EntryPoint = "mono_lookup_internal_call")]
        private static extern IntPtr MonoLookupInternalCall(IntPtr gconstpointer);

        static UnityLogWriter()
        {
            foreach (MethodInfo methodInfo in typeof(UnityEngine.UnityLogWriter).GetMethods(BindingFlags.Static | BindingFlags.Public))
            {
                if (MonoLookupInternalCall(methodInfo.MethodHandle.Value) == IntPtr.Zero)
                    continue;

                WriteStringToUnityLog = (Action<string>) Delegate.CreateDelegate(typeof(Action<string>), methodInfo);
                break;
            }
        }

        /// <summary>
        /// Writes a string specifically to the game output log.
        /// </summary>
        /// <param name="value">The value to write.</param>
        public void WriteToLog(string value)
        {
            WriteStringToUnityLog?.Invoke(value);
        }

        protected void InternalWrite(string value)
        {
            Console.Write(value);
            WriteToLog(value);
        }

	    /// <summary>
	    /// Logs an entry to the Logger instance.
	    /// </summary>
	    /// <param name="level">The level of the entry.</param>
	    /// <param name="entry">The textual value of the entry.</param>
        public override void Log(LogLevel level, object entry)
        {
            Kon.ForegroundColor = level.GetConsoleColor();
            base.Log(level, entry);
            Kon.ForegroundColor = ConsoleColor.Gray;

            // If the display level got ignored, still write it to the log
            if ((DisplayedLevels & level) == LogLevel.None)
                WriteToLog($"[{level.GetHighestLevel()}] {entry}\r\n");
        }

        public override void WriteLine(string value) => InternalWrite($"{value}\r\n");
        public override void Write(char value) => InternalWrite(value.ToString());
        public override void Write(string value) => InternalWrite(value);

        /// <summary>
        /// Start listening to Unity's log message events and sending the messages to BepInEx logger.
        /// </summary>
        public static void ListenUnityLogs()
        {
            Type application = typeof(Application);
			
            EventInfo logEvent = application.GetEvent("logMessageReceived", BindingFlags.Public | BindingFlags.Static);
            if (logEvent != null)
            {
                logEvent.AddEventHandler(null, new Application.LogCallback(OnUnityLogMessageReceived));
            }
            else
            {
                MethodInfo registerLogCallback = application.GetMethod("RegisterLogCallback", BindingFlags.Public | BindingFlags.Static);
                registerLogCallback.Invoke(null, new object[] { new Application.LogCallback(OnUnityLogMessageReceived) });
            }
        }

        private static void OnUnityLogMessageReceived(string message, string stackTrace, LogType type)
        {
            LogLevel logLevel = LogLevel.Message;

            switch (type)
            {
                case LogType.Error:
                case LogType.Assert:
                case LogType.Exception:
                    logLevel = LogLevel.Error;
                    break;
                case LogType.Warning:
                    logLevel = LogLevel.Warning;
                    break;
                case LogType.Log:
                default:
                    logLevel = LogLevel.Info;
                    break;
            }

            Logger.Log(logLevel, message);
            if (type == LogType.Exception)
            {
                Logger.Log(logLevel, $"Stack trace:\n{stackTrace}");
            }
        }
    }
}

namespace UnityEngine
{
    internal sealed class UnityLogWriter
    {
        [MethodImpl(MethodImplOptions.InternalCall)]
        public static extern void WriteStringToUnityLogImpl(string s);

        [MethodImpl(MethodImplOptions.InternalCall)]
        public static extern void WriteStringToUnityLog(string s);
    }
}