@sagepilot-ai/react-native-camera-addon 0.3.0

package/android/src/main/java/ai/sagepilot/reactnativecameraaddon/SagepilotInAppCameraDebugEvents.java

@@ -0,0 +1,63 @@
+package ai.sagepilot.reactnativecameraaddon;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.modules.core.DeviceEventManagerModule;
+import java.lang.ref.WeakReference;
+
+final class SagepilotInAppCameraDebugEvents {
+  static final String EVENT_NAME = "SagepilotInAppCameraDebug";
+
+  private static WeakReference<ReactApplicationContext> reactContextRef = new WeakReference<>(null);
+
+  /** Prevents construction of the static camera debug-event bridge. */
+  private SagepilotInAppCameraDebugEvents() {}
+
+  /** Registers the active React context used to emit native camera debug events. */
+  static void register(ReactApplicationContext reactContext) {
+    reactContextRef = new WeakReference<>(reactContext);
+  }
+
+  /** Clears the active React context when the owning module is invalidated. */
+  static void unregister(ReactApplicationContext reactContext) {
+    ReactApplicationContext activeContext = reactContextRef.get();
+    if (activeContext == reactContext) {
+      reactContextRef.clear();
+    }
+  }
+
+  /** Emits an informational native camera debug event to JavaScript. */
+  static void debug(String message) {
+    emit("debug", message, null);
+  }
+
+  /** Emits a warning native camera debug event to JavaScript. */
+  static void warn(String message) {
+    emit("warn", message, null);
+  }
+
+  /** Emits an error native camera debug event to JavaScript. */
+  static void error(String message, Throwable error) {
+    emit("error", message, error == null ? null : error.getMessage());
+  }
+
+  /** Emits a native camera debug event when a live React context is available. */
+  private static void emit(String level, String message, String errorMessage) {
+    ReactApplicationContext reactContext = reactContextRef.get();
+    if (reactContext == null || !reactContext.hasActiveCatalystInstance()) {
+      return;
+    }
+
+    WritableMap payload = Arguments.createMap();
+    payload.putString("level", level);
+    payload.putString("message", message);
+    if (errorMessage != null) {
+      payload.putString("error", errorMessage);
+    }
+
+    reactContext
+      .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+      .emit(EVENT_NAME, payload);
+  }
+}

package/android/src/main/java/ai/sagepilot/reactnativecameraaddon/SagepilotInAppCameraImageProcessor.java

@@ -0,0 +1,278 @@
+package ai.sagepilot.reactnativecameraaddon;
+
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.graphics.Matrix;
+import android.util.Base64;
+import android.util.Log;
+import androidx.exifinterface.media.ExifInterface;
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+
+final class SagepilotInAppCameraImageProcessor {
+  private static final String TAG = "SagepilotInAppCamera";
+  private static final int BASE64_BUFFER_SIZE = 8192;
+  private static final int MIN_JPEG_QUALITY = 0;
+  private static final int MAX_JPEG_QUALITY = 100;
+
+  private final int maxDimension;
+  private final int jpegQuality;
+  private final long maxFileSizeBytes;
+
+  /** Creates a reusable processor for one native camera option set. */
+  SagepilotInAppCameraImageProcessor(int maxDimension, int jpegQuality, long maxFileSizeBytes) {
+    this.maxDimension = Math.max(1, maxDimension);
+    this.jpegQuality = Math.max(MIN_JPEG_QUALITY, Math.min(MAX_JPEG_QUALITY, jpegQuality));
+    this.maxFileSizeBytes = Math.max(0L, maxFileSizeBytes);
+    logDebug("ImageProcessor created maxDimension=" + this.maxDimension
+      + " jpegQuality=" + this.jpegQuality
+      + " maxFileSizeBytes=" + this.maxFileSizeBytes);
+  }
+
+  /** Normalizes, compresses, size-checks, and base64-encodes one captured JPEG. */
+  ProcessedImage process(File capturedFile, File processedFile) throws IOException, ImageTooLargeException {
+    logDebug("ImageProcessor process start capturedBytes=" + capturedFile.length()
+      + " capturedPath=" + capturedFile.getAbsolutePath());
+    int exifOrientation = readExifOrientation(capturedFile);
+    Bitmap decodedBitmap = null;
+    Bitmap normalizedBitmap = null;
+    Bitmap scaledBitmap = null;
+
+    try {
+      decodedBitmap = decodeSampledBitmap(capturedFile);
+      logBitmap("decoded", decodedBitmap);
+      normalizedBitmap = applyExifOrientation(decodedBitmap, exifOrientation);
+      if (normalizedBitmap != decodedBitmap) {
+        logBitmap("orientation-normalized", normalizedBitmap);
+        recycleBitmap(decodedBitmap);
+        decodedBitmap = null;
+      }
+
+      scaledBitmap = scaleToMaxDimension(normalizedBitmap);
+      if (scaledBitmap != normalizedBitmap) {
+        logBitmap("scaled", scaledBitmap);
+        recycleBitmap(normalizedBitmap);
+        normalizedBitmap = null;
+      }
+
+      writeJpeg(scaledBitmap, processedFile);
+      long sizeBytes = processedFile.length();
+      logDebug("ImageProcessor compressed outputBytes=" + sizeBytes
+        + " outputPath=" + processedFile.getAbsolutePath());
+      enforceMaxFileSize(sizeBytes);
+      String dataBase64 = readFileAsBase64(processedFile);
+      logDebug("ImageProcessor process success outputBytes=" + sizeBytes
+        + " base64Length=" + dataBase64.length());
+      return new ProcessedImage(sizeBytes, dataBase64);
+    } finally {
+      recycleBitmap(scaledBitmap);
+      recycleBitmap(normalizedBitmap);
+      recycleBitmap(decodedBitmap);
+      logDebug("ImageProcessor process cleanup complete");
+    }
+  }
+
+  /** Reads CameraX-written EXIF orientation metadata from the saved JPEG. */
+  private int readExifOrientation(File file) throws IOException {
+    ExifInterface exifInterface = new ExifInterface(file.getAbsolutePath());
+    int orientation = exifInterface.getAttributeInt(ExifInterface.TAG_ORIENTATION, ExifInterface.ORIENTATION_NORMAL);
+    logDebug("ImageProcessor EXIF orientation=" + orientation);
+    return orientation;
+  }
+
+  /** Decodes only image bounds so the full bitmap can be sampled before allocation. */
+  private BitmapFactory.Options decodeBounds(File file) throws IOException {
+    BitmapFactory.Options boundsOptions = new BitmapFactory.Options();
+    boundsOptions.inJustDecodeBounds = true;
+    BitmapFactory.decodeFile(file.getAbsolutePath(), boundsOptions);
+
+    if (boundsOptions.outWidth <= 0 || boundsOptions.outHeight <= 0) {
+      throw new IOException("Could not read image bounds.");
+    }
+
+    logDebug("ImageProcessor bounds width=" + boundsOptions.outWidth
+      + " height=" + boundsOptions.outHeight
+      + " mime=" + boundsOptions.outMimeType);
+    return boundsOptions;
+  }
+
+  /** Decodes the captured JPEG with a power-of-two sample size near the target edge. */
+  private Bitmap decodeSampledBitmap(File file) throws IOException {
+    BitmapFactory.Options boundsOptions = decodeBounds(file);
+    BitmapFactory.Options decodeOptions = new BitmapFactory.Options();
+    decodeOptions.inSampleSize = calculateSampleSize(boundsOptions.outWidth, boundsOptions.outHeight);
+    decodeOptions.inPreferredConfig = Bitmap.Config.ARGB_8888;
+    logDebug("ImageProcessor decode sampleSize=" + decodeOptions.inSampleSize);
+
+    Bitmap bitmap = BitmapFactory.decodeFile(file.getAbsolutePath(), decodeOptions);
+    if (bitmap == null) {
+      throw new IOException("Could not decode image.");
+    }
+    return bitmap;
+  }
+
+  /** Calculates a sample size that avoids full-resolution allocation for large sensors. */
+  private int calculateSampleSize(int width, int height) {
+    int longestEdge = Math.max(width, height);
+    int sampleSize = 1;
+    while ((longestEdge / (sampleSize * 2)) >= maxDimension) {
+      sampleSize *= 2;
+    }
+    int calculatedSampleSize = Math.max(1, sampleSize);
+    logDebug("ImageProcessor calculated sampleSize=" + calculatedSampleSize
+      + " sourceWidth=" + width
+      + " sourceHeight=" + height
+      + " maxDimension=" + maxDimension);
+    return calculatedSampleSize;
+  }
+
+  /** Applies EXIF rotation and mirroring so the output pixels are orientation-normalized. */
+  private Bitmap applyExifOrientation(Bitmap bitmap, int exifOrientation) {
+    Matrix matrix = createExifMatrix(exifOrientation);
+    if (matrix.isIdentity()) {
+      logDebug("ImageProcessor EXIF transform not needed");
+      return bitmap;
+    }
+    logDebug("ImageProcessor applying EXIF transform orientation=" + exifOrientation);
+    return Bitmap.createBitmap(bitmap, 0, 0, bitmap.getWidth(), bitmap.getHeight(), matrix, true);
+  }
+
+  /** Builds a pixel transform for all EXIF orientation and mirror variants. */
+  private Matrix createExifMatrix(int exifOrientation) {
+    Matrix matrix = new Matrix();
+    switch (exifOrientation) {
+      case ExifInterface.ORIENTATION_FLIP_HORIZONTAL:
+        matrix.setScale(-1.0f, 1.0f);
+        break;
+      case ExifInterface.ORIENTATION_ROTATE_180:
+        matrix.setRotate(180.0f);
+        break;
+      case ExifInterface.ORIENTATION_FLIP_VERTICAL:
+        matrix.setRotate(180.0f);
+        matrix.postScale(-1.0f, 1.0f);
+        break;
+      case ExifInterface.ORIENTATION_TRANSPOSE:
+        matrix.setRotate(90.0f);
+        matrix.postScale(-1.0f, 1.0f);
+        break;
+      case ExifInterface.ORIENTATION_ROTATE_90:
+        matrix.setRotate(90.0f);
+        break;
+      case ExifInterface.ORIENTATION_TRANSVERSE:
+        matrix.setRotate(-90.0f);
+        matrix.postScale(-1.0f, 1.0f);
+        break;
+      case ExifInterface.ORIENTATION_ROTATE_270:
+        matrix.setRotate(-90.0f);
+        break;
+      default:
+        break;
+    }
+    return matrix;
+  }
+
+  /** Downscales the normalized bitmap when its longest edge exceeds the configured cap. */
+  private Bitmap scaleToMaxDimension(Bitmap bitmap) {
+    int width = bitmap.getWidth();
+    int height = bitmap.getHeight();
+    int longestEdge = Math.max(width, height);
+
+    if (longestEdge <= maxDimension) {
+      logDebug("ImageProcessor scaling not needed width=" + width + " height=" + height);
+      return bitmap;
+    }
+
+    float scale = (float) maxDimension / (float) longestEdge;
+    int targetWidth = Math.max(1, Math.round(width * scale));
+    int targetHeight = Math.max(1, Math.round(height * scale));
+    logDebug("ImageProcessor scaling width=" + width
+      + " height=" + height
+      + " targetWidth=" + targetWidth
+      + " targetHeight=" + targetHeight);
+    return Bitmap.createScaledBitmap(bitmap, targetWidth, targetHeight, true);
+  }
+
+  /** Compresses the final normalized bitmap into the processed JPEG file. */
+  private void writeJpeg(Bitmap bitmap, File outputFile) throws IOException {
+    logDebug("ImageProcessor compressing JPEG quality=" + jpegQuality);
+    try (FileOutputStream outputStream = new FileOutputStream(outputFile)) {
+      if (!bitmap.compress(Bitmap.CompressFormat.JPEG, jpegQuality, outputStream)) {
+        throw new IOException("Could not compress JPEG.");
+      }
+      outputStream.flush();
+    }
+  }
+
+  /** Rejects compressed output that exceeds the bridge image size cap. */
+  private void enforceMaxFileSize(long sizeBytes) throws ImageTooLargeException {
+    if (maxFileSizeBytes > 0L && sizeBytes > maxFileSizeBytes) {
+      logWarn("ImageProcessor output too large sizeBytes=" + sizeBytes
+        + " maxFileSizeBytes=" + maxFileSizeBytes);
+      throw new ImageTooLargeException(sizeBytes, maxFileSizeBytes);
+    }
+  }
+
+  /** Reads a bounded processed JPEG into a base64 payload without line wrapping. */
+  private String readFileAsBase64(File file) throws IOException {
+    logDebug("ImageProcessor reading base64 bytes=" + file.length());
+    try (FileInputStream inputStream = new FileInputStream(file);
+         ByteArrayOutputStream outputStream = new ByteArrayOutputStream((int) Math.min(file.length(), 1024L * 1024L))) {
+      byte[] buffer = new byte[BASE64_BUFFER_SIZE];
+      int bytesRead;
+      while ((bytesRead = inputStream.read(buffer)) != -1) {
+        outputStream.write(buffer, 0, bytesRead);
+      }
+      return Base64.encodeToString(outputStream.toByteArray(), Base64.NO_WRAP);
+    }
+  }
+
+  /** Recycles a bitmap when it is no longer needed by the processor. */
+  private void recycleBitmap(Bitmap bitmap) {
+    if (bitmap != null && !bitmap.isRecycled()) {
+      logDebug("ImageProcessor recycling bitmap width=" + bitmap.getWidth() + " height=" + bitmap.getHeight());
+      bitmap.recycle();
+    }
+  }
+
+  /** Logs decoded or transformed bitmap dimensions without reading pixel data. */
+  private void logBitmap(String label, Bitmap bitmap) {
+    logDebug("ImageProcessor " + label + " bitmap width=" + bitmap.getWidth()
+      + " height=" + bitmap.getHeight()
+      + " bytes=" + bitmap.getByteCount());
+  }
+
+  /** Writes a native debug log and mirrors it into the React Native console. */
+  private void logDebug(String message) {
+    Log.d(TAG, message);
+    SagepilotInAppCameraDebugEvents.debug(message);
+  }
+
+  /** Writes a native warning log and mirrors it into the React Native console. */
+  private void logWarn(String message) {
+    Log.w(TAG, message);
+    SagepilotInAppCameraDebugEvents.warn(message);
+  }
+
+  static final class ProcessedImage {
+    final long sizeBytes;
+    final String dataBase64;
+
+    /** Stores the bridge-ready processed image payload. */
+    ProcessedImage(long sizeBytes, String dataBase64) {
+      this.sizeBytes = sizeBytes;
+      this.dataBase64 = dataBase64;
+    }
+  }
+
+  static final class ImageTooLargeException extends Exception {
+    private static final long serialVersionUID = 1L;
+
+    /** Creates a size-cap failure with actual and allowed byte counts. */
+    ImageTooLargeException(long actualSizeBytes, long maxSizeBytes) {
+      super("Processed image is too large: " + actualSizeBytes + " > " + maxSizeBytes);
+    }
+  }
+}