public override async Task <ErrorReport> GetLastSessionCrashReportAsync()
{
var callback = new GetLastSessionCrashReportCallback();
AndroidCrashes.GetLastSessionCrashReport(callback);
var androidErrorReport = await callback.Result;
if (androidErrorReport == null)
{
return(null);
}
return(ErrorReportCache.GetErrorReport(androidErrorReport));
}
static Crashes()
{
// Set up 2 different handlers, some exceptions are caught by one or the other or both (all scenarios are possible).
// When caught on both, only the first invocation will actually be saved by the native SDK.
// Android environment is called before app domain in case of both called, and that's what we want as
// Android environment has a better stack trace object (no JavaProxyThrowable wrapper that cannot be serialized).
// Client side exception object after restart not possible most of the time with AppDomain when it's JavaProxyThrowable.
// AndroidEnvironment is also called before Java SDK exception handler (which itself not always called...).
// App domain fallback is thus used only when both android environment and Java SDK handler cannot catch.
// From our tests if only app domain is called, then it's not a JavaProxyThrowable, so stack trace looks fine.
AppCenterLog.Info(LogTag, "Set up Xamarin crash handlers.");
AndroidEnvironment.UnhandledExceptionRaiser += OnUnhandledException;
AppDomain.CurrentDomain.UnhandledException += OnUnhandledException;
// Set up bridge between Java listener and .NET events/callbacks.
AndroidCrashes.SetListener(new AndroidCrashListener());
}
static void PlatformNotifyUserConfirmation(UserConfirmation confirmation)
{
int androidUserConfirmation;
switch (confirmation)
{
case UserConfirmation.Send:
androidUserConfirmation = AndroidCrashes.Send;
break;
case UserConfirmation.DontSend:
androidUserConfirmation = AndroidCrashes.DontSend;
break;
case UserConfirmation.AlwaysSend:
androidUserConfirmation = AndroidCrashes.AlwaysSend;
break;
default:
throw new ArgumentOutOfRangeException(nameof(confirmation), confirmation, null);
}
AndroidCrashes.NotifyUserConfirmation(androidUserConfirmation);
}
static Task <bool> PlatformHasCrashedInLastSessionAsync()
{
var future = AndroidCrashes.HasCrashedInLastSession();
return(Task.Run(() => (bool)future.Get()));
}
static Task PlatformSetEnabledAsync(bool enabled)
{
var future = AndroidCrashes.SetEnabled(enabled);
return(Task.Run(() => future.Get()));
}
static Task <bool> PlatformIsEnabledAsync()
{
var future = AndroidCrashes.IsEnabled();
return(Task.Run(() => (bool)future.Get()));
}
static Task <bool> PlatformHasReceivedMemoryWarningInLastSessionAsync()
{
var future = AndroidCrashes.HasReceivedMemoryWarningInLastSession();
return(Task.Run(() => (bool)future.Get()));
}
public PlatformCrashes()
{
_crashListener = new AndroidCrashListener(this);
AndroidCrashes.SetListener(_crashListener);
}
static Crashes()
{
AppCenterLog.Info(LogTag, "Set up Xamarin crash handler.");
AndroidEnvironment.UnhandledExceptionRaiser += OnUnhandledException;
AndroidCrashes.SetListener(new AndroidCrashListener());
}
private static void PlatformUnsetInstance()
{
AndroidCrashes.UnsetInstance();
}
public override Task <bool> HasCrashedInLastSessionAsync()
{
var future = AndroidCrashes.HasCrashedInLastSession();
return(Task.Run(() => (bool)future.Get()));
}
public override Task SetEnabledAsync(bool enabled)
{
var future = AndroidCrashes.SetEnabled(enabled);
return(Task.Run(() => future.Get()));
}
public override Task <bool> IsEnabledAsync()
{
var future = AndroidCrashes.IsEnabled();
return(Task.Run(() => (bool)future.Get()));
}
