@capgo/camera-preview 6.1.5 → 6.1.6

package/README.md

@@ -55,6 +55,9 @@ Open `android/app/src/main/AndroidManifest.xml` and above the closing `</manifes
 
 ```xml
 <uses-permission android:name="android.permission.CAMERA" />
+<uses-permission android:name="android.permission.RECORD_AUDIO" />
+<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
+
 ```
 
 For more help consult the [Capacitor docs](https://capacitorjs.com/docs/android/configuration#configuring-androidmanifestxml).
@@ -71,17 +74,6 @@ Add `import '@capgo/camera-preview'` to you entry script in ionic on `app.module
 
 <docgen-index>
 
-* [`start(...)`](#start)
-* [`stop()`](#stop)
-* [`capture(...)`](#capture)
-* [`captureSample(...)`](#capturesample)
-* [`getSupportedFlashModes()`](#getsupportedflashmodes)
-* [`getHorizontalFov()`](#gethorizontalfov)
-* [`setFlashMode(...)`](#setflashmode)
-* [`flip()`](#flip)
-* [`setOpacity(...)`](#setopacity)
-* [`stopRecordVideo()`](#stoprecordvideo)
-* [`startRecordVideo(...)`](#startrecordvideo)
 * [Interfaces](#interfaces)
 * [Type Aliases](#type-aliases)
 
@@ -90,195 +82,6 @@ Add `import '@capgo/camera-preview'` to you entry script in ionic on `app.module
 <docgen-api>
 <!--Update the source file JSDoc comments and rerun docgen to update the docs below-->
 
-### start(...)
-
-```typescript
-start(options: CameraPreviewOptions) => any
-```
-
-Start the camera preview instance.
-
-| Param         | Type                                                                  | Description                                  |
-| ------------- | --------------------------------------------------------------------- | -------------------------------------------- |
-| **`options`** | <code><a href="#camerapreviewoptions">CameraPreviewOptions</a></code> | the options to start the camera preview with |
-
-**Returns:** <code>any</code>
-
-**Since:** 0.0.1
-
---------------------
-
-
-### stop()
-
-```typescript
-stop() => any
-```
-
-Stop the camera preview instance.
-
-**Returns:** <code>any</code>
-
-**Since:** 0.0.1
-
---------------------
-
-
-### capture(...)
-
-```typescript
-capture(options: CameraPreviewPictureOptions) => any
-```
-
-Switch camera.
-
-| Param         | Type                                                                                | Description                           |
-| ------------- | ----------------------------------------------------------------------------------- | ------------------------------------- |
-| **`options`** | <code><a href="#camerapreviewpictureoptions">CameraPreviewPictureOptions</a></code> | the options to switch the camera with |
-
-**Returns:** <code>any</code>
-
-**Since:** 0.0.1
-
---------------------
-
-
-### captureSample(...)
-
-```typescript
-captureSample(options: CameraSampleOptions) => any
-```
-
-Capture a sample image.
-
-| Param         | Type                                                                | Description                                  |
-| ------------- | ------------------------------------------------------------------- | -------------------------------------------- |
-| **`options`** | <code><a href="#camerasampleoptions">CameraSampleOptions</a></code> | the options to capture the sample image with |
-
-**Returns:** <code>any</code>
-
-**Since:** 0.0.1
-
---------------------
-
-
-### getSupportedFlashModes()
-
-```typescript
-getSupportedFlashModes() => any
-```
-
-Get supported flash modes.
-
-**Returns:** <code>any</code>
-
-**Since:** 0.0.1
-
---------------------
-
-
-### getHorizontalFov()
-
-```typescript
-getHorizontalFov() => any
-```
-
-Get horizontal field of view.
-
-**Returns:** <code>any</code>
-
-**Since:** 0.0.1
-
---------------------
-
-
-### setFlashMode(...)
-
-```typescript
-setFlashMode(options: { flashMode: CameraPreviewFlashMode | string; }) => any
-```
-
-Set flash mode.
-
-| Param         | Type                                | Description                            |
-| ------------- | ----------------------------------- | -------------------------------------- |
-| **`options`** | <code>{ flashMode: string; }</code> | the options to set the flash mode with |
-
-**Returns:** <code>any</code>
-
-**Since:** 0.0.1
-
---------------------
-
-
-### flip()
-
-```typescript
-flip() => any
-```
-
-Flip camera.
-
-**Returns:** <code>any</code>
-
-**Since:** 0.0.1
-
---------------------
-
-
-### setOpacity(...)
-
-```typescript
-setOpacity(options: CameraOpacityOptions) => any
-```
-
-Set opacity.
-
-| Param         | Type                                                                  | Description                                |
-| ------------- | --------------------------------------------------------------------- | ------------------------------------------ |
-| **`options`** | <code><a href="#cameraopacityoptions">CameraOpacityOptions</a></code> | the options to set the camera opacity with |
-
-**Returns:** <code>any</code>
-
-**Since:** 0.0.1
-
---------------------
-
-
-### stopRecordVideo()
-
-```typescript
-stopRecordVideo() => any
-```
-
-Stop recording video.
-
-**Returns:** <code>any</code>
-
-**Since:** 0.0.1
-
---------------------
-
-
-### startRecordVideo(...)
-
-```typescript
-startRecordVideo(options: CameraPreviewOptions) => any
-```
-
-Start recording video.
-
-| Param         | Type                                                                  | Description                               |
-| ------------- | --------------------------------------------------------------------- | ----------------------------------------- |
-| **`options`** | <code><a href="#camerapreviewoptions">CameraPreviewOptions</a></code> | the options to start recording video with |
-
-**Returns:** <code>any</code>
-
-**Since:** 0.0.1
-
---------------------
-
-
 ### Interfaces
 
 
@@ -298,7 +101,7 @@ Start recording video.
 | **`position`**                     | <code>string</code>  | Choose the camera to use 'front' or 'rear', default 'front'                                                                                                   |
 | **`storeToFile`**                  | <code>boolean</code> | Defaults to false - Capture images to a file and return the file path instead of returning base64 encoded data                                                |
 | **`disableExifHeaderStripping`**   | <code>boolean</code> | Defaults to false - Android Only - Disable automatic rotation of the image, and let the browser deal with it (keep reading on how to achieve it)              |
-| **`enableHighResolution`**         | <code>boolean</code> | Defaults to false - iOS only - Activate high resolution image capture so that output images are from the highest resolution possible on the device *          |
+| **`enableHighResolution`**         | <code>boolean</code> | Defaults to false - iOS only - Activate high resolution image capture so that output images are from the highest resolution possible on the device            |
 | **`disableAudio`**                 | <code>boolean</code> | Defaults to false - Web only - Disables audio stream to prevent permission requests and output switching                                                      |
 | **`lockAndroidOrientation`**       | <code>boolean</code> | Android Only - Locks device orientation when camera is showing.                                                                                               |
 | **`enableOpacity`**                | <code>boolean</code> | Defaults to false - Android and Web only. Set if camera preview can change opacity.                                                                           |
@@ -334,16 +137,16 @@ Start recording video.
 
 #### CameraPosition
 
-<code>"rear" | "front"</code>
+<code>'rear' | 'front'</code>
 
 
 #### PictureFormat
 
-<code>"jpeg" | "png"</code>
+<code>'jpeg' | 'png'</code>
 
 
 #### CameraPreviewFlashMode
 
-<code>"off" | "on" | "auto" | "red-eye" | "torch"</code>
+<code>'off' | 'on' | 'auto' | 'red-eye' | 'torch'</code>
 
-</docgen-api>
+</docgen-api>

package/android/src/main/java/com/ahm/capacitor/camera/preview/CameraActivity.java

@@ -8,8 +8,6 @@ import android.content.res.Configuration;
 import android.graphics.Bitmap;
 import android.graphics.Bitmap.CompressFormat;
 import android.graphics.BitmapFactory;
-import android.graphics.Canvas;
-import android.graphics.ImageFormat;
 import android.graphics.Matrix;
 import android.graphics.Rect;
 import android.graphics.YuvImage;
@@ -28,9 +26,6 @@ import android.view.Gravity;
 import android.view.LayoutInflater;
 import android.view.MotionEvent;
 import android.view.Surface;
-import android.view.Surface;
-import android.view.SurfaceHolder;
-import android.view.SurfaceView;
 import android.view.View;
 import android.view.ViewGroup;
 import android.view.ViewTreeObserver;
@@ -43,7 +38,9 @@ import java.io.File;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.util.Arrays;
+import java.util.Collections;
 import java.util.List;
+import java.util.Objects;
 import java.util.UUID;
 
 public class CameraActivity extends Fragment {
@@ -84,7 +81,7 @@ public class CameraActivity extends Fragment {
     STOPPED,
   }
 
-  private RecordingState mRecordingState = RecordingState.INITIALIZING;
+  private final RecordingState mRecordingState = RecordingState.INITIALIZING;
   private MediaRecorder mRecorder = null;
   private String recordFilePath;
 
@@ -460,7 +457,6 @@ public class CameraActivity extends Fragment {
     if (mCamera != null) {
       setDefaultCameraId();
       mPreview.setCamera(null, -1);
-      mCamera.setPreviewCallback(null);
       mCamera.release();
       mCamera = null;
     }
@@ -533,7 +529,7 @@ public class CameraActivity extends Fragment {
         getNumberOfCameras();
         Log.d(TAG, "cameraCurrentlyLocked new: " + cameraCurrentlyLocked);
       } catch (Exception exception) {
-        Log.d(TAG, exception.getMessage());
+        Log.d(TAG, Objects.requireNonNull(exception.getMessage()));
       }
 
       // Acquire the next camera and request Preview to reconfigure parameters.
@@ -622,7 +618,7 @@ public class CameraActivity extends Fragment {
     cache = getActivity().getCacheDir();
 
     // Create the cache directory if it doesn't exist
-    cache.mkdirs();
+    final boolean mkdirs = cache.mkdirs();
     return cache.getAbsolutePath();
   }
 
@@ -640,39 +636,109 @@ public class CameraActivity extends Fragment {
       Log.d(TAG, "CameraPreview jpegPictureCallback");
 
       try {
-        if (!disableExifHeaderStripping) {
-          Matrix matrix = new Matrix();
-          if (cameraCurrentlyLocked == Camera.CameraInfo.CAMERA_FACING_FRONT) {
-            matrix.preScale(1.0f, -1.0f);
-          }
-
-          ExifInterface exifInterface = new ExifInterface(
-            new ByteArrayInputStream(data)
-          );
-          int rotation = exifInterface.getAttributeInt(
-            ExifInterface.TAG_ORIENTATION,
-            ExifInterface.ORIENTATION_NORMAL
-          );
-          int rotationInDegrees = exifToDegrees(rotation);
+        Log.d(TAG, "Inside jpegPictureCallback");
 
-          if (rotation != 0f) {
-            matrix.preRotate(rotationInDegrees);
-          }
+        if (!disableExifHeaderStripping) {
+          try {
+            ExifInterface exifInterface = new ExifInterface(
+              new ByteArrayInputStream(data)
+            );
+            int orientation = exifInterface.getAttributeInt(
+              ExifInterface.TAG_ORIENTATION,
+              ExifInterface.ORIENTATION_NORMAL
+            );
+            Log.d(TAG, "EXIF Orientation: " + orientation);
 
-          // Check if matrix has changed. In that case, apply matrix and override data
-          if (!matrix.isIdentity()) {
-            Bitmap bitmap = BitmapFactory.decodeByteArray(data, 0, data.length);
-            bitmap = applyMatrix(bitmap, matrix);
+            int rotation = 0;
+            switch (orientation) {
+              case ExifInterface.ORIENTATION_ROTATE_90:
+                rotation = 90;
+                break;
+              case ExifInterface.ORIENTATION_ROTATE_180:
+                rotation = 180;
+                break;
+              case ExifInterface.ORIENTATION_ROTATE_270:
+                rotation = 270;
+                break;
+            }
+            Log.d(
+              TAG,
+              "Camera facing: " +
+              (cameraCurrentlyLocked == Camera.CameraInfo.CAMERA_FACING_FRONT
+                  ? "front"
+                  : "rear")
+            );
+            Log.d(TAG, "Image rotation: " + rotation);
+            Log.d(
+              TAG,
+              "Image flipped: " +
+              (cameraCurrentlyLocked == Camera.CameraInfo.CAMERA_FACING_FRONT)
+            );
 
-            ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
-            bitmap.compress(CompressFormat.JPEG, currentQuality, outputStream);
-            data = outputStream.toByteArray();
+            if (
+              cameraCurrentlyLocked == Camera.CameraInfo.CAMERA_FACING_FRONT
+            ) {
+              Log.d(TAG, "Front camera EXIF Orientation: " + orientation);
+              // Rotate the bitmap based on the orientation value
+              Matrix matrix = new Matrix();
+              switch (orientation) {
+                case ExifInterface.ORIENTATION_ROTATE_90:
+                  matrix.postRotate(270);
+                  break;
+                case ExifInterface.ORIENTATION_ROTATE_180:
+                  matrix.postRotate(180);
+                  break;
+                case ExifInterface.ORIENTATION_ROTATE_270:
+                  matrix.postRotate(90);
+                  break;
+              }
+              // Flip the bitmap horizontally for the front camera
+              matrix.postScale(-1, 1);
+              Bitmap bitmap = BitmapFactory.decodeByteArray(
+                data,
+                0,
+                data.length
+              );
+              bitmap = Bitmap.createBitmap(
+                bitmap,
+                0,
+                0,
+                bitmap.getWidth(),
+                bitmap.getHeight(),
+                matrix,
+                true
+              );
+              ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
+              bitmap.compress(Bitmap.CompressFormat.JPEG, 100, outputStream);
+              data = outputStream.toByteArray();
+            } else if (rotation != 0) {
+              Matrix matrix = new Matrix();
+              matrix.postRotate(rotation);
+              Bitmap bitmap = BitmapFactory.decodeByteArray(
+                data,
+                0,
+                data.length
+              );
+              bitmap = Bitmap.createBitmap(
+                bitmap,
+                0,
+                0,
+                bitmap.getWidth(),
+                bitmap.getHeight(),
+                matrix,
+                true
+              );
+              ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
+              bitmap.compress(Bitmap.CompressFormat.JPEG, 100, outputStream);
+              data = outputStream.toByteArray();
+            }
+          } catch (IOException e) {
+            Log.e(TAG, "Failed to read EXIF data", e);
           }
         }
 
         if (!storeToFile) {
           String encodedImage = Base64.encodeToString(data, Base64.NO_WRAP);
-
           eventListener.onPictureTaken(encodedImage);
         } else {
           String path = getTempFilePath();
@@ -699,105 +765,6 @@ public class CameraActivity extends Fragment {
     }
   };
 
-  private Camera.Size getOptimalPictureSize(
-    final int width,
-    final int height,
-    final Camera.Size previewSize,
-    final List<Camera.Size> supportedSizes
-  ) {
-    /*
-      get the supportedPictureSize that:
-      - matches exactly width and height
-      - has the closest aspect ratio to the preview aspect ratio
-      - has picture.width and picture.height closest to width and height
-      - has the highest supported picture width and height up to 2 Megapixel if width == 0 || height == 0
-    */
-    Camera.Size size = mCamera.new Size(width, height);
-
-    // convert to landscape if necessary
-    if (size.width < size.height) {
-      int temp = size.width;
-      size.width = size.height;
-      size.height = temp;
-    }
-
-    Camera.Size requestedSize = mCamera.new Size(size.width, size.height);
-
-    double previewAspectRatio =
-      (double) previewSize.width / (double) previewSize.height;
-
-    if (previewAspectRatio < 1.0) {
-      // reset ratio to landscape
-      previewAspectRatio = 1.0 / previewAspectRatio;
-    }
-
-    Log.d(TAG, "CameraPreview previewAspectRatio " + previewAspectRatio);
-
-    double aspectTolerance = 0.1;
-    double bestDifference = Double.MAX_VALUE;
-
-    for (int i = 0; i < supportedSizes.size(); i++) {
-      Camera.Size supportedSize = supportedSizes.get(i);
-
-      // Perfect match
-      if (supportedSize.equals(requestedSize)) {
-        Log.d(
-          TAG,
-          "CameraPreview optimalPictureSize " +
-          supportedSize.width +
-          'x' +
-          supportedSize.height
-        );
-        return supportedSize;
-      }
-
-      double difference = Math.abs(
-        previewAspectRatio -
-        ((double) supportedSize.width / (double) supportedSize.height)
-      );
-
-      if (difference < bestDifference - aspectTolerance) {
-        // better aspectRatio found
-        if (
-          (width != 0 && height != 0) ||
-          (supportedSize.width * supportedSize.height < 2048 * 1024)
-        ) {
-          size.width = supportedSize.width;
-          size.height = supportedSize.height;
-          bestDifference = difference;
-        }
-      } else if (difference < bestDifference + aspectTolerance) {
-        // same aspectRatio found (within tolerance)
-        if (width == 0 || height == 0) {
-          // set highest supported resolution below 2 Megapixel
-          if (
-            (size.width < supportedSize.width) &&
-            (supportedSize.width * supportedSize.height < 2048 * 1024)
-          ) {
-            size.width = supportedSize.width;
-            size.height = supportedSize.height;
-          }
-        } else {
-          // check if this pictureSize closer to requested width and height
-          if (
-            Math.abs(
-              width * height - supportedSize.width * supportedSize.height
-            ) <
-            Math.abs(width * height - size.width * size.height)
-          ) {
-            size.width = supportedSize.width;
-            size.height = supportedSize.height;
-          }
-        }
-      }
-    }
-    Log.d(
-      TAG,
-      "CameraPreview optimalPictureSize " + size.width + 'x' + size.height
-    );
-    return size;
-  }
-
   static byte[] rotateNV21(
     final byte[] yuv,
     final int width,
@@ -899,6 +866,43 @@ public class CameraActivity extends Fragment {
     );
   }
 
+  private Camera.Size getOptimalPictureSizeForPreview(
+    int width,
+    int height,
+    Camera.Size previewSize,
+    List<Camera.Size> supportedSizes
+  ) {
+    Log.d(TAG, "Requested picture size: " + width + "x" + height);
+    Log.d(TAG, "Preview size: " + previewSize.width + "x" + previewSize.height);
+    double targetRatio = (double) previewSize.width / previewSize.height;
+    Camera.Size optimalSize = null;
+    double minDiff = Double.MAX_VALUE;
+
+    for (Camera.Size size : supportedSizes) {
+      double ratio = (double) size.width / size.height;
+      if (Math.abs(ratio - targetRatio) > 0.1) continue;
+      if (Math.abs(size.height - height) < minDiff) {
+        optimalSize = size;
+        minDiff = Math.abs(size.height - height);
+      }
+    }
+
+    if (optimalSize == null) {
+      minDiff = Double.MAX_VALUE;
+      for (Camera.Size size : supportedSizes) {
+        if (Math.abs(size.height - height) < minDiff) {
+          optimalSize = size;
+          minDiff = Math.abs(size.height - height);
+        }
+      }
+    }
+    Log.d(
+      TAG,
+      "Optimal picture size: " + optimalSize.width + "x" + optimalSize.height
+    );
+    return optimalSize;
+  }
+
   public void takePicture(
     final int width,
     final int height,
@@ -925,7 +929,7 @@ public class CameraActivity extends Fragment {
         public void run() {
           Camera.Parameters params = mCamera.getParameters();
 
-          Camera.Size size = getOptimalPictureSize(
+          Camera.Size size = getOptimalPictureSizeForPreview(
             width,
             height,
             params.getPreviewSize(),
@@ -1027,11 +1031,7 @@ public class CameraActivity extends Fragment {
 
     Camera.Parameters cameraParams = mCamera.getParameters();
     if (withFlash) {
-      cameraParams.setFlashMode(
-        withFlash
-          ? Camera.Parameters.FLASH_MODE_TORCH
-          : Camera.Parameters.FLASH_MODE_OFF
-      );
+      cameraParams.setFlashMode(Camera.Parameters.FLASH_MODE_TORCH);
       mCamera.setParameters(cameraParams);
       mCamera.startPreview();
     }
@@ -1127,9 +1127,6 @@ public class CameraActivity extends Fragment {
 
     int degrees = 0;
     switch (currentScreenRotation) {
-      case Surface.ROTATION_0:
-        degrees = 0;
-        break;
       case Surface.ROTATION_90:
         degrees = 90;
         break;
@@ -1139,6 +1136,8 @@ public class CameraActivity extends Fragment {
       case Surface.ROTATION_270:
         degrees = 270;
         break;
+      default:
+        break;
     }
 
     int orientation;
@@ -1179,9 +1178,11 @@ public class CameraActivity extends Fragment {
       ((AudioManager) activity
           .getApplicationContext()
           .getSystemService(Context.AUDIO_SERVICE));
-    int direction = mute
-      ? audioManager.ADJUST_MUTE
-      : audioManager.ADJUST_UNMUTE;
+    if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.M) {
+      int direction = mute
+        ? AudioManager.ADJUST_MUTE
+        : AudioManager.ADJUST_UNMUTE;
+    }
   }
 
   public void setFocusArea(
@@ -1196,12 +1197,14 @@ public class CameraActivity extends Fragment {
 
       Rect focusRect = calculateTapArea(pointX, pointY, 1f);
       parameters.setFocusMode(Camera.Parameters.FOCUS_MODE_AUTO);
-      parameters.setFocusAreas(Arrays.asList(new Camera.Area(focusRect, 1000)));
+      parameters.setFocusAreas(
+        Collections.singletonList(new Camera.Area(focusRect, 1000))
+      );
 
       if (parameters.getMaxNumMeteringAreas() > 0) {
         Rect meteringRect = calculateTapArea(pointX, pointY, 1.5f);
         parameters.setMeteringAreas(
-          Arrays.asList(new Camera.Area(meteringRect, 1000))
+          Collections.singletonList(new Camera.Area(meteringRect, 1000))
         );
       }
 
@@ -1209,7 +1212,7 @@ public class CameraActivity extends Fragment {
         setCameraParameters(parameters);
         mCamera.autoFocus(callback);
       } catch (Exception e) {
-        Log.d(TAG, e.getMessage());
+        Log.d(TAG, Objects.requireNonNull(e.getMessage()));
         callback.onAutoFocus(false, this.mCamera);
       }
     }