Unity应用发布如何在本地查看Debug输出？

在使用Unity引擎开发游戏的过程中，我们能将想要看到的内容通过Debug类来输出到Console窗口中，极大的方便了程序的调试过程。但是，我们将游戏发布成对应的平台应用程序后，这些输出还能不能看到呢？如可才能看到这些输出呢？这里我就介绍一种能够将Unity引擎的Debug类的输出写入到本地硬件的方法。


这里只介绍Windows平台与Android平台。

Windows平台：

默认情况下，打包应用到Windows平台，运行程序后，我们能够在“xxoo_Data”文件夹下看到“output_log.txt”文件，这个文件就是用来记录我们代码中调用的Debug类的输出。

其他情况，其实““output_log.txt”文件是可以通过Unity引擎设置屏蔽的。Unity设置项中的“ Use Player Log”项就是控制是否将Debug类的输出写入到本地硬件（PC硬盘）的开关，默认选中。

设置方法“Editor -> Project Settings -> Player ->  选择平台(Windows) -> Resolution and Presentation -> Use Player Log”。当然，为了提高程序的运行效率，在发布程序正式版时，建议关闭这个开关。

Android平台：

默认情况下，打包应用到Android后我们就看不到输出了。怎样才能在本地设备看到输出呢?

首先，设置发布配置“Editor -> Project Settings -> Player ->  选择平台(Android) -> Other Settings -> Write Access”。将“Write Access”设置成“External(SDCard)”。为了提高程序运行效率，发布到正式版时，最好不要选择此项。

接下来我就不赘述了，直接看代码：

using UnityEngine;
using System.Collections;
using UnityEngine.UI;
using System;

/// <summary>
/// Debug测试。
/// 将Debug写入到本地硬件
/// 这里使用的是Unity5.3.3版本
/// </summary>
public class LoggerMono : MonoBehaviour
{
public Text logText;
public string logName = "123";
private string m_txt;
private float m_timeNote;
private float m_timeNote2;
public float m_duration = 2f;

void Awake()
{
Application.logMessageReceived += OnLogCallBack;
m_timeNote = Time.time;

/// 这里才是重点，要将Debug输出写入到本地文件的关键。
LoggerWriter.instance.InitWriter(logName);
}

private void OnLogCallBack(string condition, string stackTrace, LogType type)
{
string logStr = string.Empty;
switch (type)
{
case LogType.Log:
{
logStr = string.Format("{0}：{1}\n", type, condition);
}
break;
case LogType.Assert:
case LogType.Warning:
case LogType.Exception:
case LogType.Error:
{
if (string.IsNullOrEmpty(stackTrace))
{
/// 发布到对应平台后，调用堆栈获取不到。使用 Environment.StackTrace 获取调用堆栈
logStr = string.Format("{0}：{1}\n{2}", type, condition, Environment.StackTrace);
}
else
{
logStr = string.Format("{0}：{1}\n{2}", type, condition, stackTrace);
}
}
break;
}
logStr += "\n";
m_txt += logStr;
}

void Update()
{
if (logText != null)
{
logText.text = m_txt;
}

if (Time.time - m_timeNote >= m_duration)
{
m_timeNote = Time.time;
Debug.Log(DateTime.Now.ToString("yyyy-MM-dd hh:mm:ss"));
}

if (Time.time - m_timeNote2 >= 2.1f * m_duration)
{
m_timeNote2 = Time.time;
Debug.LogError(DateTime.Now.ToString("yyyy-MM-dd hh:mm:ss"));
}
}
}

using UnityEngine;
using System.Collections;
using System;
using System.IO;
using System.IO.Compression;

/// <summary>
/// Debug输出写入本地硬件方法
/// </summary>
public class LoggerWriter
{
/// <summary>
/// 初始化文件写入的入口
/// </summary>
/// <param name="logName"></param>
public void InitWriter(string logName)
{
GetLogPath(logName);
CreateLogFile();
}

/// <summary>
/// 设置及获取对应发布平台的日记存放路径
/// </summary>
/// <param name="logName"></param>
private void GetLogPath(string logName)
{
switch (Application.platform)
{
case RuntimePlatform.Android:
{
//m_logPath = "mnt/sdcard/123.txt";
//m_logPath = string.Format("{0}/123.txt", Application.persistentDataPath);
m_logPath = string.Format("mnt/sdcard/{0}.txt", logName);
}
break;
case RuntimePlatform.IPhonePlayer:
{
m_logPath = string.Format("{0}/{1}.txt", Application.persistentDataPath, logName);
}
break;
case RuntimePlatform.WindowsPlayer:
{
m_logPath = string.Format("{0}/../{1}.txt", Application.dataPath, logName);
}
break;
case RuntimePlatform.WindowsEditor:
{
//m_logPath = string.Format("{0}/123.txt", Application.dataPath);
m_logPath = string.Format("{0}/../{1}.txt", Application.dataPath, logName);
}
break;
case RuntimePlatform.OSXEditor:
{

}
break;
}
}

/// <summary>
/// 根据路径创建日记文件，并注册文件写入的函数。
/// </summary>
private void CreateLogFile()
{
if (File.Exists(m_logPath))
{
File.Delete(m_logPath);
}

try
{
FileStream fs = File.Create(m_logPath);
fs.Close();

if (File.Exists(m_logPath))
{
Debug.Log(string.Format("Create file = {0}", m_logPath));
}

/// 注册事件，当Debug调用时，就会调用：
Application.logMessageReceived += OnLogCallBack;

OutputSystemInfo();
}
catch (System.Exception ex)
{
Debug.LogError(string.Format("can't Create file = {0},\n{1}", m_logPath, ex));
}
}

/// <summary>
/// 日记文件写入的函数
/// </summary>
/// <param name="condition"></param>
/// <param name="stackTrace"></param>
/// <param name="type"></param>
private void OnLogCallBack(string condition, string stackTrace, LogType type)
{
if (File.Exists(m_logPath))
{
var filestream = File.Open(m_logPath, FileMode.Append);
using (StreamWriter sw = new StreamWriter(filestream))
//using (StreamWriter sw = File.AppendText(m_logPath))
{
string logStr = string.Empty;
switch (type)
{
case LogType.Log:
{
logStr = string.Format("{0}：{1}\n", type, condition);
}
break;
case LogType.Assert:
case LogType.Warning:
case LogType.Exception:
case LogType.Error:
{
if (string.IsNullOrEmpty(stackTrace))
{
/// 发布到对应平台后，调用堆栈获取不到。使用 Environment.StackTrace 获取调用堆栈
logStr = string.Format("{0}：{1}\n{2}\n", type, condition, Environment.StackTrace);
}
else
{
logStr = string.Format("{0}：{1}\n{2}", type, condition, stackTrace);
}
}
break;
}

sw.WriteLine(logStr);

}
filestream.Close();
}
else
{
Debug.LogError(string.Format("not Exists File = {0} ！", m_logPath));
}
}

/// <summary>
/// 输出系统/硬件等一些信息
/// </summary>
private void OutputSystemInfo()
{
string str2 = string.Format("logger Start, time: {0}, version: {1}.", DateTime.Now.ToString(), Application.unityVersion);

string systemInfo = SystemInfo.operatingSystem + " "
+ SystemInfo.processorType + " " + SystemInfo.processorCount + " "
+ "memorySize:" + SystemInfo.systemMemorySize + " "
+ "Graphics: " + SystemInfo.graphicsDeviceName + " vendor: " + SystemInfo.graphicsDeviceVendor
+ " memorySize: " + SystemInfo.graphicsMemorySize + " " + SystemInfo.graphicsDeviceVersion;

Debug.Log(string.Format("{0}\n{1}", str2, systemInfo));
}

public static LoggerWriter instance
{
get
{
if (s_instance == null)
{
s_instance = new LoggerWriter();
}
return s_instance;
}
}

public string logPath
{
get { return m_logPath; }
}

private static LoggerWriter s_instance;
private string m_logPath;
}