internal ErrorReport(MSErrorReport msReport)
{
// If Id is not null we have loaded the report from the cache
if (Id != null)
{
return;
}
Id = msReport.IncidentIdentifier;
AppStartTime = NSDateToDateTimeOffset(msReport.AppStartTime);
AppErrorTime = NSDateToDateTimeOffset(msReport.AppErrorTime);
Device = msReport.Device == null ? null : new Device(msReport.Device);
AndroidDetails = null;
iOSDetails = new iOSErrorDetails(msReport.ReporterKey,
msReport.Signal,
msReport.ExceptionName,
msReport.ExceptionReason,
(uint)msReport.AppProcessIdentifier);
MSWrapperException wrapperException = MSWrapperExceptionManager.LoadWrapperExceptionWithUUID(msReport.IncidentIdentifier);
if (wrapperException != null && wrapperException.ExceptionData != null)
{
Exception = CrashesUtils.DeserializeException(wrapperException.ExceptionData.ToArray());
}
}
internal ErrorReport(AndroidErrorReport androidReport)
{
Id = androidReport.Id;
AppStartTime = DateTimeOffset.FromUnixTimeMilliseconds(androidReport.AppStartTime.Time);
AppErrorTime = DateTimeOffset.FromUnixTimeMilliseconds(androidReport.AppErrorTime.Time);
Device = androidReport.Device == null ? null : new Device(androidReport.Device);
object androidThrowable;
try
{
androidThrowable = androidReport.Throwable;
}
catch (Exception e)
{
MobileCenterLog.Debug(Crashes.LogTag, "Cannot read throwable from java point of view, probably a .NET exception", e);
androidThrowable = null;
byte[] exceptionBytes = AndroidExceptionDataManager.LoadWrapperExceptionData(Java.Util.UUID.FromString(Id));
if (exceptionBytes != null)
{
Exception = CrashesUtils.DeserializeException(exceptionBytes);
}
}
AndroidDetails = new AndroidErrorDetails(androidThrowable, androidReport.ThreadName);
iOSDetails = null;
}
/// <summary>
/// We don't assume order between java crash handler and c# crash handler.
/// This method is called after either of those 2 events and is thus effective only the second time when we got both the c# exception and the Android error log.
/// </summary>
private static void JoinExceptionAndLog()
{
/*
* We don't assume order between java crash handler and c# crash handler.
* This method is called after either of those 2 events.
* It is thus effective only the second time when we got both the .NET exception and the Android error log.
*/
if (_errorLog != null && _exception != null)
{
/*
* Generate structured data for the C# exception and overwrite the Java exception to enhance it.
* Unless if we have java exception in top cause, this would make it worse.
* Having java exception as intermediate cause is better with .NET stack structure though.
*/
if (!(_exception is Java.Lang.Exception))
{
_errorLog.Exception = GenerateModelException(_exception);
/* Tell the Android SDK to overwrite the modified error log on disk. */
AndroidExceptionDataManager.SaveWrapperSdkErrorLog(_errorLog);
}
/* Save the System.Exception to disk as a serialized object for client side inspection. */
byte[] exceptionData = CrashesUtils.SerializeException(_exception);
AndroidExceptionDataManager.SaveWrapperExceptionData(exceptionData, _errorLog.Id);
}
}
private static void OnUnhandledException(object sender, UnhandledExceptionEventArgs e)
{
Exception systemException = e.ExceptionObject as Exception;
MSException exception = GenerateiOSException(systemException);
MSWrapperExceptionManager.SetWrapperException(exception);
byte[] exceptionBytes = CrashesUtils.SerializeException(systemException);
NSData wrapperExceptionData = NSData.FromArray(exceptionBytes);
MSWrapperExceptionManager.SetWrapperExceptionData(wrapperExceptionData);
}
private static void OnUnhandledException(object sender, RaiseThrowableEventArgs e)
{
var exception = e.Exception;
MobileCenterLog.Error(Crashes.LogTag, "Unhandled Exception:", exception);
if (!(exception is Java.Lang.Exception))
{
var modelException = GenerateModelException(exception, true);
byte[] rawException = CrashesUtils.SerializeException(exception);
WrapperSdkExceptionManager.SaveWrapperException(Thread.CurrentThread(), modelException, rawException);
}
}
private static void OnUnhandledException(object sender, UnhandledExceptionEventArgs e)
{
Exception systemException = e.ExceptionObject as Exception;
MSException exception = GenerateiOSException(systemException, true);
byte[] exceptionBytes = CrashesUtils.SerializeException(systemException);
NSData wrapperExceptionData = NSData.FromArray(exceptionBytes);
MSWrapperException wrapperException = new MSWrapperException
{
Exception = exception,
ExceptionData = wrapperExceptionData,
ProcessId = new NSNumber(Process.GetCurrentProcess().Id)
};
MSWrapperExceptionManager.SaveWrapperException(wrapperException);
}
/// <summary>
/// We don't assume order between java crash handler and c# crash handler.
/// This method is called after either of those 2 events and is thus effective only the second time when we got both the c# exception and the Android error log.
/// </summary>
private static void JoinExceptionAndLog()
{
/*
* We don't assume order between java crash handler and c# crash handler.
* This method is called after either of those 2 events.
* It is thus effective only the second time when we got both the c# exception and the Android error log.
*/
if (_errorLog != null && _exception != null)
{
/* Generate structured data for the C# exception and overwrite the Java exception. */
_errorLog.Exception = GenerateModelException(_exception);
/* Tell the Android SDK to overwrite the modified error log on disk. */
AndroidExceptionDataManager.SaveWrapperSdkErrorLog(_errorLog);
/* Save the System.Exception to disk as a serialized object. */
byte[] exceptionData = CrashesUtils.SerializeException(_exception);
AndroidExceptionDataManager.SaveWrapperExceptionData(exceptionData, _errorLog.Id);
}
}