capacitor-community-multilens-camerapreview 7.1.7 → 7.1.8

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

@@ -3,15 +3,20 @@ package com.ahm.capacitor.camera.preview;
 import android.app.Activity;
 import android.content.Context;
 import android.graphics.SurfaceTexture;
-import android.hardware.Camera;
-import android.util.DisplayMetrics;
+import android.hardware.camera2.CameraAccessException;
+import android.hardware.camera2.CameraCharacteristics;
+import android.hardware.camera2.CameraDevice;
+import android.hardware.camera2.CameraManager;
 import android.util.Log;
+import android.util.Size;
 import android.view.Surface;
 import android.view.SurfaceHolder;
 import android.view.TextureView;
 import android.view.View;
 import android.widget.RelativeLayout;
-import java.io.IOException;
+
+import androidx.annotation.NonNull;
+
 import java.util.List;
 
 class Preview extends RelativeLayout implements SurfaceHolder.Callback, TextureView.SurfaceTextureListener {
@@ -21,13 +26,13 @@ class Preview extends RelativeLayout implements SurfaceHolder.Callback, TextureV
     CustomSurfaceView mSurfaceView;
     CustomTextureView mTextureView;
     SurfaceHolder mHolder;
-    SurfaceTexture mSurface;
-    Camera.Size mPreviewSize;
-    List<Camera.Size> mSupportedPreviewSizes;
-    Camera mCamera;
-    int cameraId;
+    SurfaceTexture mSurfaceTexture;
+    Size mPreviewSize;
+    List<Size> mSupportedPreviewSizes;
+    CameraDevice cameraDevice;
+    String cameraId;
     int displayOrientation;
-    int facing = Camera.CameraInfo.CAMERA_FACING_BACK;
+    int facing;
     int viewWidth;
     int viewHeight;
     private boolean enableOpacity = false;
@@ -61,24 +66,10 @@ class Preview extends RelativeLayout implements SurfaceHolder.Callback, TextureV
         }
     }
 
-    public void setCamera(Camera camera, int cameraId) {
-        if (camera != null) {
-            mCamera = camera;
-            this.cameraId = cameraId;
-            mSupportedPreviewSizes = mCamera.getParameters().getSupportedPreviewSizes();
-            setCameraDisplayOrientation();
-
-            List<String> mFocusModes = mCamera.getParameters().getSupportedFocusModes();
-
-            Camera.Parameters params = mCamera.getParameters();
-            if (mFocusModes.contains("continuous-picture")) {
-                params.setFocusMode(Camera.Parameters.FOCUS_MODE_CONTINUOUS_PICTURE);
-            } else if (mFocusModes.contains("continuous-video")) {
-                params.setFocusMode(Camera.Parameters.FOCUS_MODE_CONTINUOUS_VIDEO);
-            } else if (mFocusModes.contains("auto")) {
-                params.setFocusMode(Camera.Parameters.FOCUS_MODE_AUTO);
-            }
-            mCamera.setParameters(params);
+    public void setCamera(CameraDevice cameraDevice, int cameraId) {
+        if (cameraDevice != null) {
+            this.cameraDevice = cameraDevice;
+            this.cameraId = String.valueOf(cameraId);
         }
     }
 
@@ -90,93 +81,58 @@ class Preview extends RelativeLayout implements SurfaceHolder.Callback, TextureV
         return facing;
     }
 
-    public void printPreviewSize(String from) {
-        Log.d(TAG, "printPreviewSize from " + from + ": > width: " + mPreviewSize.width + " height: " + mPreviewSize.height);
-    }
 
-    public void setCameraPreviewSize() {
-        if (mCamera != null) {
-            Camera.Parameters parameters = mCamera.getParameters();
-            parameters.setPreviewSize(mPreviewSize.width, mPreviewSize.height);
-            mCamera.setParameters(parameters);
-        }
-    }
 
     public void setCameraDisplayOrientation() {
-        Camera.CameraInfo info = new Camera.CameraInfo();
-        int rotation = ((Activity) getContext()).getWindowManager().getDefaultDisplay().getRotation();
-        int degrees = 0;
-        DisplayMetrics dm = new DisplayMetrics();
-
-        Camera.getCameraInfo(cameraId, info);
-        ((Activity) getContext()).getWindowManager().getDefaultDisplay().getMetrics(dm);
-
-        switch (rotation) {
-            case Surface.ROTATION_0:
-                degrees = 0;
-                break;
-            case Surface.ROTATION_90:
-                degrees = 90;
-                break;
-            case Surface.ROTATION_180:
-                degrees = 180;
-                break;
-            case Surface.ROTATION_270:
-                degrees = 270;
-                break;
-        }
-        facing = info.facing;
-        if (info.facing == Camera.CameraInfo.CAMERA_FACING_FRONT) {
-            displayOrientation = (info.orientation + degrees) % 360;
-            displayOrientation = (360 - displayOrientation) % 360;
-        } else {
-            displayOrientation = (info.orientation - degrees + 360) % 360;
+        if (cameraDevice == null || cameraId == null) {
+            return;
         }
-
-        Log.d(TAG, "screen is rotated " + degrees + "deg from natural");
-        Log.d(
-            TAG,
-            (info.facing == Camera.CameraInfo.CAMERA_FACING_FRONT ? "front" : "back") +
-            " camera is oriented -" +
-            info.orientation +
-            "deg from natural"
-        );
-        Log.d(TAG, "need to rotate preview " + displayOrientation + "deg");
-        mCamera.setDisplayOrientation(displayOrientation);
-    }
-
-    public void switchCamera(Camera camera, int cameraId) {
+        CameraManager cameraManager = (CameraManager) getContext().getSystemService(Context.CAMERA_SERVICE);
         try {
-            setCamera(camera, cameraId);
-
-            Log.d("CameraPreview", "before set camera");
-
-            View v;
-            if (enableOpacity) {
-                camera.setPreviewTexture(mSurface);
-                v = mTextureView;
-            } else {
-                camera.setPreviewDisplay(mHolder);
-                v = mSurfaceView;
+            CameraCharacteristics characteristics = cameraManager.getCameraCharacteristics(cameraId);
+            int sensorOrientation = characteristics.get(CameraCharacteristics.SENSOR_ORIENTATION);
+            int rotation = ((Activity) getContext()).getWindowManager().getDefaultDisplay().getRotation();
+            int degrees = 0;
+            switch (rotation) {
+                case Surface.ROTATION_0:
+                    degrees = 0;
+                    break;
+                case Surface.ROTATION_90:
+                    degrees = 90;
+                    break;
+                case Surface.ROTATION_180:
+                    degrees = 180;
+                    break;
+                case Surface.ROTATION_270:
+                    degrees = 270;
+                    break;
             }
-
-            Log.d("CameraPreview", "before getParameters");
-
-            Camera.Parameters parameters = camera.getParameters();
-
-            Log.d("CameraPreview", "before setPreviewSize");
-
-            mSupportedPreviewSizes = parameters.getSupportedPreviewSizes();
-            mPreviewSize = getOptimalPreviewSize(mSupportedPreviewSizes, v.getWidth(), v.getHeight());
-            parameters.setPreviewSize(mPreviewSize.width, mPreviewSize.height);
-            Log.d(TAG, mPreviewSize.width + " " + mPreviewSize.height);
-
-            camera.setParameters(parameters);
-        } catch (IOException exception) {
-            Log.e(TAG, exception.getMessage());
+            int facing = characteristics.get(CameraCharacteristics.LENS_FACING);
+            if (facing == CameraCharacteristics.LENS_FACING_FRONT) {
+                displayOrientation = (sensorOrientation + degrees) % 360;
+                displayOrientation = (360 - displayOrientation) % 360; // compensate for mirror
+            } else { // back-facing
+                displayOrientation = (sensorOrientation - degrees + 360) % 360;
+            }
+            Log.d(TAG, "screen is rotated " + degrees + "deg from natural");
+            Log.d(
+                TAG,
+                (facing == CameraCharacteristics.LENS_FACING_FRONT ? "front" : "back") +
+                " camera is oriented -" +
+                sensorOrientation +
+                "deg from natural"
+            );
+            Log.d(TAG, "need to rotate preview " + displayOrientation + "deg");
+        } catch (CameraAccessException e) {
+            Log.e(TAG, "Failed to get camera characteristics: " + e.getMessage());
         }
     }
 
+    public void switchCamera(CameraDevice cameraDevice, String cameraId) {
+        setCamera(cameraDevice, Integer.parseInt(cameraId));
+        setCameraDisplayOrientation();
+    }
+
     @Override
     protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
         // We purposely disregard child measurements because act as a
@@ -187,7 +143,7 @@ class Preview extends RelativeLayout implements SurfaceHolder.Callback, TextureV
         setMeasuredDimension(width, height);
 
         if (mSupportedPreviewSizes != null) {
-            mPreviewSize = getOptimalPreviewSize(mSupportedPreviewSizes, width, height);
+            // mPreviewSize = getOptimalPreviewSize(mSupportedPreviewSizes, width, height);
         }
     }
 
@@ -203,12 +159,12 @@ class Preview extends RelativeLayout implements SurfaceHolder.Callback, TextureV
             int previewHeight = height;
 
             if (mPreviewSize != null) {
-                previewWidth = mPreviewSize.width;
-                previewHeight = mPreviewSize.height;
+                previewWidth = mPreviewSize.getWidth();
+                previewHeight = mPreviewSize.getHeight();
 
                 if (displayOrientation == 90 || displayOrientation == 270) {
-                    previewWidth = mPreviewSize.height;
-                    previewHeight = mPreviewSize.width;
+                    previewWidth = mPreviewSize.getHeight();
+                    previewHeight = mPreviewSize.getWidth();
                 }
                 //        LOG.d(TAG, "previewWidth:" + previewWidth + " previewHeight:" + previewHeight);
             }
@@ -245,146 +201,51 @@ class Preview extends RelativeLayout implements SurfaceHolder.Callback, TextureV
         }
     }
 
-    public void surfaceCreated(SurfaceHolder holder) {
-        // The Surface has been created, acquire the camera and tell it where
-        // to draw.
-        try {
-            if (mCamera != null) {
-                mSurfaceView.setWillNotDraw(false);
-                mCamera.setPreviewDisplay(holder);
-            }
-        } catch (Exception exception) {
-            Log.e(TAG, "Exception caused by setPreviewDisplay()", exception);
-        }
-    }
-
-    public void surfaceDestroyed(SurfaceHolder holder) {
-        // Surface will be destroyed when we return, so stop the preview.
-        try {
-            if (mCamera != null) {
-                mCamera.stopPreview();
-            }
-        } catch (Exception exception) {
-            Log.e(TAG, "Exception caused by surfaceDestroyed()", exception);
-        }
-    }
 
-    private Camera.Size getOptimalPreviewSize(List<Camera.Size> sizes, int w, int h) {
-        final double ASPECT_TOLERANCE = 0.1;
-        double targetRatio = (double) w / h;
-        if (displayOrientation == 90 || displayOrientation == 270) {
-            targetRatio = (double) h / w;
-        }
 
-        if (sizes == null) {
-            return null;
+    public void setOpacity(final float opacity) {
+        this.opacity = opacity;
+        if (enableOpacity) {
+            mTextureView.setAlpha(opacity);
         }
+    }
 
-        Camera.Size optimalSize = null;
-        double minDiff = Double.MAX_VALUE;
-
-        int targetHeight = h;
-
-        // Try to find an size match aspect ratio and size
-        for (Camera.Size size : sizes) {
-            double ratio = (double) size.width / size.height;
-            if (Math.abs(ratio - targetRatio) > ASPECT_TOLERANCE) continue;
-            if (Math.abs(size.height - targetHeight) < minDiff) {
-                optimalSize = size;
-                minDiff = Math.abs(size.height - targetHeight);
-            }
-        }
+    public Surface getSurface() {
+        return null;
+    }
 
-        // Cannot find the one match the aspect ratio, ignore the requirement
-        if (optimalSize == null) {
-            minDiff = Double.MAX_VALUE;
-            for (Camera.Size size : sizes) {
-                if (Math.abs(size.height - targetHeight) < minDiff) {
-                    optimalSize = size;
-                    minDiff = Math.abs(size.height - targetHeight);
-                }
-            }
-        }
+    @Override
+    public void surfaceCreated(@NonNull SurfaceHolder holder) {
 
-        Log.d(TAG, "optimal preview size: w: " + optimalSize.width + " h: " + optimalSize.height);
-        return optimalSize;
     }
 
-    public void surfaceChanged(SurfaceHolder holder, int format, int w, int h) {
-        if (mCamera != null) {
-            try {
-                // Now that the size is known, set up the camera parameters and begin
-                // the preview.
-                mSupportedPreviewSizes = mCamera.getParameters().getSupportedPreviewSizes();
-                if (mSupportedPreviewSizes != null) {
-                    mPreviewSize = getOptimalPreviewSize(mSupportedPreviewSizes, w, h);
-                }
-                startCamera();
-            } catch (Exception exception) {
-                Log.e(TAG, "Exception caused by surfaceChanged()", exception);
-            }
-        }
-    }
+    @Override
+    public void surfaceChanged(@NonNull SurfaceHolder holder, int format, int width, int height) {
 
-    private void startCamera() {
-        Camera.Parameters parameters = mCamera.getParameters();
-        parameters.setPreviewSize(mPreviewSize.width, mPreviewSize.height);
-        requestLayout();
-        //mCamera.setDisplayOrientation(90);
-        mCamera.setParameters(parameters);
-        mCamera.startPreview();
     }
 
-    //  Texture Callbacks
+    @Override
+    public void surfaceDestroyed(@NonNull SurfaceHolder holder) {
 
-    public void onSurfaceTextureAvailable(SurfaceTexture surface, int width, int height) {
-        // The Surface has been created, acquire the camera and tell it where
-        // to draw.
-        try {
-            mSurface = surface;
-            if (mSupportedPreviewSizes != null) {
-                mPreviewSize = getOptimalPreviewSize(mSupportedPreviewSizes, width, height);
-            }
-            if (mCamera != null) {
-                mTextureView.setAlpha(opacity);
-                mCamera.setPreviewTexture(surface);
-                startCamera();
-            }
-        } catch (Exception exception) {
-            Log.e(TAG, "Exception caused by onSurfaceTextureAvailable()", exception);
-        }
     }
 
-    public void onSurfaceTextureSizeChanged(SurfaceTexture surface, int width, int height) {}
+    @Override
+    public void onSurfaceTextureAvailable(@NonNull SurfaceTexture surface, int width, int height) {
 
-    public boolean onSurfaceTextureDestroyed(SurfaceTexture surface) {
-        try {
-            if (mCamera != null) {
-                mCamera.stopPreview();
-            }
-        } catch (Exception exception) {
-            Log.e(TAG, "Exception caused by onSurfaceTextureDestroyed()", exception);
-            return false;
-        }
-        return true;
     }
 
-    public void onSurfaceTextureUpdated(SurfaceTexture surface) {}
+    @Override
+    public void onSurfaceTextureSizeChanged(@NonNull SurfaceTexture surface, int width, int height) {
 
-    public void setOneShotPreviewCallback(Camera.PreviewCallback callback) {
-        if (mCamera != null) {
-            mCamera.setOneShotPreviewCallback(callback);
-        }
     }
 
-    public void setOpacity(final float opacity) {
-        this.opacity = opacity;
-        if (mCamera != null && enableOpacity) {
-            mTextureView.setAlpha(opacity);
-        }
+    @Override
+    public boolean onSurfaceTextureDestroyed(@NonNull SurfaceTexture surface) {
+        return false;
     }
 
-    public Surface getSurface() {
-        return null;
+    @Override
+    public void onSurfaceTextureUpdated(@NonNull SurfaceTexture surface) {
+
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "capacitor-community-multilens-camerapreview",
-  "version": "7.1.7",
+  "version": "7.1.8",
   "description": "fork of capacitor community camera preview with support for switchting lenses",
   "main": "dist/plugin.cjs.js",
   "module": "dist/esm/index.js",