react-native-rectangle-doc-scanner 3.65.0 → 3.67.0

package/dist/DocScanner.js

@@ -88,6 +88,18 @@ exports.DocScanner = (0, react_1.forwardRef)(({ onCapture, overlayColor = DEFAUL
         return Math.min(100, Math.max(0, quality));
     }, [quality]);
     const handlePictureTaken = (0, react_1.useCallback)((event) => {
+        const captureError = event?.error;
+        if (captureError) {
+            console.error('[DocScanner] Native capture error received:', captureError);
+            captureOriginRef.current = 'auto';
+            setIsAutoCapturing(false);
+            setDetectedRectangle(null);
+            if (captureResolvers.current) {
+                captureResolvers.current.reject(new Error(String(captureError)));
+                captureResolvers.current = null;
+            }
+            return;
+        }
         console.log('[DocScanner] handlePictureTaken called with event:', {
             hasInitialImage: !!event.initialImage,
             hasCroppedImage: !!event.croppedImage,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-rectangle-doc-scanner",
-  "version": "3.65.0",
+  "version": "3.67.0",
   "description": "Native-backed document scanner for React Native with customizable overlays.",
   "license": "MIT",
   "main": "dist/index.js",

package/src/DocScanner.tsx

@@ -150,6 +150,21 @@ export const DocScanner = forwardRef<DocScannerHandle, Props>(
 
     const handlePictureTaken = useCallback(
       (event: PictureEvent) => {
+        const captureError = (event as any)?.error;
+        if (captureError) {
+          console.error('[DocScanner] Native capture error received:', captureError);
+          captureOriginRef.current = 'auto';
+          setIsAutoCapturing(false);
+          setDetectedRectangle(null);
+
+          if (captureResolvers.current) {
+            captureResolvers.current.reject(new Error(String(captureError)));
+            captureResolvers.current = null;
+          }
+
+          return;
+        }
+
         console.log('[DocScanner] handlePictureTaken called with event:', {
           hasInitialImage: !!event.initialImage,
           hasCroppedImage: !!event.croppedImage,

package/vendor/react-native-document-scanner/ios/DocumentScannerView.m

@@ -127,7 +127,28 @@
 - (void) capture {
     NSLog(@"[DocumentScanner] capture called");
     [self captureImageWithCompletionHander:^(UIImage *croppedImage, UIImage *initialImage, CIRectangleFeature *rectangleFeature) {
-      NSLog(@"[DocumentScanner] captureImageWithCompletionHander callback - croppedImage: %@, initialImage: %@", croppedImage ? @"YES" : @"NO", initialImage ? @"YES" : @"NO");
+    NSLog(@"[DocumentScanner] captureImageWithCompletionHander callback - croppedImage: %@, initialImage: %@", croppedImage ? @"YES" : @"NO", initialImage ? @"YES" : @"NO");
+
+      if (!croppedImage && initialImage) {
+        // Use initial image when cropping is not available
+        croppedImage = initialImage;
+      } else if (!initialImage && croppedImage) {
+        // Mirror cropped image so downstream logic continues to work
+        initialImage = croppedImage;
+      }
+
+      if (!croppedImage || !initialImage) {
+        NSLog(@"[DocumentScanner] capture failed - missing image data");
+        if (self.onPictureTaken) {
+          self.onPictureTaken(@{ @"error": @"capture_failed" });
+        }
+
+        if (!self.captureMultiple) {
+          [self stop];
+        }
+        return;
+      }
+
       if (self.onPictureTaken) {
             NSLog(@"[DocumentScanner] Calling onPictureTaken");
             // Use maximum JPEG quality (1.0) or user's quality setting, whichever is higher

package/vendor/react-native-document-scanner/ios/IPDFCameraViewController.m

@@ -15,6 +15,19 @@
 #import <ImageIO/ImageIO.h>
 #import <GLKit/GLKit.h>
 
+static inline void dispatch_async_main_queue(dispatch_block_t block)
+{
+    if (!block) {
+        return;
+    }
+
+    if ([NSThread isMainThread]) {
+        block();
+    } else {
+        dispatch_async(dispatch_get_main_queue(), block);
+    }
+}
+
 @interface IPDFCameraViewController () <AVCaptureVideoDataOutputSampleBufferDelegate, AVCapturePhotoCaptureDelegate>
 
 @property (nonatomic,strong) AVCaptureSession *captureSession;
@@ -47,6 +60,39 @@
     BOOL _isCapturing;
 }
 
+- (void)completeCaptureWithCroppedImage:(UIImage *)croppedImage
+                            initialImage:(UIImage *)initialImage
+                               rectangle:(CIRectangleFeature *)rectangleFeature
+                                   error:(NSError *)error
+{
+    void (^completionHandler)(UIImage *, UIImage *, CIRectangleFeature *) = self.captureCompletionHandler;
+
+    dispatch_async_main_queue(^{
+        if (error) {
+            NSLog(@"[IPDFCameraViewController] Completing capture with error: %@", error.localizedDescription);
+            if (completionHandler) {
+                completionHandler(nil, nil, nil);
+            }
+        } else {
+            UIImage *resolvedInitial = initialImage ?: croppedImage;
+            UIImage *resolvedCropped = croppedImage ?: resolvedInitial;
+
+            if (!resolvedInitial || !resolvedCropped) {
+                NSLog(@"[IPDFCameraViewController] Missing images during completion, sending failure to JS");
+                if (completionHandler) {
+                    completionHandler(nil, nil, nil);
+                }
+            } else if (completionHandler) {
+                completionHandler(resolvedCropped, resolvedInitial, rectangleFeature);
+            }
+        }
+
+        self.captureCompletionHandler = nil;
+        self->_isCapturing = NO;
+        [self hideGLKView:NO completion:nil];
+    });
+}
+
 - (void)awakeFromNib
 {
     [super awakeFromNib];
@@ -153,7 +199,16 @@
             [session addOutput:self.photoOutput];
             NSLog(@"[IPDFCamera] Using AVCapturePhotoOutput (modern API)");
         } else {
-            NSLog(@"[IPDFCamera] ERROR: Cannot add AVCapturePhotoOutput");
+            NSLog(@"[IPDFCamera] WARNING: Cannot add AVCapturePhotoOutput, falling back to AVCaptureStillImageOutput");
+            self.photoOutput = nil;
+            // Fallback to legacy API
+            self.stillImageOutput = [[AVCaptureStillImageOutput alloc] init];
+            if ([session canAddOutput:self.stillImageOutput]) {
+                [session addOutput:self.stillImageOutput];
+                NSLog(@"[IPDFCamera] Fallback successful: Using AVCaptureStillImageOutput");
+            } else {
+                NSLog(@"[IPDFCamera] CRITICAL ERROR: Cannot add any capture output!");
+            }
         }
     } else {
         // Fallback for older iOS versions (< iOS 10)
@@ -443,7 +498,10 @@
 
     if (!self.captureSession || !self.captureSession.isRunning) {
         NSLog(@"[IPDFCameraViewController] ERROR: captureSession is not running");
-        _isCapturing = NO;
+        NSError *error = [NSError errorWithDomain:@"IPDFCameraViewController"
+                                             code:-200
+                                         userInfo:@{ NSLocalizedDescriptionKey: @"capture_session_not_running" }];
+        [self completeCaptureWithCroppedImage:nil initialImage:nil rectangle:nil error:error];
         return;
     }
 
@@ -464,24 +522,25 @@
 
     // Use modern AVCapturePhotoOutput API (iOS 10+)
     if (@available(iOS 10.0, *)) {
-        if (!self.photoOutput) {
-            NSLog(@"[IPDFCameraViewController] ERROR: photoOutput is nil");
-            _isCapturing = NO;
-            self.captureCompletionHandler = nil;
-            [weakSelf hideGLKView:NO completion:nil];
+        if (self.photoOutput) {
+            NSLog(@"[IPDFCameraViewController] Using AVCapturePhotoOutput to capture");
+            AVCapturePhotoSettings *settings = [AVCapturePhotoSettings photoSettings];
+            [self.photoOutput capturePhotoWithSettings:settings delegate:self];
             return;
         }
 
-        NSLog(@"[IPDFCameraViewController] Using AVCapturePhotoOutput to capture");
-        AVCapturePhotoSettings *settings = [AVCapturePhotoSettings photoSettings];
-        [self.photoOutput capturePhotoWithSettings:settings delegate:self];
-    } else {
-        // Fallback to deprecated API for iOS < 10
+        NSLog(@"[IPDFCameraViewController] photoOutput is nil, trying fallback to stillImageOutput");
+        // Fallback to legacy API if photoOutput is not available
+    }
+
+    // Fallback: Use legacy AVCaptureStillImageOutput (iOS < 10 or when photoOutput failed)
+    {
         if (!self.stillImageOutput) {
             NSLog(@"[IPDFCameraViewController] ERROR: stillImageOutput is nil");
-            _isCapturing = NO;
-            self.captureCompletionHandler = nil;
-            [weakSelf hideGLKView:NO completion:nil];
+            NSError *error = [NSError errorWithDomain:@"IPDFCameraViewController"
+                                                 code:-201
+                                             userInfo:@{ NSLocalizedDescriptionKey: @"missing_still_image_output" }];
+            [self completeCaptureWithCroppedImage:nil initialImage:nil rectangle:nil error:error];
             return;
         }
 
@@ -501,9 +560,10 @@
 
         if (!videoConnection) {
             NSLog(@"[IPDFCameraViewController] ERROR: No video connection found");
-            _isCapturing = NO;
-            self.captureCompletionHandler = nil;
-            [weakSelf hideGLKView:NO completion:nil];
+            NSError *error = [NSError errorWithDomain:@"IPDFCameraViewController"
+                                                 code:-202
+                                             userInfo:@{ NSLocalizedDescriptionKey: @"no_video_connection" }];
+            [self completeCaptureWithCroppedImage:nil initialImage:nil rectangle:nil error:error];
             return;
         }
 
@@ -521,126 +581,155 @@
 
     if (error) {
         NSLog(@"[IPDFCameraViewController] ERROR in didFinishProcessingPhoto: %@", error);
-        _isCapturing = NO;
-        self.captureCompletionHandler = nil;
-        [self hideGLKView:NO completion:nil];
+        [self completeCaptureWithCroppedImage:nil initialImage:nil rectangle:nil error:error];
         return;
     }
 
+    // iOS 11+ uses fileDataRepresentation
     NSData *imageData = [photo fileDataRepresentation];
     if (!imageData) {
         NSLog(@"[IPDFCameraViewController] ERROR: Failed to get image data from photo");
-        _isCapturing = NO;
-        self.captureCompletionHandler = nil;
-        [self hideGLKView:NO completion:nil];
+        NSError *dataError = [NSError errorWithDomain:@"IPDFCameraViewController"
+                                                code:-203
+                                            userInfo:@{ NSLocalizedDescriptionKey: @"no_image_data_from_photo" }];
+        [self completeCaptureWithCroppedImage:nil initialImage:nil rectangle:nil error:dataError];
         return;
     }
 
+    NSLog(@"[IPDFCameraViewController] Got image data from AVCapturePhoto, size: %lu bytes", (unsigned long)imageData.length);
     [self processImageData:imageData];
 }
 
 // AVCapturePhotoCaptureDelegate method for iOS 10
 - (void)captureOutput:(AVCapturePhotoOutput *)output didFinishProcessingPhotoSampleBuffer:(CMSampleBufferRef)photoSampleBuffer previewPhotoSampleBuffer:(CMSampleBufferRef)previewPhotoSampleBuffer resolvedSettings:(AVCaptureResolvedPhotoSettings *)resolvedSettings bracketSettings:(AVCaptureBracketedStillImageSettings *)bracketSettings error:(NSError *)error API_DEPRECATED("Use -captureOutput:didFinishProcessingPhoto:error: instead.", ios(10.0, 11.0)) {
     NSLog(@"[IPDFCameraViewController] didFinishProcessingPhotoSampleBuffer called (iOS 10)");
-    [self handleCapturedImageData:photoSampleBuffer error:error];
+
+    if (error) {
+        NSLog(@"[IPDFCameraViewController] ERROR in didFinishProcessingPhotoSampleBuffer: %@", error);
+        [self completeCaptureWithCroppedImage:nil initialImage:nil rectangle:nil error:error];
+        return;
+    }
+
+    if (!photoSampleBuffer) {
+        NSLog(@"[IPDFCameraViewController] ERROR: photoSampleBuffer is nil");
+        NSError *bufferError = [NSError errorWithDomain:@"IPDFCameraViewController"
+                                                  code:-204
+                                              userInfo:@{ NSLocalizedDescriptionKey: @"photo_sample_buffer_nil" }];
+        [self completeCaptureWithCroppedImage:nil initialImage:nil rectangle:nil error:bufferError];
+        return;
+    }
+
+    // iOS 10: Use AVCapturePhotoOutput's method for converting sample buffer
+    NSData *imageData = [AVCapturePhotoOutput JPEGPhotoDataRepresentationForJPEGSampleBuffer:photoSampleBuffer previewPhotoSampleBuffer:previewPhotoSampleBuffer];
+
+    if (!imageData) {
+        NSLog(@"[IPDFCameraViewController] ERROR: Failed to create JPEG data from photo sample buffer");
+        NSError *dataError = [NSError errorWithDomain:@"IPDFCameraViewController"
+                                                code:-205
+                                            userInfo:@{ NSLocalizedDescriptionKey: @"jpeg_conversion_failed" }];
+        [self completeCaptureWithCroppedImage:nil initialImage:nil rectangle:nil error:dataError];
+        return;
+    }
+
+    NSLog(@"[IPDFCameraViewController] Got image data from photo sample buffer (iOS 10), size: %lu bytes", (unsigned long)imageData.length);
+    [self processImageData:imageData];
 }
 
+// Helper method for legacy AVCaptureStillImageOutput (iOS < 10)
 - (void)handleCapturedImageData:(CMSampleBufferRef)sampleBuffer error:(NSError *)error {
-    NSLog(@"[IPDFCameraViewController] handleCapturedImageData called, error=%@, buffer=%@", error, sampleBuffer ? @"YES" : @"NO");
+    NSLog(@"[IPDFCameraViewController] handleCapturedImageData called (legacy), error=%@, buffer=%@", error, sampleBuffer ? @"YES" : @"NO");
 
     if (error) {
         NSLog(@"[IPDFCameraViewController] ERROR capturing image: %@", error);
-        _isCapturing = NO;
-        self.captureCompletionHandler = nil;
-        [self hideGLKView:NO completion:nil];
+        [self completeCaptureWithCroppedImage:nil initialImage:nil rectangle:nil error:error];
         return;
     }
 
     if (!sampleBuffer) {
         NSLog(@"[IPDFCameraViewController] ERROR: sampleBuffer is nil");
-        _isCapturing = NO;
-        self.captureCompletionHandler = nil;
-        [self hideGLKView:NO completion:nil];
+        NSError *bufferError = [NSError errorWithDomain:@"IPDFCameraViewController"
+                                                  code:-206
+                                              userInfo:@{ NSLocalizedDescriptionKey: @"sample_buffer_nil" }];
+        [self completeCaptureWithCroppedImage:nil initialImage:nil rectangle:nil error:bufferError];
         return;
     }
 
+    // iOS < 10: Use AVCaptureStillImageOutput's method
     NSData *imageData = [AVCaptureStillImageOutput jpegStillImageNSDataRepresentation:sampleBuffer];
 
     if (!imageData) {
-        NSLog(@"[IPDFCameraViewController] ERROR: Failed to create image data from sample buffer");
-        _isCapturing = NO;
-        self.captureCompletionHandler = nil;
-        [self hideGLKView:NO completion:nil];
+        NSLog(@"[IPDFCameraViewController] ERROR: Failed to create image data from sample buffer (legacy)");
+        NSError *dataError = [NSError errorWithDomain:@"IPDFCameraViewController"
+                                                code:-207
+                                            userInfo:@{ NSLocalizedDescriptionKey: @"legacy_sample_conversion_failed" }];
+        [self completeCaptureWithCroppedImage:nil initialImage:nil rectangle:nil error:dataError];
         return;
     }
 
+    NSLog(@"[IPDFCameraViewController] Got image data from still image output (legacy), size: %lu bytes", (unsigned long)imageData.length);
     [self processImageData:imageData];
 }
 
 - (void)processImageData:(NSData *)imageData {
     NSLog(@"[IPDFCameraViewController] processImageData called, imageData size: %lu bytes", (unsigned long)imageData.length);
 
-    __weak typeof(self) weakSelf = self;
-    void (^completionHandler)(UIImage *, UIImage *, CIRectangleFeature *) = self.captureCompletionHandler;
-
-    if (!completionHandler) {
-        NSLog(@"[IPDFCameraViewController] ERROR: completionHandler is nil");
-        _isCapturing = NO;
-        [self hideGLKView:NO completion:nil];
+    if (!imageData || imageData.length == 0) {
+        NSError *dataError = [NSError errorWithDomain:@"IPDFCameraViewController"
+                                                code:-208
+                                            userInfo:@{ NSLocalizedDescriptionKey: @"empty_image_data" }];
+        [self completeCaptureWithCroppedImage:nil initialImage:nil rectangle:nil error:dataError];
         return;
     }
 
-    if (self.cameraViewType == IPDFCameraViewTypeBlackAndWhite || self.isBorderDetectionEnabled)
-    {
-        CIImage *enhancedImage = [CIImage imageWithData:imageData];
-
-        if (self.cameraViewType == IPDFCameraViewTypeBlackAndWhite)
-        {
-            enhancedImage = [self filteredImageUsingEnhanceFilterOnImage:enhancedImage];
-        }
-        else
-        {
-            enhancedImage = [self filteredImageUsingContrastFilterOnImage:enhancedImage];
-        }
-
-        if (self.isBorderDetectionEnabled && rectangleDetectionConfidenceHighEnough(_imageDedectionConfidence))
-        {
-            CIRectangleFeature *rectangleFeature = [self biggestRectangleInRectangles:[[self highAccuracyRectangleDetector] featuresInImage:enhancedImage]];
-
-            if (rectangleFeature)
-            {
-                enhancedImage = [self correctPerspectiveForImage:enhancedImage withFeatures:rectangleFeature];
+    UIImage *initialImage = [UIImage imageWithData:imageData];
+    if (!initialImage) {
+        NSError *conversionError = [NSError errorWithDomain:@"IPDFCameraViewController"
+                                                       code:-209
+                                                   userInfo:@{ NSLocalizedDescriptionKey: @"initial_image_conversion_failed" }];
+        [self completeCaptureWithCroppedImage:nil initialImage:nil rectangle:nil error:conversionError];
+        return;
+    }
 
-                UIGraphicsBeginImageContext(CGSizeMake(enhancedImage.extent.size.height, enhancedImage.extent.size.width));
-                [[UIImage imageWithCIImage:enhancedImage scale:1.0 orientation:UIImageOrientationRight] drawInRect:CGRectMake(0,0, enhancedImage.extent.size.height, enhancedImage.extent.size.width)];
-                UIImage *image = UIGraphicsGetImageFromCurrentImageContext();
-                UIImage *initialImage = [UIImage imageWithData:imageData];
-                UIGraphicsEndImageContext();
+    UIImage *croppedImage = initialImage;
+    CIRectangleFeature *rectangleFeature = nil;
 
-                [weakSelf hideGLKView:NO completion:nil];
-                completionHandler(image, initialImage, rectangleFeature);
+    BOOL shouldEnhance = (self.cameraViewType == IPDFCameraViewTypeBlackAndWhite) || self.isBorderDetectionEnabled;
+    if (shouldEnhance) {
+        CIImage *processedImage = [CIImage imageWithData:imageData];
+        if (!processedImage) {
+            NSLog(@"[IPDFCameraViewController] Unable to create CIImage from data, returning original image");
+        } else {
+            if (self.cameraViewType == IPDFCameraViewTypeBlackAndWhite) {
+                processedImage = [self filteredImageUsingEnhanceFilterOnImage:processedImage];
             } else {
-                // No rectangle detected, return original image
-                NSLog(@"[IPDFCameraViewController] No rectangle detected during manual capture, returning original image");
-                [weakSelf hideGLKView:NO completion:nil];
-                UIImage *initialImage = [UIImage imageWithData:imageData];
-                completionHandler(initialImage, initialImage, nil);
+                processedImage = [self filteredImageUsingContrastFilterOnImage:processedImage];
+            }
+
+            if (self.isBorderDetectionEnabled && rectangleDetectionConfidenceHighEnough(_imageDedectionConfidence)) {
+                CIRectangleFeature *detectedRectangle = [self biggestRectangleInRectangles:[[self highAccuracyRectangleDetector] featuresInImage:processedImage]];
+
+                if (detectedRectangle) {
+                    rectangleFeature = detectedRectangle;
+                    CIImage *correctedImage = [self correctPerspectiveForImage:processedImage withFeatures:detectedRectangle];
+
+                    UIGraphicsBeginImageContext(CGSizeMake(correctedImage.extent.size.height, correctedImage.extent.size.width));
+                    [[UIImage imageWithCIImage:correctedImage scale:1.0 orientation:UIImageOrientationRight] drawInRect:CGRectMake(0, 0, correctedImage.extent.size.height, correctedImage.extent.size.width)];
+                    UIImage *perspectiveCorrectedImage = UIGraphicsGetImageFromCurrentImageContext();
+                    UIGraphicsEndImageContext();
+
+                    if (perspectiveCorrectedImage) {
+                        croppedImage = perspectiveCorrectedImage;
+                    } else {
+                        NSLog(@"[IPDFCameraViewController] Failed to create perspective corrected image, using original");
+                    }
+                } else {
+                    NSLog(@"[IPDFCameraViewController] No rectangle detected during manual capture, returning original image");
+                }
             }
-        } else {
-            [weakSelf hideGLKView:NO completion:nil];
-            UIImage *initialImage = [UIImage imageWithData:imageData];
-            completionHandler(initialImage, initialImage, nil);
         }
     }
-    else
-    {
-        [weakSelf hideGLKView:NO completion:nil];
-        UIImage *initialImage = [UIImage imageWithData:imageData];
-        completionHandler(initialImage, initialImage, nil);
-    }
 
-    _isCapturing = NO;
-    self.captureCompletionHandler = nil;
+    [self completeCaptureWithCroppedImage:croppedImage initialImage:initialImage rectangle:rectangleFeature error:nil];
 }
 
 - (void)hideGLKView:(BOOL)hidden completion:(void(^)())completion

package/vendor/react-native-document-scanner/ios/RNPdfScannerManager.m

@@ -34,24 +34,37 @@ RCT_EXPORT_VIEW_PROPERTY(quality, float)
 RCT_EXPORT_VIEW_PROPERTY(brightness, float)
 RCT_EXPORT_VIEW_PROPERTY(contrast, float)
 
-RCT_EXPORT_METHOD(capture:(nonnull NSNumber *)reactTag) {
+// Main capture method - uses the last created scanner view
+RCT_EXPORT_METHOD(capture:(nullable NSNumber *)reactTag) {
     NSLog(@"[RNPdfScannerManager] capture called with reactTag: %@", reactTag);
     dispatch_async(dispatch_get_main_queue(), ^{
-        UIView *view = [self.bridge.uiManager viewForReactTag:reactTag];
-        if (!view || ![view isKindOfClass:[DocumentScannerView class]]) {
-            NSLog(@"[RNPdfScannerManager] Cannot find DocumentScannerView with tag #%@", reactTag);
+        DocumentScannerView *targetView = nil;
+
+        if (reactTag) {
+            UIView *view = [self.bridge.uiManager viewForReactTag:reactTag];
+            if ([view isKindOfClass:[DocumentScannerView class]]) {
+                targetView = (DocumentScannerView *)view;
+                self->_scannerView = targetView;
+            } else if (view) {
+                NSLog(@"[RNPdfScannerManager] View for tag %@ is not DocumentScannerView: %@", reactTag, NSStringFromClass(view.class));
+            } else {
+                NSLog(@"[RNPdfScannerManager] No view found for tag %@", reactTag);
+            }
+        }
+
+        if (!targetView && self->_scannerView) {
+            NSLog(@"[RNPdfScannerManager] Falling back to last known scanner view");
+            targetView = self->_scannerView;
+        }
+
+        if (!targetView) {
+            NSLog(@"[RNPdfScannerManager] ERROR: No scanner view available for capture");
             return;
         }
-        DocumentScannerView *scannerView = (DocumentScannerView *)view;
-        NSLog(@"[RNPdfScannerManager] Calling capture on view: %@", scannerView);
-        [scannerView capture];
-    });
-}
 
-// Deprecated - kept for backward compatibility
-RCT_EXPORT_METHOD(captureGlobal) {
-    NSLog(@"[RNPdfScannerManager] captureGlobal called (deprecated), scannerView: %@", _scannerView ? @"YES" : @"NO");
-    [_scannerView capture];
+        NSLog(@"[RNPdfScannerManager] Calling capture on view: %@", targetView);
+        [targetView capture];
+    });
 }
 
 - (UIView*) view {