react-native-capture-studio 0.1.0

package/ios/CaptureStudio.mm

@@ -0,0 +1,186 @@
+#import "CaptureStudio.h"
+#import "ImageProcessor.h"
+#import <ImageIO/ImageIO.h>
+#import <CoreGraphics/CoreGraphics.h>
+#import <UIKit/UIKit.h>
+
+// Store active operations and results
+static NSMutableDictionary<NSString *, NSOperationQueue *> *operationQueues;
+static NSMutableDictionary<NSString *, NSDictionary *> *operationResults;
+
+@implementation CaptureStudio
+
+RCT_EXPORT_MODULE()
+
++ (void)initialize {
+    if (self == [CaptureStudio class]) {
+        operationQueues = [NSMutableDictionary new];
+        operationResults = [NSMutableDictionary new];
+    }
+}
+
+#pragma mark - openCaptureStudio
+
+- (void)openCaptureStudio:(NSDictionary *)options
+                  resolve:(RCTPromiseResolveBlock)resolve
+                   reject:(RCTPromiseRejectBlock)reject
+{
+    // TODO: Implement camera capture UI
+    resolve(@{@"status": @"not_implemented"});
+}
+
+#pragma mark - processImages
+
+- (void)processImages:(NSArray *)images
+              resolve:(RCTPromiseResolveBlock)resolve
+               reject:(RCTPromiseRejectBlock)reject
+{
+    if (!images || images.count == 0) {
+        reject(@"INVALID_INPUT", @"No images provided", nil);
+        return;
+    }
+
+    NSString *operationId = [[NSUUID UUID] UUIDString];
+
+    // Create operation queue for background processing
+    NSOperationQueue *queue = [[NSOperationQueue alloc] init];
+    queue.name = [NSString stringWithFormat:@"ImageProcessing-%@", operationId];
+    queue.maxConcurrentOperationCount = 1; // Sequential processing
+    queue.qualityOfService = NSQualityOfServiceUserInitiated;
+
+    @synchronized (operationQueues) {
+        operationQueues[operationId] = queue;
+    }
+
+    // Create operation for processing
+    // Copy operationId for use in block
+    NSString *opId = [operationId copy];
+
+    NSBlockOperation *operation = [NSBlockOperation blockOperationWithBlock:^{
+        NSMutableArray *results = [NSMutableArray new];
+
+        for (NSDictionary *imageInfo in images) {
+            @autoreleasepool {
+                NSString *localPath = imageInfo[@"localPath"];
+                NSString *timeStamp = imageInfo[@"timeStamp"];
+                BOOL isForOnlyWatermark = [imageInfo[@"isForOnlyWatermark"] boolValue];
+                BOOL compressJpeg = [imageInfo[@"compressJpegImage"] boolValue];
+                // Default to YES (replace original) if not specified
+                BOOL replaceOriginal = imageInfo[@"replaceOriginal"] != nil ?
+                    [imageInfo[@"replaceOriginal"] boolValue] : YES;
+
+                // Skip invalid entries
+                if (!localPath || localPath.length == 0 ||
+                    [localPath isEqualToString:@"undefined"]) {
+                    continue;
+                }
+
+                // Remove file:// prefix if present
+                NSString *cleanPath = [localPath stringByReplacingOccurrencesOfString:@"file://"
+                                                                           withString:@""];
+
+                // Check if file exists
+                if (![[NSFileManager defaultManager] fileExistsAtPath:cleanPath]) {
+                    [results addObject:@{
+                        @"localPath": localPath,
+                        @"outputPath": localPath,
+                        @"success": @(NO),
+                        @"error": @"File not found"
+                    }];
+                    continue;
+                }
+
+                ImageProcessorResult *processorResult = [ImageProcessor processImageAtPath:cleanPath
+                                                                                 timeStamp:timeStamp ?: @""
+                                                                        isForOnlyWatermark:isForOnlyWatermark
+                                                                              compressJpeg:compressJpeg
+                                                                           replaceOriginal:replaceOriginal];
+
+                // Add file:// prefix back to output path for consistency
+                NSString *outputPathWithPrefix = [NSString stringWithFormat:@"file://%@",
+                                                  processorResult.outputPath];
+
+                [results addObject:@{
+                    @"localPath": localPath,
+                    @"outputPath": outputPathWithPrefix,
+                    @"success": @(processorResult.success),
+                    @"error": processorResult.error ? processorResult.error.localizedDescription : [NSNull null]
+                }];
+            }
+        }
+
+        // Store results
+        @synchronized (operationResults) {
+            operationResults[opId] = @{
+                @"status": @"completed",
+                @"processedImages": results
+            };
+        }
+    }];
+
+    [queue addOperation:operation];
+
+    // Return operation ID immediately
+    resolve(operationId);
+}
+
+#pragma mark - fetchProcessingResult
+
+- (void)fetchProcessingResult:(NSString *)operationId
+                      resolve:(RCTPromiseResolveBlock)resolve
+                       reject:(RCTPromiseRejectBlock)reject
+{
+    if (!operationId || operationId.length == 0) {
+        reject(@"INVALID_INPUT", @"Operation ID is required", nil);
+        return;
+    }
+
+    NSDictionary *result = nil;
+    NSOperationQueue *queue = nil;
+
+    @synchronized (operationResults) {
+        result = operationResults[operationId];
+    }
+
+    if (result) {
+        NSError *jsonError;
+        NSData *jsonData = [NSJSONSerialization dataWithJSONObject:result
+                                                           options:0
+                                                             error:&jsonError];
+        if (jsonData) {
+            NSString *jsonString = [[NSString alloc] initWithData:jsonData
+                                                         encoding:NSUTF8StringEncoding];
+            // Cleanup
+            @synchronized (operationQueues) {
+                [operationQueues removeObjectForKey:operationId];
+            }
+            @synchronized (operationResults) {
+                [operationResults removeObjectForKey:operationId];
+            }
+            resolve(jsonString);
+        } else {
+            reject(@"JSON_ERROR", @"Failed to serialize result", jsonError);
+        }
+    } else {
+        // Check if operation is still running
+        @synchronized (operationQueues) {
+            queue = operationQueues[operationId];
+        }
+
+        if (queue && queue.operationCount > 0) {
+            resolve(@"{\"status\":\"processing\"}");
+        } else {
+            reject(@"NOT_FOUND", @"Operation not found", nil);
+        }
+    }
+}
+
+#pragma mark - TurboModule
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params
+{
+    return std::make_shared<facebook::react::NativeCaptureStudioSpecJSI>(params);
+}
+
+@end

package/ios/ImageProcessor.h

@@ -0,0 +1,22 @@
+#import <Foundation/Foundation.h>
+#import <CoreGraphics/CoreGraphics.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface ImageProcessorResult : NSObject
+@property (nonatomic, strong) NSString *outputPath;
+@property (nonatomic, assign) BOOL success;
+@property (nonatomic, strong, nullable) NSError *error;
+@end
+
+@interface ImageProcessor : NSObject
+
++ (ImageProcessorResult *)processImageAtPath:(NSString *)path
+                                   timeStamp:(NSString *)timeStamp
+                          isForOnlyWatermark:(BOOL)isForOnlyWatermark
+                                compressJpeg:(BOOL)compressJpeg
+                             replaceOriginal:(BOOL)replaceOriginal;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/ImageProcessor.mm

@@ -0,0 +1,383 @@
+#import "ImageProcessor.h"
+#import <ImageIO/ImageIO.h>
+#import <UIKit/UIKit.h>
+#import <UniformTypeIdentifiers/UniformTypeIdentifiers.h>
+#import <CoreImage/CoreImage.h>
+
+@implementation ImageProcessorResult
+@end
+
+@implementation ImageProcessor
+
+#pragma mark - Public API
+
++ (ImageProcessorResult *)processImageAtPath:(NSString *)path
+                                   timeStamp:(NSString *)timeStamp
+                          isForOnlyWatermark:(BOOL)isForOnlyWatermark
+                                compressJpeg:(BOOL)compressJpeg
+                             replaceOriginal:(BOOL)replaceOriginal
+{
+    ImageProcessorResult *result = [[ImageProcessorResult alloc] init];
+    result.success = NO;
+    result.outputPath = path; // Always return original path (like Android)
+
+    @autoreleasepool {
+        // 1. Load image
+        NSURL *fileURL = [NSURL fileURLWithPath:path];
+        CGImageSourceRef source = CGImageSourceCreateWithURL((__bridge CFURLRef)fileURL, NULL);
+
+        if (!source) {
+            result.error = [NSError errorWithDomain:@"ImageProcessor"
+                                               code:1
+                                           userInfo:@{NSLocalizedDescriptionKey: @"Failed to load image"}];
+            return result;
+        }
+
+        CGImageRef originalImage = CGImageSourceCreateImageAtIndex(source, 0, NULL);
+        CFRelease(source);
+
+        if (!originalImage) {
+            result.error = [NSError errorWithDomain:@"ImageProcessor"
+                                               code:2
+                                           userInfo:@{NSLocalizedDescriptionKey: @"Failed to decode image"}];
+            return result;
+        }
+
+        // 2. Get EXIF orientation and rotate if needed
+        CGImageRef rotatedImage = [self createRotatedImage:originalImage fromPath:path];
+        CGImageRelease(originalImage);
+
+        if (!rotatedImage) {
+            result.error = [NSError errorWithDomain:@"ImageProcessor"
+                                               code:5
+                                           userInfo:@{NSLocalizedDescriptionKey: @"Failed to rotate image"}];
+            return result;
+        }
+
+        // 3. Add watermark
+        CGImageRef watermarkedImage = [self createWatermarkedImage:rotatedImage withText:timeStamp];
+        CGImageRelease(rotatedImage);
+
+        if (!watermarkedImage) {
+            result.error = [NSError errorWithDomain:@"ImageProcessor"
+                                               code:6
+                                           userInfo:@{NSLocalizedDescriptionKey: @"Failed to add watermark"}];
+            return result;
+        }
+
+        // 4. Output path - ALWAYS use original path (like Android)
+        // This overwrites the original file with WebP/JPEG data
+        // The path stays the same regardless of format change
+        NSString *outputPath = path;
+        result.outputPath = outputPath;
+
+        // 5. Compress to target size (300-500KB)
+        // Use WebP by default (better quality at smaller sizes), JPEG only if explicitly requested
+        NSInteger minSizeKB = isForOnlyWatermark ? 400 : 300;
+        NSInteger maxSizeKB = 500;
+
+        NSError *compressError = nil;
+        BOOL success = [self compressImage:watermarkedImage
+                                    toPath:outputPath
+                                 minSizeKB:minSizeKB
+                                 maxSizeKB:maxSizeKB
+                              compressJpeg:compressJpeg
+                                     error:&compressError];
+
+        CGImageRelease(watermarkedImage);
+
+        result.success = success;
+        result.error = compressError;
+
+        return result;
+    }
+}
+
+#pragma mark - Generate New Path
+
++ (NSString *)generateNewPath:(NSString *)originalPath compressJpeg:(BOOL)compressJpeg
+{
+    NSString *directory = [originalPath stringByDeletingLastPathComponent];
+    NSString *filename = [originalPath lastPathComponent];
+    NSString *nameWithoutExt = [filename stringByDeletingPathExtension];
+
+    // Generate timestamp for unique filename
+    NSDateFormatter *formatter = [[NSDateFormatter alloc] init];
+    [formatter setDateFormat:@"yyyyMMdd_HHmmss"];
+    NSString *timestamp = [formatter stringFromDate:[NSDate date]];
+
+    // Determine extension based on format
+    NSString *extension = compressJpeg ? @"jpg" : @"webp";
+
+    // Check if WebP is supported, fallback to jpg
+    if (!compressJpeg) {
+        CFArrayRef supportedTypes = CGImageDestinationCopyTypeIdentifiers();
+        BOOL webpSupported = NO;
+        CFStringRef webpType = (__bridge CFStringRef)UTTypeWebP.identifier;
+
+        for (CFIndex i = 0; i < CFArrayGetCount(supportedTypes); i++) {
+            CFStringRef type = (CFStringRef)CFArrayGetValueAtIndex(supportedTypes, i);
+            if (CFStringCompare(type, webpType, 0) == kCFCompareEqualTo) {
+                webpSupported = YES;
+                break;
+            }
+        }
+        CFRelease(supportedTypes);
+
+        if (!webpSupported) {
+            extension = @"jpg";
+        }
+    }
+
+    // Create new filename: originalName_compressed_timestamp.ext
+    NSString *newFilename = [NSString stringWithFormat:@"%@_compressed_%@.%@",
+                             nameWithoutExt, timestamp, extension];
+
+    return [directory stringByAppendingPathComponent:newFilename];
+}
+
+#pragma mark - Image Rotation (EXIF)
+
++ (CGImageRef)createRotatedImage:(CGImageRef)image fromPath:(NSString *)path
+{
+    // Read EXIF orientation
+    NSURL *fileURL = [NSURL fileURLWithPath:path];
+    CGImageSourceRef source = CGImageSourceCreateWithURL((__bridge CFURLRef)fileURL, NULL);
+
+    if (!source) {
+        CGImageRetain(image);
+        return image;
+    }
+
+    NSDictionary *properties = (__bridge_transfer NSDictionary *)
+        CGImageSourceCopyPropertiesAtIndex(source, 0, NULL);
+    CFRelease(source);
+
+    NSNumber *orientationValue = properties[(__bridge NSString *)kCGImagePropertyOrientation];
+    CGImagePropertyOrientation orientation = orientationValue ?
+        (CGImagePropertyOrientation)[orientationValue intValue] :
+        kCGImagePropertyOrientationUp;
+
+    if (orientation == kCGImagePropertyOrientationUp) {
+        CGImageRetain(image);
+        return image;
+    }
+
+    // Create rotated image using CIImage (handles all EXIF orientations)
+    CIImage *ciImage = [CIImage imageWithCGImage:image];
+    ciImage = [ciImage imageByApplyingOrientation:orientation];
+
+    CIContext *context = [CIContext contextWithOptions:nil];
+    CGImageRef rotated = [context createCGImage:ciImage fromRect:ciImage.extent];
+
+    return rotated;
+}
+
+#pragma mark - Watermark
+
++ (CGImageRef)createWatermarkedImage:(CGImageRef)image withText:(NSString *)text
+{
+    if (!text || text.length == 0) {
+        CGImageRetain(image);
+        return image;
+    }
+
+    size_t width = CGImageGetWidth(image);
+    size_t height = CGImageGetHeight(image);
+
+    // Create bitmap context
+    CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();
+    CGContextRef context = CGBitmapContextCreate(NULL, width, height, 8,
+                                                  width * 4, colorSpace,
+                                                  kCGImageAlphaPremultipliedLast);
+    CGColorSpaceRelease(colorSpace);
+
+    if (!context) {
+        CGImageRetain(image);
+        return image;
+    }
+
+    // Draw original image
+    CGContextDrawImage(context, CGRectMake(0, 0, width, height), image);
+
+    // Calculate sizes relative to image (matching Android)
+    CGFloat textSize = width / 40.0;
+    CGFloat padding = width / 50.0;
+
+    // Create attributed string for measurement
+    UIFont *font = [UIFont systemFontOfSize:textSize weight:UIFontWeightRegular];
+    NSDictionary *attributes = @{
+        NSFontAttributeName: font,
+        NSForegroundColorAttributeName: [UIColor yellowColor]
+    };
+
+    CGSize textSizeRect = [text sizeWithAttributes:attributes];
+
+    // Calculate position (bottom-right, matching Android)
+    CGFloat bgWidth = textSizeRect.width + 2 * padding;
+    CGFloat bgHeight = textSizeRect.height + 2 * padding;
+    CGFloat x = width - bgWidth - padding;
+    CGFloat y = padding;  // CoreGraphics origin is bottom-left
+
+    // Draw black background rectangle
+    CGContextSetFillColorWithColor(context, [UIColor blackColor].CGColor);
+    CGContextFillRect(context, CGRectMake(x, y, bgWidth, bgHeight));
+
+    // Draw text using UIGraphics (push context)
+    UIGraphicsPushContext(context);
+
+    // Flip coordinate system for text
+    CGContextTranslateCTM(context, 0, height);
+    CGContextScaleCTM(context, 1.0, -1.0);
+
+    // Recalculate Y for flipped coordinates
+    CGFloat textY = height - y - bgHeight + padding;
+
+    [text drawAtPoint:CGPointMake(x + padding, textY) withAttributes:attributes];
+
+    UIGraphicsPopContext();
+
+    // Create final image
+    CGImageRef result = CGBitmapContextCreateImage(context);
+    CGContextRelease(context);
+
+    return result;
+}
+
+#pragma mark - Compression (Binary Search for Target Size)
+
++ (BOOL)compressImage:(CGImageRef)image
+               toPath:(NSString *)path
+            minSizeKB:(NSInteger)minSizeKB
+            maxSizeKB:(NSInteger)maxSizeKB
+         compressJpeg:(BOOL)compressJpeg
+                error:(NSError **)error
+{
+    // Use UTType for iOS 14+
+    CFStringRef imageType;
+
+    if (compressJpeg) {
+        imageType = (__bridge CFStringRef)UTTypeJPEG.identifier;
+    } else {
+        // Check if WebP is supported
+        CFArrayRef supportedTypes = CGImageDestinationCopyTypeIdentifiers();
+        BOOL webpSupported = NO;
+        CFStringRef webpType = (__bridge CFStringRef)UTTypeWebP.identifier;
+
+        for (CFIndex i = 0; i < CFArrayGetCount(supportedTypes); i++) {
+            CFStringRef type = (CFStringRef)CFArrayGetValueAtIndex(supportedTypes, i);
+            if (CFStringCompare(type, webpType, 0) == kCFCompareEqualTo) {
+                webpSupported = YES;
+                break;
+            }
+        }
+        CFRelease(supportedTypes);
+
+        if (webpSupported) {
+            imageType = webpType;
+        } else {
+            // Fallback to JPEG
+            imageType = (__bridge CFStringRef)UTTypeJPEG.identifier;
+        }
+    }
+
+    // Binary search for optimal quality (matching Android algorithm)
+    // Start with quality=100 and find optimal quality for 300-500KB range
+    NSInteger low = 0;
+    NSInteger high = 100;
+    NSInteger bestQuality = 100;
+    NSData *bestData = nil;
+    NSData *highestQualityValidData = nil;  // Highest quality within range
+    NSInteger highestQualityFound = 0;
+
+    while (low <= high) {
+        NSInteger quality = (low + high) / 2;
+        CGFloat qualityFloat = quality / 100.0;
+
+        NSMutableData *imageData = [NSMutableData data];
+        CGImageDestinationRef destination = CGImageDestinationCreateWithData(
+            (__bridge CFMutableDataRef)imageData,
+            imageType,
+            1,
+            NULL
+        );
+
+        if (!destination) {
+            if (error) {
+                *error = [NSError errorWithDomain:@"ImageProcessor"
+                                             code:3
+                                         userInfo:@{NSLocalizedDescriptionKey: @"Failed to create image destination"}];
+            }
+            return NO;
+        }
+
+        NSDictionary *options = @{
+            (__bridge NSString *)kCGImageDestinationLossyCompressionQuality: @(qualityFloat)
+        };
+
+        CGImageDestinationAddImage(destination, image, (__bridge CFDictionaryRef)options);
+        BOOL finalized = CGImageDestinationFinalize(destination);
+        CFRelease(destination);
+
+        if (!finalized) {
+            if (error) {
+                *error = [NSError errorWithDomain:@"ImageProcessor"
+                                             code:7
+                                         userInfo:@{NSLocalizedDescriptionKey: @"Failed to finalize image"}];
+            }
+            return NO;
+        }
+
+        NSInteger fileSizeKB = imageData.length / 1024;
+
+        if (fileSizeKB < minSizeKB) {
+            // Size too small, increase quality
+            low = quality + 1;
+            bestData = imageData;
+            bestQuality = quality;
+        } else if (fileSizeKB > maxSizeKB) {
+            // Size too large, decrease quality
+            high = quality - 1;
+            bestData = imageData;
+            bestQuality = quality;
+        } else {
+            // Within range - keep track of highest quality within range
+            if (quality > highestQualityFound) {
+                highestQualityFound = quality;
+                highestQualityValidData = imageData;
+            }
+            // Try to find higher quality within range
+            low = quality + 1;
+            bestData = imageData;
+            bestQuality = quality;
+        }
+    }
+
+    // Prefer highest quality data that was within the valid range
+    if (highestQualityValidData) {
+        bestData = highestQualityValidData;
+    }
+
+    if (!bestData) {
+        if (error) {
+            *error = [NSError errorWithDomain:@"ImageProcessor"
+                                         code:8
+                                     userInfo:@{NSLocalizedDescriptionKey: @"Failed to compress image"}];
+        }
+        return NO;
+    }
+
+    // Write to file
+    NSError *writeError = nil;
+    BOOL success = [bestData writeToFile:path options:NSDataWritingAtomic error:&writeError];
+
+    if (!success && error) {
+        *error = writeError ?: [NSError errorWithDomain:@"ImageProcessor"
+                                                   code:4
+                                               userInfo:@{NSLocalizedDescriptionKey: @"Failed to write image"}];
+    }
+
+    return success;
+}
+
+@end

package/ios/generated/Package.swift

@@ -0,0 +1,59 @@
+// swift-tools-version: 6.1
+// The swift-tools-version declares the minimum version of Swift required to build this package.
+
+import PackageDescription
+
+let package = Package(
+    name: "React-GeneratedCode",
+    platforms: [.iOS(.v15), .macCatalyst(SupportedPlatform.MacCatalystVersion.v13)],
+    products: [
+        // Products define the executables and libraries a package produces, making them visible to other packages.
+        .library(
+            name: "ReactCodegen",
+            targets: ["ReactCodegen"]),
+        .library(
+            name: "ReactAppDependencyProvider",
+            targets: ["ReactAppDependencyProvider"]),
+    ],
+    dependencies: [
+      .package(name: "React", path: "../../../../../../../node_modules/react-native")
+    ],
+    targets: [
+        // Targets are the basic building blocks of a package, defining a module or a test suite.
+        // Targets can depend on other targets in this package and products from dependencies.
+        .target(
+            name: "ReactCodegen",
+            dependencies: ["React"],
+            path: "ReactCodegen",
+            exclude: ["ReactCodegen.podspec"],
+            publicHeadersPath: ".",
+            cSettings: [
+              .headerSearchPath("headers")
+            ],
+            cxxSettings: [
+              .headerSearchPath("headers"),
+              .unsafeFlags(["-std=c++20"]),
+            ],
+            linkerSettings: [
+              .linkedFramework("Foundation")
+            ]
+        ),
+        .target(
+          name: "ReactAppDependencyProvider",
+          dependencies: ["ReactCodegen"],
+          path: "ReactAppDependencyProvider",
+          exclude: ["ReactAppDependencyProvider.podspec"],
+          publicHeadersPath: ".",
+          cSettings: [
+            .headerSearchPath("headers"),
+          ],
+          cxxSettings: [
+            .headerSearchPath("headers"),
+            .unsafeFlags(["-std=c++20"]),
+          ],
+          linkerSettings: [
+            .linkedFramework("Foundation")
+          ]
+        )
+    ]
+)

package/ios/generated/ReactAppDependencyProvider/RCTAppDependencyProvider.h

@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+
+#import <Foundation/Foundation.h>
+
+#if __has_include(<React-RCTAppDelegate/RCTDependencyProvider.h>)
+#import <React-RCTAppDelegate/RCTDependencyProvider.h>
+#elif __has_include(<React_RCTAppDelegate/RCTDependencyProvider.h>)
+#import <React_RCTAppDelegate/RCTDependencyProvider.h>
+#else
+#import "RCTDependencyProvider.h"
+#endif
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface RCTAppDependencyProvider : NSObject <RCTDependencyProvider>
+
+@end
+
+NS_ASSUME_NONNULL_END