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())); }