feat: Add screenshot at crash

CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## Unreleased
+
+### Features
+
+- Add screenshot at crash (#1920)
+
 ## 7.18.1
 
 ### Fixes

Sources/Sentry/SentryCrashReportConverter.m

@@ -145,7 +145,6 @@ - (SentryEvent *_Nullable)convertReportToEvent
             [NSString stringWithFormat:@"Could not convert report:%@", exception.description];
         [SentryLog logWithMessage:errorMessage andLevel:kSentryLevelError];
     }
-
     return nil;
 }
 

Sources/Sentry/SentryCrashReportSink.m

@@ -1,4 +1,5 @@
 #import "SentryCrashReportSink.h"
+#import "SentryAttachment.h"
 #import "SentryClient.h"
 #import "SentryCrash.h"
 #import "SentryCrashReportConverter.h"
@@ -9,6 +10,7 @@
 #import "SentryLog.h"
 #import "SentrySDK+Private.h"
 #import "SentrySDK.h"
+#import "SentryScope.h"
 #import "SentryThread.h"
 
 @interface
@@ -33,7 +35,15 @@ - (void)handleConvertedEvent:(SentryEvent *)event
                  sentReports:(NSMutableArray *)sentReports
 {
     [sentReports addObject:report];
-    [SentrySDK captureCrashEvent:event];
+    SentryScope *scope = [[SentryScope alloc] initWithScope:SentrySDK.currentHub.scope];
+
+    if (report[@"screenshots"]) {
+        for (NSString *ssPath in report[@"screenshots"]) {
+            [scope addAttachment:[[SentryAttachment alloc] initWithPath:ssPath]];
+        }
+    }
+
+    [SentrySDK captureCrashEvent:event withScope:scope];
 }
 
 - (void)filterReports:(NSArray *)reports

Sources/Sentry/SentryHub.m

@@ -203,13 +203,18 @@ - (nullable SentrySession *)incrementSessionErrors
     return sessionCopy;
 }
 
+- (void)captureCrashEvent:(SentryEvent *)event
+{
+    [self captureCrashEvent:event withScope:self.scope];
+}
+
 /**
  * If autoSessionTracking is enabled we want to send the crash and the event together to get proper
  * numbers for release health statistics. If there are multiple crash events to be sent on the start
  * of the SDK there is currently no way to know which one belongs to the crashed session so we just
  * send the session with the first crashed event we receive.
  */
-- (void)captureCrashEvent:(SentryEvent *)event
+- (void)captureCrashEvent:(SentryEvent *)event withScope:(SentryScope *)scope
 {
     event.isCrashEvent = YES;
 
@@ -226,13 +231,13 @@ - (void)captureCrashEvent:(SentryEvent *)event
         // It can be that there is no session yet, because autoSessionTracking was just enabled and
         // there is a previous crash on disk. In this case we just send the crash event.
         if (nil != crashedSession) {
-            [client captureCrashEvent:event withSession:crashedSession withScope:self.scope];
+            [client captureCrashEvent:event withSession:crashedSession withScope:scope];
             [fileManager deleteCrashedSession];
             return;
         }
     }
 
-    [client captureCrashEvent:event withScope:self.scope];
+    [client captureCrashEvent:event withScope:scope];
 }
 
 - (SentryId *)captureTransaction:(SentryTransaction *)transaction withScope:(SentryScope *)scope

Sources/Sentry/SentrySDK.m

@@ -159,6 +159,11 @@ + (void)captureCrashEvent:(SentryEvent *)event
     [SentrySDK.currentHub captureCrashEvent:event];
 }
 
++ (void)captureCrashEvent:(SentryEvent *)event withScope:(SentryScope *)scope
+{
+    [SentrySDK.currentHub captureCrashEvent:event withScope:scope];
+}
+
 + (SentryId *)captureEvent:(SentryEvent *)event
 {
     return [SentrySDK captureEvent:event withScope:SentrySDK.currentHub.scope];

Sources/Sentry/SentryScreenshot.m

@@ -5,6 +5,13 @@
 #if SENTRY_HAS_UIKIT
 #    import <UIKit/UIKit.h>
 
+void
+saveScreenShots(const char *path)
+{
+    [SentryDependencyContainer.sharedInstance.screenshot
+        saveScreenShots:[NSString stringWithUTF8String:path]];
+}
+
 @implementation SentryScreenshot
 
 - (NSArray<NSData *> *)appScreenshots
@@ -38,6 +45,27 @@ @implementation SentryScreenshot
     return result;
 }
 
+- (void)saveScreenShots:(NSString *)path
+{
+    NSArray<UIWindow *> *windows = [SentryDependencyContainer.sharedInstance.application windows];
+
+    for (UIWindow *window in windows) {
+        UIGraphicsBeginImageContext(window.frame.size);
+
+        int index = 0;
+        if ([window drawViewHierarchyInRect:window.bounds afterScreenUpdates:false]) {
+            UIImage *img = UIGraphicsGetImageFromCurrentImageContext();
+            NSString *name = index == 0
+                ? @"screenshot.png"
+                : [NSString stringWithFormat:@"screenshot-%i.png", index++ + 1];
+            NSString *fileName = [path stringByAppendingPathComponent:name];
+            [UIImagePNGRepresentation(img) writeToFile:fileName atomically:YES];
+        }
+
+        UIGraphicsEndImageContext();
+    }
+}
+
 @end
 
 #endif

Sources/Sentry/SentryScreenshotIntegration.m

@@ -1,6 +1,7 @@
 #import "SentryScreenshotIntegration.h"
 #import "SentryAttachment.h"
 #import "SentryClient+Private.h"
+#import "SentryCrashC.h"
 #import "SentryDependencyContainer.h"
 #import "SentryEvent+Private.h"
 #import "SentryEvent.h"
@@ -10,6 +11,23 @@
 #import "SentrySDK+Private.h"
 
 #if SENTRY_HAS_UIKIT
+
+void
+saveScreenShot(const char *path)
+{
+    NSString *reportPath = [NSString stringWithUTF8String:path];
+    if (![NSFileManager.defaultManager fileExistsAtPath:reportPath isDirectory:nil]) {
+        NSError *error = nil;
+        [NSFileManager.defaultManager createDirectoryAtPath:reportPath
+                                withIntermediateDirectories:YES
+                                                 attributes:nil
+                                                      error:&error];
+        if (error != nil)
+            return;
+    }
+    [SentryDependencyContainer.sharedInstance.screenshot saveScreenShots:reportPath];
+}
+
 @implementation SentryScreenshotIntegration
 
 - (void)installWithOptions:(nonnull SentryOptions *)options
@@ -21,6 +39,8 @@ - (void)installWithOptions:(nonnull SentryOptions *)options
 
     SentryClient *client = [SentrySDK.currentHub getClient];
     client.attachmentProcessor = self;
+
+    sentrycrash_setSaveScreenShot(&saveScreenShot);
 }
 
 - (NSArray<SentryAttachment *> *)processAttachments:(NSArray<SentryAttachment *> *)attachments
@@ -39,11 +59,8 @@ - (void)installWithOptions:(nonnull SentryOptions *)options
     [result addObjectsFromArray:attachments];
 
     for (int i = 0; i < screenshot.count; i++) {
-        NSString *name;
-        if (i == 0)
-            name = @"screenshot.png";
-        else
-            name = [NSString stringWithFormat:@"screenshot-%i.png", i + 1];
+        NSString *name
+            = i == 0 ? @"screenshot.png" : [NSString stringWithFormat:@"screenshot-%i.png", i + 1];
 
         SentryAttachment *att = [[SentryAttachment alloc] initWithData:screenshot[i]
                                                               filename:name

Sources/Sentry/include/SentryHub+Private.h

@@ -10,6 +10,8 @@ SentryHub (Private)
 
 - (void)captureCrashEvent:(SentryEvent *)event;
 
+- (void)captureCrashEvent:(SentryEvent *)event withScope:(SentryScope *)scope;
+
 - (void)setSampleRandomValue:(NSNumber *)value;
 
 - (void)closeCachedSessionWithTimestamp:(NSDate *_Nullable)timestamp;

Sources/Sentry/include/SentrySDK+Private.h

@@ -9,6 +9,8 @@ SentrySDK (Private)
 
 + (void)captureCrashEvent:(SentryEvent *)event;
 
++ (void)captureCrashEvent:(SentryEvent *)event withScope:(SentryScope *)scope;
+
 /**
  * SDK private field to store the state if onCrashedLastRun was called.
  */

Sources/Sentry/include/SentryScreenshot.h

@@ -14,6 +14,7 @@ NS_ASSUME_NONNULL_BEGIN
  */
 - (nullable NSArray<NSData *> *)appScreenshots;
 
+- (void)saveScreenShots:(NSString *)path;
 @end
 
 NS_ASSUME_NONNULL_END

Sources/SentryCrash/Recording/SentryCrash.m

@@ -34,6 +34,7 @@
 #import "SentryCrashMonitor_AppState.h"
 #import "SentryCrashMonitor_System.h"
 #import "SentryCrashReportFields.h"
+#import "SentryCrashReportStore.h"
 #import "SentryCrashSystemCapabilities.h"
 #import <NSData+Sentry.h>
 
@@ -407,6 +408,28 @@ - (NSData *)loadCrashReportJSONWithID:(int64_t)reportID
     return nil;
 }
 
+- (NSArray *)getScreenShots:(int64_t)reportID
+{
+    char report_screenshot_path[SentryCrashCRS_MAX_PATH_LENGTH];
+    sentrycrashcrs_screenShotPath(reportID, report_screenshot_path);
+    NSString *path = [NSString stringWithUTF8String:report_screenshot_path];
+
+    bool isDir = false;
+    if (![NSFileManager.defaultManager fileExistsAtPath:path isDirectory:&isDir] || !isDir)
+        return @[];
+
+    NSArray *files = [NSFileManager.defaultManager contentsOfDirectoryAtPath:path error:nil];
+    if (files == nil)
+        return @[];
+
+    NSMutableArray *result = [[NSMutableArray alloc] initWithCapacity:files.count];
+    [files enumerateObjectsUsingBlock:^(id _Nonnull obj, NSUInteger idx, BOOL *_Nonnull stop) {
+        [result addObject:[NSString stringWithFormat:@"%@/%@", path, obj]];
+    }];
+
+    return result;
+}
+
 - (void)doctorReport:(NSMutableDictionary *)report
 {
     NSMutableDictionary *crashReport = report[@SentryCrashField_Crash];
@@ -452,6 +475,7 @@ - (NSDictionary *)reportWithIntID:(int64_t)reportID
                              | SentryCrashJSONDecodeOptionIgnoreNullInObject
                              | SentryCrashJSONDecodeOptionKeepPartialObject
                                error:&error];
+
     if (error != nil) {
         SentryCrashLOG_ERROR(
             @"Encountered error loading crash report %" PRIx64 ": %@", reportID, error);
@@ -460,6 +484,12 @@ - (NSDictionary *)reportWithIntID:(int64_t)reportID
         SentryCrashLOG_ERROR(@"Could not load crash report");
         return nil;
     }
+
+    NSArray *screenShots = [self getScreenShots:reportID];
+    if (screenShots.count > 0) {
+        [crashReport setObject:screenShots forKey:@"screenshots"];
+    }
+
     [self doctorReport:crashReport];
 
     return crashReport;

Sources/SentryCrash/Recording/SentryCrashC.c

@@ -61,6 +61,7 @@ static bool g_shouldPrintPreviousLog = false;
 static char g_consoleLogPath[SentryCrashFU_MAX_PATH_LENGTH];
 static SentryCrashMonitorType g_monitoring = SentryCrashMonitorTypeProductionSafeMinimal;
 static char g_lastCrashReportFilePath[SentryCrashFU_MAX_PATH_LENGTH];
+static void (*g_saveScreenShot)(const char *) = 0;
 
 // ============================================================================
 #pragma mark - Utility -
@@ -106,6 +107,17 @@ onCrash(struct SentryCrash_MonitorContext *monitorContext)
         strncpy(g_lastCrashReportFilePath, crashReportFilePath, sizeof(g_lastCrashReportFilePath));
         sentrycrashreport_writeStandardReport(monitorContext, crashReportFilePath);
     }
+
+    // Report is saved to disk, now we try to take screenshots.
+    // Depending on the state of the crash this may not work
+    // because we gonna call into asyng code.
+    if (g_saveScreenShot) {
+        unsigned long pathLen = strlen(g_lastCrashReportFilePath);
+        char crashScreenshotsPath[pathLen];
+        strcpy(crashScreenshotsPath, g_lastCrashReportFilePath);
+        crashScreenshotsPath[pathLen - 5] = 0; // remove extension to use as a directory
+        g_saveScreenShot(crashScreenshotsPath);
+    }
 }
 
 // ============================================================================
@@ -211,6 +223,12 @@ sentrycrash_setMaxReportCount(int maxReportCount)
     sentrycrashcrs_setMaxReportCount(maxReportCount);
 }
 
+void
+sentrycrash_setSaveScreenShot(void (*callback)(const char *))
+{
+    g_saveScreenShot = callback;
+}
+
 void
 sentrycrash_reportUserException(const char *name, const char *reason, const char *language,
     const char *lineOfCode, const char *stackTrace, bool logAllThreads, bool terminateProgram)

Sources/SentryCrash/Recording/SentryCrashC.h

@@ -133,6 +133,13 @@ void sentrycrash_setPrintPreviousLog(bool shouldPrintPreviousLog);
  */
 void sentrycrash_setMaxReportCount(int maxReportCount);
 
+/**
+ * Set the callback to be called at the end of a crash to make the app save a screenshot;
+ *
+ * @param callback function pointer that will be called with a give path.
+ */
+void sentrycrash_setSaveScreenShot(void (*callback)(const char *));
+
 /** Report a custom, user defined exception.
  * This can be useful when dealing with scripting languages.
  *

Sources/SentryCrash/Recording/SentryCrashReportStore.c

@@ -212,6 +212,13 @@ sentrycrashcrs_readReport(int64_t reportID)
     return result;
 }
 
+void
+sentrycrashcrs_screenShotPath(int64_t reportID, char *pathBuffer)
+{
+    snprintf(pathBuffer, SentryCrashCRS_MAX_PATH_LENGTH, "%s/%s-report-%016llx", g_reportsPath,
+        g_appName, reportID);
+}
+
 int64_t
 sentrycrashcrs_addUserReport(const char *report, int reportLength)
 {

Sources/SentryCrash/Recording/SentryCrashReportStore.h

@@ -73,6 +73,13 @@ int sentrycrashcrs_getReportIDs(int64_t *reportIDs, int count);
  */
 char *sentrycrashcrs_readReport(int64_t reportID);
 
+/** Gets a report screenshots directory.
+ *
+ * @param reportID The report's ID.
+ * @param pathBuffer A buffer to store the path;
+ */
+void sentrycrashcrs_screenShotPath(int64_t reportID, char *pathBuffer);
+
 /** Add a custom report to the store.
  *
  * @param report The report's contents (must be JSON encoded).