@capgo/camera-preview 4.0.0 → 5.0.1

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,10 +81,9 @@ public class CameraActivity extends Fragment {
     STOPPED,
   }
 
-  private RecordingState mRecordingState = RecordingState.INITIALIZING;
+  private final RecordingState mRecordingState = RecordingState.INITIALIZING;
   private MediaRecorder mRecorder = null;
   private String recordFilePath;
-  private float opacity;
 
   // The first rear facing camera
   private int defaultCameraId;
@@ -121,13 +117,12 @@ public class CameraActivity extends Fragment {
     appResourcesPackage = getActivity().getPackageName();
 
     // Inflate the layout for this fragment
-    view =
-      inflater.inflate(
-        getResources()
-          .getIdentifier("camera_activity", "layout", appResourcesPackage),
-        container,
-        false
-      );
+    view = inflater.inflate(
+      getResources()
+        .getIdentifier("camera_activity", "layout", appResourcesPackage),
+      container,
+      false
+    );
     createCameraPreview();
     return view;
   }
@@ -149,19 +144,17 @@ public class CameraActivity extends Fragment {
         height
       );
       layoutParams.setMargins(x, y, 0, 0);
-      frameContainerLayout =
-        (FrameLayout) view.findViewById(
-          getResources()
-            .getIdentifier("frame_container", "id", appResourcesPackage)
-        );
+      frameContainerLayout = (FrameLayout) view.findViewById(
+        getResources()
+          .getIdentifier("frame_container", "id", appResourcesPackage)
+      );
       frameContainerLayout.setLayoutParams(layoutParams);
 
       //video view
       mPreview = new Preview(getActivity(), enableOpacity);
-      mainLayout =
-        (FrameLayout) view.findViewById(
-          getResources().getIdentifier("video_view", "id", appResourcesPackage)
-        );
+      mainLayout = (FrameLayout) view.findViewById(
+        getResources().getIdentifier("video_view", "id", appResourcesPackage)
+      );
       mainLayout.setLayoutParams(
         new RelativeLayout.LayoutParams(
           RelativeLayout.LayoutParams.MATCH_PARENT,
@@ -280,10 +273,10 @@ public class CameraActivity extends Fragment {
                         switch (event.getAction()) {
                           case MotionEvent.ACTION_DOWN:
                             if (mLastTouchX == 0 || mLastTouchY == 0) {
-                              mLastTouchX =
-                                (int) event.getRawX() - layoutParams.leftMargin;
-                              mLastTouchY =
-                                (int) event.getRawY() - layoutParams.topMargin;
+                              mLastTouchX = (int) event.getRawX() -
+                              layoutParams.leftMargin;
+                              mLastTouchY = (int) event.getRawY() -
+                              layoutParams.topMargin;
                             } else {
                               mLastTouchX = (int) event.getRawX();
                               mLastTouchY = (int) event.getRawY();
@@ -363,17 +356,22 @@ public class CameraActivity extends Fragment {
       );
   }
 
-  private void setDefaultCameraId() {
-    // Find the total number of cameras available
-    numberOfCameras = Camera.getNumberOfCameras();
+  private int getNumberOfCameras() {
+    if (numberOfCameras == 0) {
+      numberOfCameras = Camera.getNumberOfCameras();
+    }
 
+    return numberOfCameras;
+  }
+
+  private void setDefaultCameraId() {
     int facing = "front".equals(defaultCamera)
       ? Camera.CameraInfo.CAMERA_FACING_FRONT
       : Camera.CameraInfo.CAMERA_FACING_BACK;
 
     // Find the ID of the default camera
     Camera.CameraInfo cameraInfo = new Camera.CameraInfo();
-    for (int i = 0; i < numberOfCameras; i++) {
+    for (int i = 0; i < getNumberOfCameras(); i++) {
       Camera.getCameraInfo(i, cameraInfo);
       if (cameraInfo.facing == facing) {
         defaultCameraId = i;
@@ -384,16 +382,17 @@ public class CameraActivity extends Fragment {
 
   @Override
   public void onResume() {
+    // This gets called when getting started AND after the app gets resumed.
     super.onResume();
 
-    mCamera = Camera.open(defaultCameraId);
+    // Make sure that we load the currently "locked" camera. If the camera gets changed
+    // during use, we want to "restore" that camera back as soon as we come back to the app.
+    mCamera = Camera.open(cameraCurrentlyLocked);
 
-    if (cameraParameters != null) {
+    if (cameraCurrentlyLocked == 0 && cameraParameters != null) {
       mCamera.setParameters(cameraParameters);
     }
 
-    cameraCurrentlyLocked = defaultCameraId;
-
     if (mPreview.mPreviewSize == null) {
       mPreview.setCamera(mCamera, cameraCurrentlyLocked);
       eventListener.onCameraStarted();
@@ -440,8 +439,8 @@ public class CameraActivity extends Fragment {
                   frameContainerLayout.getWidth(),
                   frameContainerLayout.getHeight()
                 );
-              camViewLayout.gravity =
-                Gravity.CENTER_HORIZONTAL | Gravity.CENTER_VERTICAL;
+              camViewLayout.gravity = Gravity.CENTER_HORIZONTAL |
+              Gravity.CENTER_VERTICAL;
               frameCamContainerLayout.setLayoutParams(camViewLayout);
             }
           }
@@ -458,7 +457,6 @@ public class CameraActivity extends Fragment {
     if (mCamera != null) {
       setDefaultCameraId();
       mPreview.setCamera(null, -1);
-      mCamera.setPreviewCallback(null);
       mCamera.release();
       mCamera = null;
     }
@@ -512,7 +510,7 @@ public class CameraActivity extends Fragment {
     if (numberOfCameras == 1) {
       //There is only one camera available
     } else {
-      Log.d(TAG, "numberOfCameras: " + numberOfCameras);
+      Log.d(TAG, "numberOfCameras: " + getNumberOfCameras());
 
       // OK, we have multiple cameras. Release this camera -> cameraCurrentlyLocked
       if (mCamera != null) {
@@ -527,10 +525,11 @@ public class CameraActivity extends Fragment {
         "cameraCurrentlyLocked := " + Integer.toString(cameraCurrentlyLocked)
       );
       try {
-        cameraCurrentlyLocked = (cameraCurrentlyLocked + 1) % numberOfCameras;
+        cameraCurrentlyLocked = (cameraCurrentlyLocked + 1) %
+        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.
@@ -619,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();
   }
 
@@ -637,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();
@@ -696,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,
@@ -841,7 +811,6 @@ public class CameraActivity extends Fragment {
 
   public void setOpacity(final float opacity) {
     Log.d(TAG, "set opacity:" + opacity);
-    this.opacity = opacity;
     mPreview.setOpacity(opacity);
   }
 
@@ -858,13 +827,12 @@ public class CameraActivity extends Fragment {
               mPreview.getCameraFacing() ==
               Camera.CameraInfo.CAMERA_FACING_FRONT
             ) {
-              bytes =
-                rotateNV21(
-                  bytes,
-                  size.width,
-                  size.height,
-                  (360 - orientation) % 360
-                );
+              bytes = rotateNV21(
+                bytes,
+                size.width,
+                size.height,
+                (360 - orientation) % 360
+              );
             } else {
               bytes = rotateNV21(bytes, size.width, size.height, orientation);
             }
@@ -898,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,
@@ -924,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(),
@@ -1026,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();
     }
@@ -1048,8 +1049,10 @@ public class CameraActivity extends Fragment {
           CamcorderProfile.QUALITY_HIGH
         )
       ) {
-        profile =
-          CamcorderProfile.get(defaultCameraId, CamcorderProfile.QUALITY_HIGH);
+        profile = CamcorderProfile.get(
+          defaultCameraId,
+          CamcorderProfile.QUALITY_HIGH
+        );
       } else {
         if (
           CamcorderProfile.hasProfile(
@@ -1057,11 +1060,10 @@ public class CameraActivity extends Fragment {
             CamcorderProfile.QUALITY_480P
           )
         ) {
-          profile =
-            CamcorderProfile.get(
-              defaultCameraId,
-              CamcorderProfile.QUALITY_480P
-            );
+          profile = CamcorderProfile.get(
+            defaultCameraId,
+            CamcorderProfile.QUALITY_480P
+          );
         } else {
           if (
             CamcorderProfile.hasProfile(
@@ -1069,11 +1071,10 @@ public class CameraActivity extends Fragment {
               CamcorderProfile.QUALITY_720P
             )
           ) {
-            profile =
-              CamcorderProfile.get(
-                defaultCameraId,
-                CamcorderProfile.QUALITY_720P
-              );
+            profile = CamcorderProfile.get(
+              defaultCameraId,
+              CamcorderProfile.QUALITY_720P
+            );
           } else {
             if (
               CamcorderProfile.hasProfile(
@@ -1081,17 +1082,15 @@ public class CameraActivity extends Fragment {
                 CamcorderProfile.QUALITY_1080P
               )
             ) {
-              profile =
-                CamcorderProfile.get(
-                  defaultCameraId,
-                  CamcorderProfile.QUALITY_1080P
-                );
+              profile = CamcorderProfile.get(
+                defaultCameraId,
+                CamcorderProfile.QUALITY_1080P
+              );
             } else {
-              profile =
-                CamcorderProfile.get(
-                  defaultCameraId,
-                  CamcorderProfile.QUALITY_LOW
-                );
+              profile = CamcorderProfile.get(
+                defaultCameraId,
+                CamcorderProfile.QUALITY_LOW
+              );
             }
           }
         }
@@ -1128,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;
@@ -1140,6 +1136,8 @@ public class CameraActivity extends Fragment {
       case Surface.ROTATION_270:
         degrees = 270;
         break;
+      default:
+        break;
     }
 
     int orientation;
@@ -1177,14 +1175,14 @@ public class CameraActivity extends Fragment {
 
   public void muteStream(boolean mute, Activity activity) {
     AudioManager audioManager =
-      (
-        (AudioManager) activity
+      ((AudioManager) activity
           .getApplicationContext()
-          .getSystemService(Context.AUDIO_SERVICE)
-      );
-    int direction = mute
-      ? audioManager.ADJUST_MUTE
-      : audioManager.ADJUST_UNMUTE;
+          .getSystemService(Context.AUDIO_SERVICE));
+    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(
@@ -1199,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))
         );
       }
 
@@ -1212,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);
       }
     }
@@ -1232,10 +1232,10 @@ public class CameraActivity extends Fragment {
       y = height - 100;
     }
     return new Rect(
-      Math.round((x - 100) * 2000 / width - 1000),
-      Math.round((y - 100) * 2000 / height - 1000),
-      Math.round((x + 100) * 2000 / width - 1000),
-      Math.round((y + 100) * 2000 / height - 1000)
+      Math.round(((x - 100) * 2000) / width - 1000),
+      Math.round(((y - 100) * 2000) / height - 1000),
+      Math.round(((x + 100) * 2000) / width - 1000),
+      Math.round(((y + 100) * 2000) / height - 1000)
     );
   }