diff --git a/README.md b/README.md
index cc71a228..6104bbeb 100644
--- a/README.md
+++ b/README.md
@@ -102,6 +102,7 @@ Starts the camera preview instance.
 | lockAndroidOrientation | boolean | (optional) Locks device orientation when camera is showing, default false. (applicable to Android only) |
 | enableOpacity | boolean | (optional) Make the camera preview see-through. Ideal for augmented reality uses. Default false (applicable to Android and web only)
 | enableZoom | boolean | (optional) Set if you can pinch to zoom. Default false (applicable to the android and ios platforms only)
+| maxZoomLimit | number | (optional) Set the max zoom level to limit the camera device to. Set to -1 for unlimited. Default -1 (applicable to the android and ios platforms only)
 
 <!-- <strong>Options:</strong>
 All options stated are optional and will default to values here
@@ -297,6 +298,51 @@ const myCamera = CameraPreview.start({enableOpacity: true});
 myCamera.setOpacity({opacity: 0.4});
 ```
 
+### getMaxZoom(): Promise<{value: number}>;  ---- ANDROID and iOS only
+
+<info>Get the maximum zoom level for the camera device currently started.</info><br/>
+
+```javascript
+const myCamera = CameraPreview.start();
+const maxZoom = await CameraPreview.getMaxZoom();
+```
+
+### getZoom(): Promise<{value: number}>;  ---- ANDROID and iOS only
+
+<info>Get the current zoom level for the camera device currently started.</info><br/>
+
+```javascript
+const myCamera = CameraPreview.start();
+const zoom = await CameraPreview.getZoom();
+```
+
+### setZoom({zoom: number}): Promise<void>;  ---- ANDROID and iOS only
+
+<info>Set the zoom level for the camera device currently started.</info><br/>
+
+```javascript
+const myCamera = CameraPreview.start();
+await CameraPreview.setZoom({zoom: 2});
+```
+
+### getMaxZoomLimit(): Promise<{value: number}>;  ---- ANDROID and iOS only
+
+<info>Gets the current zoom max level which the camera device is limited to. -1 indicates unlimited.</info><br/>
+
+```javascript
+const myCamera = CameraPreview.start();
+const zoomLimit = await CameraPreview.getMaxZoomLimit();
+```
+
+### setMaxZoomLimit({zoom: number}): Promise<void>;  ---- ANDROID and iOS only
+
+<info>Sets the max zoom level to limit the camera device to. Set to -1 for unlimited.</info><br/>
+
+```javascript
+const myCamera = CameraPreview.start();
+await CameraPreview.setMaxZoomLimit({zoom: 5});
+```
+
 # Settings
 
 <a name="camera_Settings.FlashMode"></a>
diff --git a/android/src/main/java/com/ahm/capacitor/camera/preview/CameraActivity.java b/android/src/main/java/com/ahm/capacitor/camera/preview/CameraActivity.java
index b0554fe1..3fc8ec4d 100644
--- a/android/src/main/java/com/ahm/capacitor/camera/preview/CameraActivity.java
+++ b/android/src/main/java/com/ahm/capacitor/camera/preview/CameraActivity.java
@@ -1,48 +1,71 @@
 package com.ahm.capacitor.camera.preview;
 
+import static androidx.core.math.MathUtils.clamp;
+
+import android.Manifest;
+import android.annotation.SuppressLint;
 import android.app.Activity;
-import android.app.Fragment;
 import android.content.Context;
 import android.content.pm.PackageManager;
-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;
+import android.graphics.SurfaceTexture;
 import android.hardware.Camera;
-import android.hardware.Camera.PictureCallback;
-import android.hardware.Camera.ShutterCallback;
+import android.hardware.SensorManager;
+import android.hardware.camera2.CameraCaptureSession;
+import android.hardware.camera2.CameraCharacteristics;
+import android.hardware.camera2.CameraDevice;
+import android.hardware.camera2.CameraManager;
+import android.hardware.camera2.CaptureRequest;
+import android.hardware.camera2.CameraMetadata;
+import android.hardware.camera2.CaptureResult;
+import android.hardware.camera2.TotalCaptureResult;
+import android.hardware.camera2.params.MeteringRectangle;
+import android.hardware.camera2.params.StreamConfigurationMap;
 import android.media.AudioManager;
 import android.media.CamcorderProfile;
+import android.media.Image;
+import android.media.ImageReader;
 import android.media.MediaRecorder;
+import android.os.Build;
 import android.os.Bundle;
+import android.os.Handler;
+import android.os.HandlerThread;
+import android.os.Looper;
 import android.util.Base64;
 import android.util.DisplayMetrics;
 import android.util.Log;
+import android.util.Size;
+import android.util.SparseIntArray;
 import android.view.GestureDetector;
-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.TextureView;
 import android.view.View;
 import android.view.ViewGroup;
-import android.view.ViewTreeObserver;
+import android.view.WindowManager;
 import android.widget.FrameLayout;
 import android.widget.RelativeLayout;
-import androidx.exifinterface.media.ExifInterface;
-import java.io.ByteArrayInputStream;
+
+import androidx.annotation.NonNull;
+import androidx.core.app.ActivityCompat;
+
+import android.app.Fragment;
+
+import com.getcapacitor.Bridge;
+import com.getcapacitor.JSObject;
+
 import java.io.ByteArrayOutputStream;
 import java.io.File;
 import java.io.FileOutputStream;
 import java.io.IOException;
-import java.util.Arrays;
+import java.io.OutputStream;
+import java.nio.ByteBuffer;
+import java.util.ArrayList;
+import java.util.Collections;
 import java.util.List;
 import java.util.UUID;
 
@@ -50,33 +73,63 @@ public class CameraActivity extends Fragment {
 
     public interface CameraPreviewListener {
         void onPictureTaken(String originalPicture);
+
         void onPictureTakenError(String message);
+
         void onSnapshotTaken(String originalPicture);
+
         void onSnapshotTakenError(String message);
+
         void onFocusSet(int pointX, int pointY);
+
         void onFocusSetError(String message);
+
         void onBackButton();
+
         void onCameraStarted();
+
         void onStartRecordVideo();
+
         void onStartRecordVideoError(String message);
+
         void onStopRecordVideo(String file);
+
         void onStopRecordVideoError(String error);
     }
 
-    private CameraPreviewListener eventListener;
-    private static final String TAG = "CameraActivity";
-    public FrameLayout mainLayout;
-    public FrameLayout frameContainerLayout;
+    /**
+     * Private properties
+     */
+    private static final String TAG = "CameraPreviewActivity";
+    private static final int REQUEST_CAMERA_PERMISSION = 200;
+
+    private static final float PINCH_ZOOM_SENSITIVITY = 0.01f;
+    private static final long PINCH_ZOOM_DEBOUNCE_DELAY_MS = 10; // milliseconds
 
-    private Preview mPreview;
-    private boolean canTakePicture = true;
 
-    private View view;
-    private Camera.Parameters cameraParameters;
-    private Camera mCamera;
-    private int numberOfCameras;
-    private int cameraCurrentlyLocked;
-    private int currentQuality;
+    private TextureView textureView;
+    private CameraDevice cameraDevice;
+    private CameraCaptureSession captureSession;
+    private CaptureRequest.Builder previewRequestBuilder;
+
+
+    private CameraActivity.CameraPreviewListener eventListener;
+
+    private Size[] mSupportedPreviewSizes;
+    private CameraCharacteristics mCameraCharacteristics;
+    Size mPreviewSize;
+
+    private static final SparseIntArray ORIENTATIONS = new SparseIntArray();
+
+    static {
+        ORIENTATIONS.append(Surface.ROTATION_0, 90);
+        ORIENTATIONS.append(Surface.ROTATION_90, 0);
+        ORIENTATIONS.append(Surface.ROTATION_180, 270);
+        ORIENTATIONS.append(Surface.ROTATION_270, 180);
+    }
+
+    private Handler mBackgroundHandler;
+    private HandlerThread mBackgroundThread;
 
     private enum RecordingState {
         INITIALIZING,
@@ -84,14 +137,24 @@ private enum RecordingState {
         STOPPED
     }
 
-    private RecordingState mRecordingState = RecordingState.INITIALIZING;
+    private final CameraActivity.RecordingState mRecordingState = CameraActivity.RecordingState.INITIALIZING;
     private MediaRecorder mRecorder = null;
     private String recordFilePath;
-    private float opacity;
 
-    // The first rear facing camera
-    private int defaultCameraId;
-    public String defaultCamera;
+    private String cameraId;
+
+
+    /**
+     * Public properties
+     */
+    public CameraPreview cameraPreview;
+    public Bridge bridge;
+    public Activity activity;
+    public Context context;
+    public FrameLayout mainLayout;
+    public FrameLayout frameContainerLayout;
+
+    public String position = "back";
     public boolean tapToTakePicture;
     public boolean dragEnabled;
     public boolean tapToFocus;
@@ -100,26 +163,23 @@ private enum RecordingState {
     public boolean toBack;
     public boolean enableOpacity = false;
     public boolean enableZoom = false;
+    public boolean cropToPreview = true; // whether to crop captured image to preview size
+    public boolean lockOrientation = false;
 
     public int width;
     public int height;
     public int x;
     public int y;
 
-    public void setEventListener(CameraPreviewListener listener) {
-        eventListener = listener;
-    }
-
-    private String appResourcesPackage;
+    public final float NO_MAX_ZOOM_LIMIT = -1f;
+    public float maxZoomLimit = NO_MAX_ZOOM_LIMIT;
 
-    @Override
-    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
-        appResourcesPackage = getActivity().getPackageName();
 
-        // Inflate the layout for this fragment
-        view = inflater.inflate(getResources().getIdentifier("camera_activity", "layout", appResourcesPackage), container, false);
-        createCameraPreview();
-        return view;
+    /**
+     * Public methods
+     */
+    public void setEventListener(CameraActivity.CameraPreviewListener listener) {
+        eventListener = listener;
     }
 
     public void setRect(int x, int y, int width, int height) {
@@ -129,872 +189,1251 @@ public void setRect(int x, int y, int width, int height) {
         this.height = height;
     }
 
-    private void createCameraPreview() {
-        if (mPreview == null) {
-            setDefaultCameraId();
+    public CameraDevice getCamera() {
+        return cameraDevice;
+    }
 
-            //set box position and size
-            FrameLayout.LayoutParams layoutParams = new FrameLayout.LayoutParams(width, height);
-            layoutParams.setMargins(x, y, 0, 0);
-            frameContainerLayout =
-                (FrameLayout) view.findViewById(getResources().getIdentifier("frame_container", "id", appResourcesPackage));
-            frameContainerLayout.setLayoutParams(layoutParams);
+    public CameraCharacteristics getCameraCharacteristics() {
+        return mCameraCharacteristics;
+    }
 
-            //video view
-            mPreview = new Preview(getActivity(), enableOpacity);
-            mainLayout = (FrameLayout) view.findViewById(getResources().getIdentifier("video_view", "id", appResourcesPackage));
-            mainLayout.setLayoutParams(
-                new RelativeLayout.LayoutParams(RelativeLayout.LayoutParams.MATCH_PARENT, RelativeLayout.LayoutParams.MATCH_PARENT)
-            );
-            mainLayout.addView(mPreview);
-            mainLayout.setEnabled(false);
+    public void switchCamera() {
+        closeCamera();
+        position = position.equals("front") ? "back" : "front";
+        logMessage("switchCamera to: " + position);
+        openCamera();
+    }
 
-            if (enableZoom) {
-                this.setupTouchAndBackButton();
-            }
+    public void setOpacity(final float opacity) {
+        logMessage("setOpacity: " + opacity);
+        if (enableOpacity && textureView != null) {
+            textureView.setAlpha(opacity);
         }
     }
 
-    private void setupTouchAndBackButton() {
-        final GestureDetector gestureDetector = new GestureDetector(getActivity().getApplicationContext(), new TapGestureDetector());
-
-        getActivity()
-            .runOnUiThread(
-                new Runnable() {
-                    @Override
-                    public void run() {
-                        frameContainerLayout.setClickable(true);
-                        frameContainerLayout.setOnTouchListener(
-                            new View.OnTouchListener() {
-                                private int mLastTouchX;
-                                private int mLastTouchY;
-                                private int mPosX = 0;
-                                private int mPosY = 0;
-
-                                @Override
-                                public boolean onTouch(View v, MotionEvent event) {
-                                    FrameLayout.LayoutParams layoutParams = (FrameLayout.LayoutParams) frameContainerLayout.getLayoutParams();
-
-                                    boolean isSingleTapTouch = gestureDetector.onTouchEvent(event);
-                                    int action = event.getAction();
-                                    int eventCount = event.getPointerCount();
-                                    Log.d(TAG, "onTouch event, action, count: " + event + ", " + action + ", " + eventCount);
-                                    if (eventCount > 1) {
-                                        // handle multi-touch events
-                                        Camera.Parameters params = mCamera.getParameters();
-                                        if (action == MotionEvent.ACTION_POINTER_DOWN) {
-                                            mDist = getFingerSpacing(event);
-                                        } else if (action == MotionEvent.ACTION_MOVE && params.isZoomSupported()) {
-                                            handleZoom(event, params);
-                                        }
-                                    } else {
-                                        if (action != MotionEvent.ACTION_MOVE && isSingleTapTouch) {
-                                            if (tapToTakePicture && tapToFocus) {
-                                                setFocusArea(
-                                                    (int) event.getX(0),
-                                                    (int) event.getY(0),
-                                                    new Camera.AutoFocusCallback() {
-                                                        public void onAutoFocus(boolean success, Camera camera) {
-                                                            if (success) {
-                                                                takePicture(0, 0, 85);
-                                                            } else {
-                                                                Log.d(TAG, "onTouch:" + " setFocusArea() did not suceed");
-                                                            }
-                                                        }
-                                                    }
-                                                );
-                                            } else if (tapToTakePicture) {
-                                                takePicture(0, 0, 85);
-                                            } else if (tapToFocus) {
-                                                setFocusArea(
-                                                    (int) event.getX(0),
-                                                    (int) event.getY(0),
-                                                    new Camera.AutoFocusCallback() {
-                                                        public void onAutoFocus(boolean success, Camera camera) {
-                                                            if (success) {
-                                                                // A callback to JS might make sense here.
-                                                            } else {
-                                                                Log.d(TAG, "onTouch:" + " setFocusArea() did not suceed");
-                                                            }
-                                                        }
-                                                    }
-                                                );
-                                            }
-                                            return true;
-                                        } else {
-                                            if (dragEnabled) {
-                                                int x;
-                                                int y;
-
-                                                switch (event.getAction()) {
-                                                    case MotionEvent.ACTION_DOWN:
-                                                        if (mLastTouchX == 0 || mLastTouchY == 0) {
-                                                            mLastTouchX = (int) event.getRawX() - layoutParams.leftMargin;
-                                                            mLastTouchY = (int) event.getRawY() - layoutParams.topMargin;
-                                                        } else {
-                                                            mLastTouchX = (int) event.getRawX();
-                                                            mLastTouchY = (int) event.getRawY();
-                                                        }
-                                                        break;
-                                                    case MotionEvent.ACTION_MOVE:
-                                                        x = (int) event.getRawX();
-                                                        y = (int) event.getRawY();
+    public void takePicture(final int width, final int height, final int quality) throws Exception {
+        if (cameraDevice == null) {
+            return;
+        }
 
-                                                        final float dx = x - mLastTouchX;
-                                                        final float dy = y - mLastTouchY;
+        int imageWidth = width;
+        int imageHeight = height;
+
+        if(cropToPreview){
+            imageWidth = mPreviewSize.getWidth();
+            imageHeight = mPreviewSize.getHeight();
+        }else{
+            Size[] jpegSizes = null;
+            if (mCameraCharacteristics != null) {
+                jpegSizes = mCameraCharacteristics.get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP)
+                        .getOutputSizes(android.graphics.ImageFormat.JPEG);
+            }
+            if (jpegSizes != null && jpegSizes.length > 0) {
+                imageWidth = jpegSizes[0].getWidth();
+                imageHeight = jpegSizes[0].getHeight();
+            }
+        }
+        logMessage("takePicture: " + imageWidth + ", " + imageHeight + ", " + quality);
+
+        final ImageReader reader = ImageReader.newInstance(imageWidth, imageHeight, android.graphics.ImageFormat.JPEG, 1);
+        List<Surface> outputSurfaces = new ArrayList<>(2);
+        outputSurfaces.add(reader.getSurface());
+        outputSurfaces.add(new Surface(textureView.getSurfaceTexture()));
+
+        final CaptureRequest.Builder stillCaptureRequestBuilder = cameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_STILL_CAPTURE);
+        stillCaptureRequestBuilder.addTarget(reader.getSurface());
+        stillCaptureRequestBuilder.set(CaptureRequest.CONTROL_MODE, CameraMetadata.CONTROL_MODE_AUTO);
+
+        if (!disableExifHeaderStripping) {
+            int deviceOrientation = activity.getWindowManager().getDefaultDisplay().getRotation();
+            stillCaptureRequestBuilder.set(CaptureRequest.JPEG_ORIENTATION, ORIENTATIONS.get(deviceOrientation));
+        }else{
+            stillCaptureRequestBuilder.set(CaptureRequest.JPEG_ORIENTATION, 0);
+        }
 
-                                                        mPosX += dx;
-                                                        mPosY += dy;
+        Rect zoomRect = getZoomRect(getCurrentZoomLevel());
+        if (zoomRect != null) {
+            stillCaptureRequestBuilder.set(CaptureRequest.SCALER_CROP_REGION, zoomRect);
+        }
+        ImageReader.OnImageAvailableListener readerListener = new ImageReader.OnImageAvailableListener() {
+            @Override
+            public void onImageAvailable(ImageReader reader) {
+                try (Image image = reader.acquireLatestImage()) {
+                    ByteBuffer buffer = image.getPlanes()[0].getBuffer();
+                    byte[] bytes = new byte[buffer.capacity()];
+                    buffer.get(bytes);
+
+                    if (!storeToFile) {
+                        String encodedImage = Base64.encodeToString(bytes, Base64.NO_WRAP);
+                        eventListener.onPictureTaken(encodedImage);
+                    } else {
+                        String path = getTempFilePath();
+                        save(bytes, path, quality);
+                        eventListener.onPictureTaken(path);
+                    }
+                } catch (Exception e) {
+                    eventListener.onPictureTakenError(e.getMessage());
+                    logException(e);
+                }
+            }
 
-                                                        layoutParams.leftMargin = mPosX;
-                                                        layoutParams.topMargin = mPosY;
+            private void save(byte[] bytes, String filePath, int quality) throws Exception {
+                Bitmap bitmap = BitmapFactory.decodeByteArray(bytes, 0, bytes.length);
+                try (OutputStream output = new FileOutputStream(filePath)) {
+                    bitmap.compress(Bitmap.CompressFormat.JPEG, quality, output);
+                }
+            }
+        };
+        reader.setOnImageAvailableListener(readerListener, mBackgroundHandler);
+        CameraCaptureSession.CaptureCallback stillCaptureListener = new CameraCaptureSession.CaptureCallback() {
+            @Override
+            public void onCaptureCompleted(@NonNull CameraCaptureSession session, @NonNull CaptureRequest request, @NonNull TotalCaptureResult result) {
+                super.onCaptureCompleted(session, request, result);
+                try {
+                    startPreview();
+                } catch (Exception e) {
+                    eventListener.onPictureTakenError(e.getMessage());
+                    logException(e);
+                }
+            }
+        };
+        cameraDevice.createCaptureSession(outputSurfaces, new CameraCaptureSession.StateCallback() {
+            @Override
+            public void onConfigured(@NonNull CameraCaptureSession stillCaptureSession) {
+                try {
+                    stillCaptureSession.capture(stillCaptureRequestBuilder.build(), stillCaptureListener, mBackgroundHandler);
+                } catch (Exception e) {
+                    eventListener.onPictureTakenError(e.getMessage());
+                    logException(e);
+                }
+            }
 
-                                                        frameContainerLayout.setLayoutParams(layoutParams);
+            @Override
+            public void onConfigureFailed(@NonNull CameraCaptureSession session) {
+                eventListener.onPictureTakenError("Configuration failed");
+            }
+        }, mBackgroundHandler);
+    }
 
-                                                        // Remember this touch position for the next move event
-                                                        mLastTouchX = x;
-                                                        mLastTouchY = y;
+    public void takeSnapshot(final int quality) throws Exception {
+        if (cameraDevice == null) {
+            return;
+        }
+        logMessage("takeSnapshot");
+        final ImageReader reader = ImageReader.newInstance(width, height, android.graphics.ImageFormat.JPEG, 1);
+        List<Surface> outputSurfaces = new ArrayList<>(2);
+        outputSurfaces.add(reader.getSurface());
+        outputSurfaces.add(new Surface(textureView.getSurfaceTexture()));
+        final CaptureRequest.Builder stillCaptureRequestBuilder = cameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_STILL_CAPTURE);
+        stillCaptureRequestBuilder.addTarget(reader.getSurface());
+        stillCaptureRequestBuilder.set(CaptureRequest.CONTROL_MODE, CameraMetadata.CONTROL_MODE_AUTO);
+        // Orientation
+        if (!disableExifHeaderStripping) {
+            int rotation = activity.getWindowManager().getDefaultDisplay().getRotation();
+            stillCaptureRequestBuilder.set(CaptureRequest.JPEG_ORIENTATION, ORIENTATIONS.get(rotation));
+        }else{
+            stillCaptureRequestBuilder.set(CaptureRequest.JPEG_ORIENTATION, 0);
+        }
+        Rect zoomRect = getZoomRect(getCurrentZoomLevel());
+        if (zoomRect != null) {
+            stillCaptureRequestBuilder.set(CaptureRequest.SCALER_CROP_REGION, zoomRect);
+        }
+        ImageReader.OnImageAvailableListener readerListener = new ImageReader.OnImageAvailableListener() {
+            @Override
+            public void onImageAvailable(ImageReader reader) {
+                try (Image image = reader.acquireLatestImage()) {
+                    ByteBuffer buffer = image.getPlanes()[0].getBuffer();
+                    byte[] bytes = new byte[buffer.capacity()];
+                    buffer.get(bytes);
+
+                    // Compress the image using the quality parameter
+                    Bitmap bitmap = BitmapFactory.decodeByteArray(bytes, 0, bytes.length);
+                    ByteArrayOutputStream baos = new ByteArrayOutputStream();
+                    bitmap.compress(Bitmap.CompressFormat.JPEG, quality, baos);
+                    byte[] compressedBytes = baos.toByteArray();
+
+                    String encodedImage = Base64.encodeToString(compressedBytes, Base64.NO_WRAP);
+                    eventListener.onSnapshotTaken(encodedImage);
+                } catch (Exception e) {
+                    eventListener.onSnapshotTakenError(e.getMessage());
+                    logException(e);
+                }
+            }
+        };
+        reader.setOnImageAvailableListener(readerListener, mBackgroundHandler);
+        CameraCaptureSession.CaptureCallback captureListener = new CameraCaptureSession.CaptureCallback() {
+            @Override
+            public void onCaptureCompleted(@NonNull CameraCaptureSession session, @NonNull CaptureRequest request, @NonNull TotalCaptureResult result) {
+                try {
+                    super.onCaptureCompleted(session, request, result);
+                    startPreview();
+                } catch (Exception e) {
+                    eventListener.onSnapshotTakenError(e.getMessage());
+                    logException(e);
+                }
+            }
+        };
+        cameraDevice.createCaptureSession(outputSurfaces, new CameraCaptureSession.StateCallback() {
+            @Override
+            public void onConfigured(@NonNull CameraCaptureSession session) {
+                try {
+                    session.capture(stillCaptureRequestBuilder.build(), captureListener, mBackgroundHandler);
+                } catch (Exception e) {
+                    eventListener.onSnapshotTakenError(e.getMessage());
+                    logException(e);
+                }
+            }
 
-                                                        break;
-                                                    default:
-                                                        break;
-                                                }
-                                            }
-                                        }
-                                    }
-                                    return true;
-                                }
-                            }
-                        );
-                        frameContainerLayout.setFocusableInTouchMode(true);
-                        frameContainerLayout.requestFocus();
-                        frameContainerLayout.setOnKeyListener(
-                            new View.OnKeyListener() {
-                                @Override
-                                public boolean onKey(View v, int keyCode, android.view.KeyEvent event) {
-                                    if (keyCode == android.view.KeyEvent.KEYCODE_BACK) {
-                                        eventListener.onBackButton();
-                                        return true;
-                                    }
-                                    return false;
-                                }
-                            }
-                        );
-                    }
+            @Override
+            public void onConfigureFailed(@NonNull CameraCaptureSession session) {
+            }
+        }, mBackgroundHandler);
 
-                    private float mDist = 0F;
-
-                    private void handleZoom(MotionEvent event, Camera.Parameters params) {
-                        if (mCamera != null) {
-                            mCamera.cancelAutoFocus();
-                            int maxZoom = params.getMaxZoom();
-                            int zoom = params.getZoom();
-                            float newDist = getFingerSpacing(event);
-                            if (newDist > mDist) {
-                                //zoom in
-                                if (zoom < maxZoom) zoom++;
-                            } else if (newDist < mDist) {
-                                //zoom out
-                                if (zoom > 0) zoom--;
-                            }
-                            mDist = newDist;
-                            params.setZoom(zoom);
-                            mCamera.setParameters(params);
-                        }
-                    }
-                }
-            );
     }
 
-    private void setDefaultCameraId() {
-        // Find the total number of cameras available
-        numberOfCameras = Camera.getNumberOfCameras();
-
-        int facing = "front".equals(defaultCamera) ? Camera.CameraInfo.CAMERA_FACING_FRONT : Camera.CameraInfo.CAMERA_FACING_BACK;
+    public void startRecord(
+            final String filePath,
+            final String camera,
+            final int width,
+            final int height,
+            final int quality,
+            final boolean withFlash,
+            final int maxDuration
+    ) throws Exception {
+
+        logMessage("CameraPreview startRecord camera: " + camera + " width: " + width + ", height: " + height + ", quality: " + quality);
+        muteStream(true, activity);
+        if (this.mRecordingState == RecordingState.STARTED) {
+            logError("Recording already started");
+            return;
+        }
+        this.recordFilePath = filePath;
 
-        // Find the ID of the default camera
-        Camera.CameraInfo cameraInfo = new Camera.CameraInfo();
-        for (int i = 0; i < numberOfCameras; i++) {
-            Camera.getCameraInfo(i, cameraInfo);
-            if (cameraInfo.facing == facing) {
-                defaultCameraId = i;
-                break;
+        if (withFlash) {
+            // Turn on the flash
+            CameraManager manager = (CameraManager) activity.getSystemService(Context.CAMERA_SERVICE);
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+                manager.setTorchMode(cameraId, true);
+            } else { // for old devices
+                @SuppressWarnings("deprecation")
+                Camera oldCamera = Camera.open();
+                Camera.Parameters parameters = oldCamera.getParameters();
+                parameters.setFlashMode(Camera.Parameters.FLASH_MODE_TORCH);
+                oldCamera.setParameters(parameters);
+                oldCamera.startPreview();
             }
         }
-    }
 
-    @Override
-    public void onResume() {
-        super.onResume();
+        mRecorder = new MediaRecorder();
+
+        try {
+            CamcorderProfile profile;
+            if (CamcorderProfile.hasProfile(getCameraToUse(), CamcorderProfile.QUALITY_HIGH)) {
+                profile = CamcorderProfile.get(getCameraToUse(), CamcorderProfile.QUALITY_HIGH);
+            } else {
+                if (CamcorderProfile.hasProfile(getCameraToUse(), CamcorderProfile.QUALITY_480P)) {
+                    profile = CamcorderProfile.get(getCameraToUse(), CamcorderProfile.QUALITY_480P);
+                } else {
+                    if (CamcorderProfile.hasProfile(getCameraToUse(), CamcorderProfile.QUALITY_720P)) {
+                        profile = CamcorderProfile.get(getCameraToUse(), CamcorderProfile.QUALITY_720P);
+                    } else {
+                        if (CamcorderProfile.hasProfile(getCameraToUse(), CamcorderProfile.QUALITY_1080P)) {
+                            profile = CamcorderProfile.get(getCameraToUse(), CamcorderProfile.QUALITY_1080P);
+                        } else {
+                            profile = CamcorderProfile.get(getCameraToUse(), CamcorderProfile.QUALITY_LOW);
+                        }
+                    }
+                }
+            }
 
-        mCamera = Camera.open(defaultCameraId);
+            mRecorder.setAudioSource(MediaRecorder.AudioSource.VOICE_RECOGNITION);
+            mRecorder.setVideoSource(MediaRecorder.VideoSource.CAMERA);
+            mRecorder.setProfile(profile);
+            mRecorder.setOutputFile(filePath);
+            mRecorder.setOrientationHint(getOrientationHint());
+            mRecorder.setMaxDuration(maxDuration);
 
-        if (cameraParameters != null) {
-            mCamera.setParameters(cameraParameters);
-        }
+            List<Surface> surfaces = new ArrayList<>();
 
-        cameraCurrentlyLocked = defaultCameraId;
+            Surface recorderSurface = mRecorder.getSurface();
+            surfaces.add(recorderSurface);
 
-        if (mPreview.mPreviewSize == null) {
-            mPreview.setCamera(mCamera, cameraCurrentlyLocked);
-            eventListener.onCameraStarted();
-        } else {
-            mPreview.switchCamera(mCamera, cameraCurrentlyLocked);
-            mCamera.startPreview();
-        }
-
-        Log.d(TAG, "cameraCurrentlyLocked:" + cameraCurrentlyLocked);
-
-        final FrameLayout frameContainerLayout = (FrameLayout) view.findViewById(
-            getResources().getIdentifier("frame_container", "id", appResourcesPackage)
-        );
-
-        ViewTreeObserver viewTreeObserver = frameContainerLayout.getViewTreeObserver();
-
-        if (viewTreeObserver.isAlive()) {
-            viewTreeObserver.addOnGlobalLayoutListener(
-                new ViewTreeObserver.OnGlobalLayoutListener() {
-                    @Override
-                    public void onGlobalLayout() {
-                        frameContainerLayout.getViewTreeObserver().removeGlobalOnLayoutListener(this);
-                        frameContainerLayout.measure(View.MeasureSpec.UNSPECIFIED, View.MeasureSpec.UNSPECIFIED);
-                        Activity activity = getActivity();
-                        if (isAdded() && activity != null) {
-                            final RelativeLayout frameCamContainerLayout = (RelativeLayout) view.findViewById(
-                                getResources().getIdentifier("frame_camera_cont", "id", appResourcesPackage)
-                            );
-
-                            FrameLayout.LayoutParams camViewLayout = new FrameLayout.LayoutParams(
-                                frameContainerLayout.getWidth(),
-                                frameContainerLayout.getHeight()
-                            );
-                            camViewLayout.gravity = Gravity.CENTER_HORIZONTAL | Gravity.CENTER_VERTICAL;
-                            frameCamContainerLayout.setLayoutParams(camViewLayout);
+            surfaces.add(new Surface(textureView.getSurfaceTexture()));
+
+            cameraDevice.createCaptureSession(surfaces, new CameraCaptureSession.StateCallback() {
+                @Override
+                public void onConfigured(@NonNull CameraCaptureSession session) {
+                    captureSession = session;
+                    try {
+                        // Build the capture request, and start the session
+                        CaptureRequest.Builder recordCaptureRequestBuilder = cameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_RECORD);
+                        recordCaptureRequestBuilder.addTarget(recorderSurface);
+                        Rect zoomRect = getZoomRect(getCurrentZoomLevel());
+                        if (zoomRect != null) {
+                            recordCaptureRequestBuilder.set(CaptureRequest.SCALER_CROP_REGION, zoomRect);
                         }
+
+                        session.setRepeatingRequest(recordCaptureRequestBuilder.build(), null, null);
+                        mRecorder.prepare();
+                        logMessage("Starting recording");
+                        mRecorder.start();
+                    } catch (Exception e) {
+                        logException(e);
                     }
                 }
-            );
-        }
-    }
 
-    @Override
-    public void onPause() {
-        super.onPause();
+                @Override
+                public void onConfigureFailed(@NonNull CameraCaptureSession session) {
+                    // Handle configuration failure
+                }
+            }, null);
 
-        // Because the Camera object is a shared resource, it's very important to release it when the activity is paused.
-        if (mCamera != null) {
-            setDefaultCameraId();
-            mPreview.setCamera(null, -1);
-            mCamera.setPreviewCallback(null);
-            mCamera.release();
-            mCamera = null;
+            eventListener.onStartRecordVideo();
+        } catch (Exception e) {
+            eventListener.onStartRecordVideoError(e.getMessage());
         }
+
     }
 
-    @Override
-    public void onConfigurationChanged(Configuration newConfig) {
-        super.onConfigurationChanged(newConfig);
-
-        final FrameLayout frameContainerLayout = (FrameLayout) view.findViewById(
-            getResources().getIdentifier("frame_container", "id", appResourcesPackage)
-        );
-
-        final int previousOrientation = frameContainerLayout.getHeight() > frameContainerLayout.getWidth()
-            ? Configuration.ORIENTATION_PORTRAIT
-            : Configuration.ORIENTATION_LANDSCAPE;
-        // Checks if the orientation of the screen has changed
-        if (newConfig.orientation != previousOrientation) {
-            final RelativeLayout frameCamContainerLayout = (RelativeLayout) view.findViewById(
-                getResources().getIdentifier("frame_camera_cont", "id", appResourcesPackage)
-            );
+    public void muteStream(boolean mute, Activity activity) {
+        AudioManager audioManager = ((AudioManager) activity.getApplicationContext().getSystemService(Context.AUDIO_SERVICE));
+        int direction;
+        if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.M) {
+            direction = mute ? AudioManager.ADJUST_MUTE : AudioManager.ADJUST_UNMUTE;
+        } else {
+            direction = mute ? AudioManager.ADJUST_LOWER : AudioManager.ADJUST_RAISE;
+        }
+        audioManager.adjustStreamVolume(AudioManager.STREAM_SYSTEM, direction, 0);
+    }
 
-            frameContainerLayout.getLayoutParams().width = frameCamContainerLayout.getHeight();
-            frameContainerLayout.getLayoutParams().height = frameCamContainerLayout.getWidth();
+    public void stopRecord() {
+        logMessage("stopRecord");
 
-            frameCamContainerLayout.getLayoutParams().width = frameCamContainerLayout.getHeight();
-            frameCamContainerLayout.getLayoutParams().height = frameCamContainerLayout.getWidth();
+        try {
+            mRecorder.stop();
+            mRecorder.reset(); // clear recorder configuration
+            mRecorder.release(); // release the recorder object
+            mRecorder = null;
+            startPreview();
+            eventListener.onStopRecordVideo(this.recordFilePath);
+        } catch (Exception e) {
+            eventListener.onStopRecordVideoError(e.getMessage());
+        }
+    }
 
-            frameContainerLayout.invalidate();
-            frameContainerLayout.requestLayout();
+    public boolean isZoomSupported() {
+        if (mCameraCharacteristics == null) return false;
+        return mCameraCharacteristics.get(CameraCharacteristics.SCALER_AVAILABLE_MAX_DIGITAL_ZOOM) > 1;
+    }
 
-            frameCamContainerLayout.forceLayout();
 
-            mPreview.setCameraDisplayOrientation();
+    public float getMaxZoomLevel() {
+        Float maxZoom = null;
+        if(mCameraCharacteristics != null){
+            maxZoom = mCameraCharacteristics.get(CameraCharacteristics.SCALER_AVAILABLE_MAX_DIGITAL_ZOOM);
         }
+        return (maxZoom != null) ? maxZoom : 1.0f;
     }
 
-    public Camera getCamera() {
-        return mCamera;
+    public float getMinZoomLevel() {
+        return 1.0f; // The minimum zoom level is always 1.0 (no zoom)
     }
 
-    public void switchCamera() {
-        // check for availability of multiple cameras
-        if (numberOfCameras == 1) {
-            //There is only one camera available
-        } else {
-            Log.d(TAG, "numberOfCameras: " + numberOfCameras);
-
-            // OK, we have multiple cameras. Release this camera -> cameraCurrentlyLocked
-            if (mCamera != null) {
-                mCamera.stopPreview();
-                mPreview.setCamera(null, -1);
-                mCamera.release();
-                mCamera = null;
-            }
-
-            Log.d(TAG, "cameraCurrentlyLocked := " + Integer.toString(cameraCurrentlyLocked));
-            try {
-                cameraCurrentlyLocked = (cameraCurrentlyLocked + 1) % numberOfCameras;
-                Log.d(TAG, "cameraCurrentlyLocked new: " + cameraCurrentlyLocked);
-            } catch (Exception exception) {
-                Log.d(TAG, exception.getMessage());
-            }
-
-            // Acquire the next camera and request Preview to reconfigure parameters.
-            mCamera = Camera.open(cameraCurrentlyLocked);
-
-            if (cameraParameters != null) {
-                Log.d(TAG, "camera parameter not null");
-
-                // Check for flashMode as well to prevent error on frontward facing camera.
-                List<String> supportedFlashModesNewCamera = mCamera.getParameters().getSupportedFlashModes();
-                String currentFlashModePreviousCamera = cameraParameters.getFlashMode();
-                if (supportedFlashModesNewCamera != null && supportedFlashModesNewCamera.contains(currentFlashModePreviousCamera)) {
-                    Log.d(TAG, "current flash mode supported on new camera. setting params");
-                    /* mCamera.setParameters(cameraParameters);
-            The line above is disabled because parameters that can actually be changed are different from one device to another. Makes less sense trying to reconfigure them when changing camera device while those settings gan be changed using plugin methods.
-         */
-                } else {
-                    Log.d(TAG, "current flash mode NOT supported on new camera");
-                }
-            } else {
-                Log.d(TAG, "camera parameter NULL");
-            }
+    public void setCurrentZoomLevel(float zoomLevel) throws Exception {
+        if(maxZoomLimit != NO_MAX_ZOOM_LIMIT && zoomLevel > maxZoomLimit){
+            logMessage("Zoom level exceeds max zoom limit: " + maxZoomLimit);
+            zoomLevel = maxZoomLimit;
+        }
 
-            mPreview.switchCamera(mCamera, cameraCurrentlyLocked);
+        if (mCameraCharacteristics == null) return;
+        logMessage("setCurrentZoomLevel to: " + zoomLevel);
+        logMessage("currentZoomLevel (before setCurrentZoomLevel): " + getCurrentZoomLevel());
 
-            mCamera.startPreview();
-        }
-    }
+        float maxZoom = getMaxZoomLevel();
+        logMessage("maxZoom: " + maxZoom);
+        float minZoom = getMinZoomLevel();
+        logMessage("minZoom: " + minZoom);
+
+        float newLevel = Math.max(minZoom, Math.min(zoomLevel, maxZoom));
+        logMessage("newLevel: " + newLevel);
 
-    public void setCameraParameters(Camera.Parameters params) {
-        cameraParameters = params;
+        String eventData = "{ \"level\": " + newLevel + " }";
+        bridge.triggerWindowJSEvent("CameraPreview.zoomLevelChanged", eventData);
 
-        if (mCamera != null && cameraParameters != null) {
-            mCamera.setParameters(cameraParameters);
+        Rect zoomRect = getZoomRect(newLevel);
+        if (zoomRect != null) {
+            previewRequestBuilder.set(CaptureRequest.SCALER_CROP_REGION, zoomRect);
+            captureSession.setRepeatingRequest(previewRequestBuilder.build(), null, null);
         }
     }
 
-    public boolean hasFrontCamera() {
-        return getActivity().getApplicationContext().getPackageManager().hasSystemFeature(PackageManager.FEATURE_CAMERA_FRONT);
+
+    public float getCurrentZoomLevel() {
+        if(mCameraCharacteristics != null){
+            Rect activeArraySize = mCameraCharacteristics.get(CameraCharacteristics.SENSOR_INFO_ACTIVE_ARRAY_SIZE);
+            if (activeArraySize != null) {
+                Rect currentCropRegion = previewRequestBuilder.get(CaptureRequest.SCALER_CROP_REGION);
+                if (currentCropRegion != null) {
+                    return (float) activeArraySize.width() / currentCropRegion.width();
+                }
+            }
+        }
+        return getMinZoomLevel(); // Default to minimum zoom if current crop region is unavailable
     }
 
-    public static Bitmap applyMatrix(Bitmap source, Matrix matrix) {
-        return Bitmap.createBitmap(source, 0, 0, source.getWidth(), source.getHeight(), matrix, true);
+    // get supported flash modes
+    public String[] getSupportedFlashModes() {
+        if (mCameraCharacteristics != null) {
+            int[] flashModes = mCameraCharacteristics.get(CameraCharacteristics.CONTROL_AE_AVAILABLE_MODES);
+            String[] flashModesStr = new String[flashModes.length];
+            for (int i = 0; i < flashModes.length; i++) {
+                flashModesStr[i] = flashModes[i] + "";
+            }
+            return flashModesStr;
+        }
+        return new String[0];
     }
 
-    ShutterCallback shutterCallback = new ShutterCallback() {
-        public void onShutter() {
-            // do nothing, availabilty of this callback causes default system shutter sound to work
+    public void setFlashMode(String flashMode) {
+        if (mCameraCharacteristics != null) {
+            previewRequestBuilder.set(CaptureRequest.CONTROL_AE_MODE, Integer.parseInt(flashMode));
+            logMessage("setFlashMode: " + flashMode);
         }
-    };
+    }
 
-    private static int exifToDegrees(int exifOrientation) {
-        if (exifOrientation == ExifInterface.ORIENTATION_ROTATE_90) {
-            return 90;
-        } else if (exifOrientation == ExifInterface.ORIENTATION_ROTATE_180) {
-            return 180;
-        } else if (exifOrientation == ExifInterface.ORIENTATION_ROTATE_270) {
-            return 270;
+    public void onOrientationChange(String orientation) {
+        try {
+            logMessage("onOrientationChanged: " + orientation);
+//            Log.d(TAG, "device orientation: " + getDeviceOrientation());
+//            Log.d(TAG, "sensor orientation: " + getSensorOrientation());
+            configureTransform(textureView.getWidth(), textureView.getHeight());
+        } catch (Exception e) {
+            logException("onOrientationChanged error", e);
         }
-        return 0;
     }
 
-    private String getTempDirectoryPath() {
-        File cache = null;
+    /**
+     * Internal methods and listeners
+     */
+    private Rect getZoomRect(float zoomLevel){
+        if(mCameraCharacteristics == null) return null;
 
-        // Use internal storage
-        cache = getActivity().getCacheDir();
+        Rect activeArraySize = mCameraCharacteristics.get(CameraCharacteristics.SENSOR_INFO_ACTIVE_ARRAY_SIZE);
+        if (activeArraySize == null) return null;
 
-        // Create the cache directory if it doesn't exist
-        cache.mkdirs();
-        return cache.getAbsolutePath();
-    }
 
-    private String getTempFilePath() {
-        return getTempDirectoryPath() + "/cpcp_capture_" + UUID.randomUUID().toString().replace("-", "").substring(0, 8) + ".jpg";
+        int cropWidth = (int) (activeArraySize.width() / zoomLevel);
+        int cropHeight = (int) (activeArraySize.height() / zoomLevel);
+        int cropLeft = (activeArraySize.width() - cropWidth) / 2;
+        int cropTop = (activeArraySize.height() - cropHeight) / 2;
+        return new Rect(cropLeft, cropTop, cropLeft + cropWidth, cropTop + cropHeight);
     }
 
-    PictureCallback jpegPictureCallback = new PictureCallback() {
-        public void onPictureTaken(byte[] data, Camera arg1) {
-            Log.d(TAG, "CameraPreview jpegPictureCallback");
+    private final TextureView.SurfaceTextureListener textureListener = new TextureView.SurfaceTextureListener() {
+        @Override
+        public void onSurfaceTextureAvailable(@NonNull SurfaceTexture surface, int width, int height) {
+            try{
+                openCamera();
+            }catch (Exception e){
+                logException(e);
+            }
+        }
 
-            try {
-                if (!disableExifHeaderStripping) {
-                    Matrix matrix = new Matrix();
-                    if (cameraCurrentlyLocked == Camera.CameraInfo.CAMERA_FACING_FRONT) {
-                        matrix.preScale(1.0f, -1.0f);
-                    }
+        @Override
+        public void onSurfaceTextureSizeChanged(@NonNull SurfaceTexture surface, int width, int height) {
+            try{
+                configureTransform(width, height);
+            }catch (Exception e){
+                logException(e);
+            }
+        }
 
-                    ExifInterface exifInterface = new ExifInterface(new ByteArrayInputStream(data));
-                    int rotation = exifInterface.getAttributeInt(ExifInterface.TAG_ORIENTATION, ExifInterface.ORIENTATION_NORMAL);
-                    int rotationInDegrees = exifToDegrees(rotation);
+        @Override
+        public boolean onSurfaceTextureDestroyed(@NonNull SurfaceTexture surface) {
+            return true;
+        }
 
-                    if (rotation != 0f) {
-                        matrix.preRotate(rotationInDegrees);
-                    }
+        @Override
+        public void onSurfaceTextureUpdated(@NonNull SurfaceTexture surface) {
+        }
+    };
 
-                    // 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);
+    private final CameraDevice.StateCallback stateCallback = new CameraDevice.StateCallback() {
+        @Override
+        public void onOpened(@NonNull CameraDevice camera) {
+            try{
+                cameraDevice = camera;
+                createCameraPreview();
+            }catch (Exception e){
+                logException(e);
+            }
 
-                        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
-                        bitmap.compress(CompressFormat.JPEG, currentQuality, outputStream);
-                        data = outputStream.toByteArray();
-                    }
-                }
+        }
 
-                if (!storeToFile) {
-                    String encodedImage = Base64.encodeToString(data, Base64.NO_WRAP);
+        @Override
+        public void onDisconnected(@NonNull CameraDevice camera) {
+            try{
+                closeCamera();
+            }catch (Exception e){
+                logException(e);
+            }
+        }
 
-                    eventListener.onPictureTaken(encodedImage);
-                } else {
-                    String path = getTempFilePath();
-                    FileOutputStream out = new FileOutputStream(path);
-                    out.write(data);
-                    out.close();
-                    eventListener.onPictureTaken(path);
-                }
-                Log.d(TAG, "CameraPreview pictureTakenHandler called back");
-            } catch (OutOfMemoryError e) {
-                // most likely failed to allocate memory for rotateBitmap
-                Log.d(TAG, "CameraPreview OutOfMemoryError");
-                // failed to allocate memory
-                eventListener.onPictureTakenError("Picture too large (memory)");
-            } catch (IOException e) {
-                Log.d(TAG, "CameraPreview IOException");
-                eventListener.onPictureTakenError("IO Error when extracting exif");
-            } catch (Exception e) {
-                Log.d(TAG, "CameraPreview onPictureTaken general exception");
-            } finally {
-                canTakePicture = true;
-                mCamera.startPreview();
+        @Override
+        public void onError(@NonNull CameraDevice camera, int error) {
+            try{
+                closeCamera();
+            }catch (Exception e){
+                logException(e);
             }
         }
     };
 
-    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);
+    @Override
+    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
+        View view = null;
+        try{
+            String appResourcesPackage = getActivity().getPackageName();
 
-        // convert to landscape if necessary
-        if (size.width < size.height) {
-            int temp = size.width;
-            size.width = size.height;
-            size.height = temp;
-        }
+            // Inflate the layout for this fragment
+            view = inflater.inflate(getResources().getIdentifier("camera_activity", "layout", appResourcesPackage), container, false);
 
-        Camera.Size requestedSize = mCamera.new Size(size.width, size.height);
+            FrameLayout.LayoutParams layoutParams = new FrameLayout.LayoutParams(width, height);
+            layoutParams.setMargins(x, y, 0, 0);
+            frameContainerLayout =
+                    view.findViewById(getResources().getIdentifier("frame_container", "id", appResourcesPackage));
+            frameContainerLayout.setLayoutParams(layoutParams);
 
-        double previewAspectRatio = (double) previewSize.width / (double) previewSize.height;
 
-        if (previewAspectRatio < 1.0) {
-            // reset ratio to landscape
-            previewAspectRatio = 1.0 / previewAspectRatio;
+            mainLayout = view.findViewById(getResources().getIdentifier("video_view", "id", appResourcesPackage));
+            mainLayout.setLayoutParams(
+                    new RelativeLayout.LayoutParams(RelativeLayout.LayoutParams.MATCH_PARENT, RelativeLayout.LayoutParams.MATCH_PARENT)
+            );
+            mainLayout.setEnabled(false);
+
+            // create texture view and add it to mainLayout
+            textureView = new TextureView(getActivity());
+            mainLayout.addView(textureView);
+            textureView.setSurfaceTextureListener(textureListener);
+            textureView.setLayerType(View.LAYER_TYPE_HARDWARE, null);
+
+            if (enableZoom) {
+                setupTouchAndBackButton();
+            }
+        }catch (Exception e){
+            logException(e);
         }
 
-        Log.d(TAG, "CameraPreview previewAspectRatio " + previewAspectRatio);
+        return view;
+    }
+
+    private void setupTouchAndBackButton() {
+        final GestureDetector gestureDetector = new GestureDetector(activity.getApplicationContext(), new TapGestureDetector());
+
+        activity
+                .runOnUiThread(
+                        new Runnable() {
+                            @Override
+                            public void run() {
+                                try{
+                                    frameContainerLayout.setClickable(true);
+                                    frameContainerLayout.setOnTouchListener(
+                                            new View.OnTouchListener() {
+                                                private int mLastTouchX;
+                                                private int mLastTouchY;
+                                                private int mPosX = 0;
+                                                private int mPosY = 0;
+
+                                                @Override
+                                                public boolean onTouch(View v, MotionEvent event) {
+                                                    try {
+                                                        FrameLayout.LayoutParams layoutParams = (FrameLayout.LayoutParams) frameContainerLayout.getLayoutParams();
+
+                                                        boolean isSingleTapTouch = gestureDetector.onTouchEvent(event);
+                                                        int action = event.getAction();
+                                                        int eventCount = event.getPointerCount();
+//                                                    Log.d(TAG, "onTouch event, action, count: " + event + ", " + action + ", " + eventCount);
+                                                        if (eventCount > 1) {
+                                                            // handle multi-touch events
+                                                            if (action == MotionEvent.ACTION_POINTER_DOWN || action == MotionEvent.ACTION_POINTER_2_DOWN) {
+                                                                mDist = getFingerSpacing(event);
+//                                                            Log.d(TAG, "onTouch start: mDist=" + mDist);
+                                                            } else if (action == MotionEvent.ACTION_MOVE && isZoomSupported()) {
+                                                                handlePinchZoom(event);
+                                                            }
+                                                        } else {
+                                                            if (action != MotionEvent.ACTION_MOVE && isSingleTapTouch) {
+                                                                if (tapToTakePicture && tapToFocus) {
+                                                                    int tapX = (int) event.getX(0);
+                                                                    int tapY = (int) event.getY(0);
+                                                                    setFocusArea(
+                                                                            tapX,
+                                                                            tapY,
+                                                                            new CameraCaptureSession.CaptureCallback() {
+                                                                                @Override
+                                                                                public void onCaptureCompleted(@NonNull CameraCaptureSession session, @NonNull CaptureRequest request, @NonNull TotalCaptureResult result) {
+                                                                                    super.onCaptureCompleted(session, request, result);
+                                                                                    try {
+                                                                                        eventListener.onFocusSet(tapX, tapY);
+                                                                                        takePicture(0, 0, 85);
+                                                                                    } catch (Exception e) {
+                                                                                        eventListener.onFocusSetError(e.getMessage());
+                                                                                        logException(e);
+                                                                                    }
+                                                                                }
+                                                                            }
+                                                                    );
+                                                                } else if (tapToTakePicture) {
+                                                                    takePicture(0, 0, 85);
+                                                                } else if (tapToFocus) {
+                                                                    int tapX = (int) event.getX(0);
+                                                                    int tapY = (int) event.getY(0);
+
+                                                                    CameraCaptureSession.CaptureCallback captureCallback =  new CameraCaptureSession.CaptureCallback() {
+                                                                        @Override
+                                                                        public void onCaptureCompleted(@NonNull CameraCaptureSession session, @NonNull CaptureRequest request, @NonNull TotalCaptureResult result) {
+                                                                            super.onCaptureCompleted(session, request, result);
+                                                                            try {
+                                                                                logMessage("onTouch:" + " setFocusArea() succeeded");
+                                                                                eventListener.onFocusSet(tapX, tapY);
+                                                                            } catch (Exception e) {
+                                                                                eventListener.onFocusSetError(e.getMessage());
+                                                                                logException(e);
+                                                                            }
+                                                                        }
+                                                                    };
+
+                                                                    setFocusArea(
+                                                                            tapX,
+                                                                            tapY,
+                                                                            captureCallback
+                                                                    );
+                                                                }
+                                                                return true;
+                                                            } else {
+                                                                if (dragEnabled) {
+                                                                    int x;
+                                                                    int y;
+
+                                                                    switch (event.getAction()) {
+                                                                        case MotionEvent.ACTION_DOWN:
+                                                                            if (mLastTouchX == 0 || mLastTouchY == 0) {
+                                                                                mLastTouchX = (int) event.getRawX() - layoutParams.leftMargin;
+                                                                                mLastTouchY = (int) event.getRawY() - layoutParams.topMargin;
+                                                                            } else {
+                                                                                mLastTouchX = (int) event.getRawX();
+                                                                                mLastTouchY = (int) event.getRawY();
+                                                                            }
+                                                                            break;
+                                                                        case MotionEvent.ACTION_MOVE:
+                                                                            x = (int) event.getRawX();
+                                                                            y = (int) event.getRawY();
+
+                                                                            final float dx = x - mLastTouchX;
+                                                                            final float dy = y - mLastTouchY;
+
+                                                                            mPosX += (int) dx;
+                                                                            mPosY += (int) dy;
+
+                                                                            layoutParams.leftMargin = mPosX;
+                                                                            layoutParams.topMargin = mPosY;
+
+                                                                            frameContainerLayout.setLayoutParams(layoutParams);
+
+                                                                            // Remember this touch position for the next move event
+                                                                            mLastTouchX = x;
+                                                                            mLastTouchY = y;
+
+                                                                            break;
+                                                                        default:
+                                                                            break;
+                                                                    }
+                                                                }
+                                                            }
+                                                        }
+                                                    } catch (Exception e) {
+                                                        logException("onTouch error: ", e);
+                                                    }
+                                                    return true;
+                                                }
+                                            }
+                                    );
+                                    frameContainerLayout.setFocusableInTouchMode(true);
+                                    frameContainerLayout.requestFocus();
+                                    frameContainerLayout.setOnKeyListener(
+                                            new View.OnKeyListener() {
+                                                @Override
+                                                public boolean onKey(View v, int keyCode, android.view.KeyEvent event) {
+                                                    if (keyCode == android.view.KeyEvent.KEYCODE_BACK) {
+                                                        eventListener.onBackButton();
+                                                        return true;
+                                                    }
+                                                    return false;
+                                                }
+                                            }
+                                    );
+                                }catch (Exception e){
+                                    logException(e);
+                                }
+
+                            }
 
-        double aspectTolerance = 0.1;
-        double bestDifference = Double.MAX_VALUE;
+                            private float mDist = 0F;
+                            private long lastZoomTime = 0;
 
-        for (int i = 0; i < supportedSizes.size(); i++) {
-            Camera.Size supportedSize = supportedSizes.get(i);
+                            private void handlePinchZoom(MotionEvent event){
+                                if (cameraDevice == null) return;
+                                try {
+                                    float newDist = getFingerSpacing(event);
 
-            // Perfect match
-            if (supportedSize.equals(requestedSize)) {
-                Log.d(TAG, "CameraPreview optimalPictureSize " + supportedSize.width + 'x' + supportedSize.height);
-                return supportedSize;
-            }
+                                    float maxZoom = getMaxZoomLevel();
+                                    float minZoom = getMinZoomLevel();
 
-            double difference = Math.abs(previewAspectRatio - ((double) supportedSize.width / (double) supportedSize.height));
+                                    float currentZoomLevel = getCurrentZoomLevel();
 
-            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;
-                    }
+                                    float newZoomLevel = currentZoomLevel;
+
+                                    if (newDist > mDist) {
+                                        // Zoom in
+                                        newZoomLevel = Math.min(currentZoomLevel + ((newDist - mDist) * PINCH_ZOOM_SENSITIVITY), maxZoom);
+                                    } else if (newDist < mDist) {
+                                        // Zoom out
+                                        newZoomLevel = Math.max(currentZoomLevel - ((mDist - newDist) * PINCH_ZOOM_SENSITIVITY), minZoom);
+                                    }
+                                    mDist = newDist;
+
+                                    long currentTime = System.currentTimeMillis();
+                                    if (newZoomLevel != currentZoomLevel && (currentTime - lastZoomTime) > PINCH_ZOOM_DEBOUNCE_DELAY_MS) {
+                                        setCurrentZoomLevel(newZoomLevel);
+                                        lastZoomTime = currentTime;
+                                    }
+                                } catch (Exception e) {
+                                    logException(e);
+                                }
+                            }
+                        }
+                );
+    }
+
+    private Handler focusHandler = null;
+    private final int MAX_FOCUS_RETRY_COUNT = 3;
+    private final int FOCUS_RETRY_INTERVAL_MS = 100;
+    private int focusRetryCount = 0;
+
+    public void setFocusArea(final int pointX, final int pointY, final CameraCaptureSession.CaptureCallback callback) throws Exception {
+        if (cameraDevice == null) return;
+
+        previewRequestBuilder.set(CaptureRequest.CONTROL_AF_TRIGGER, CameraMetadata.CONTROL_AF_TRIGGER_CANCEL);
+        captureSession.capture(previewRequestBuilder.build(), new CameraCaptureSession.CaptureCallback() {
+            @Override
+            public void onCaptureCompleted(@NonNull CameraCaptureSession session, @NonNull CaptureRequest request, @NonNull TotalCaptureResult result) {
+                try{
+                    triggerAutofocus(pointX, pointY, callback);
+                }catch (Exception e) {
+                    logException(e);
                 }
             }
-        }
-        Log.d(TAG, "CameraPreview optimalPictureSize " + size.width + 'x' + size.height);
-        return size;
+        }, mBackgroundHandler);
     }
 
-    static byte[] rotateNV21(final byte[] yuv, final int width, final int height, final int rotation) {
-        if (rotation == 0) return yuv;
-        if (rotation % 90 != 0 || rotation < 0 || rotation > 270) {
-            throw new IllegalArgumentException("0 <= rotation < 360, rotation % 90 == 0");
-        }
-
-        final byte[] output = new byte[yuv.length];
-        final int frameSize = width * height;
-        final boolean swap = rotation % 180 != 0;
-        final boolean xflip = rotation % 270 != 0;
-        final boolean yflip = rotation >= 180;
+    private void triggerAutofocus(final int pointX, final int pointY, final CameraCaptureSession.CaptureCallback callback) {
+        try {
+            // Calculate focus and metering areas
+            Rect focusRect = calculateTapArea(pointX, pointY, 1f);
+            Rect meteringRect = calculateTapArea(pointX, pointY, 1.5f);
 
-        for (int j = 0; j < height; j++) {
-            for (int i = 0; i < width; i++) {
-                final int yIn = j * width + i;
-                final int uIn = frameSize + (j >> 1) * width + (i & ~1);
-                final int vIn = uIn + 1;
+            if (focusRect == null || meteringRect == null) {
+                logError("Invalid focus or metering area dimensions");
+                return;
+            }
 
-                final int wOut = swap ? height : width;
-                final int hOut = swap ? width : height;
-                final int iSwapped = swap ? j : i;
-                final int jSwapped = swap ? i : j;
-                final int iOut = xflip ? wOut - iSwapped - 1 : iSwapped;
-                final int jOut = yflip ? hOut - jSwapped - 1 : jSwapped;
+            // Set AF, AE, and AWB regions
+            previewRequestBuilder.set(CaptureRequest.CONTROL_AF_REGIONS, new MeteringRectangle[]{new MeteringRectangle(focusRect, 1000)});
+            previewRequestBuilder.set(CaptureRequest.CONTROL_AE_REGIONS, new MeteringRectangle[]{new MeteringRectangle(meteringRect, 1000)});
+            previewRequestBuilder.set(CaptureRequest.CONTROL_AWB_REGIONS, new MeteringRectangle[]{new MeteringRectangle(meteringRect, 1000)});
 
-                final int yOut = jOut * wOut + iOut;
-                final int uOut = frameSize + (jOut >> 1) * wOut + (iOut & ~1);
-                final int vOut = uOut + 1;
+            // Set AF mode to auto
+            previewRequestBuilder.set(CaptureRequest.CONTROL_AF_MODE, CaptureRequest.CONTROL_AF_MODE_AUTO);
 
-                output[yOut] = (byte) (0xff & yuv[yIn]);
-                output[uOut] = (byte) (0xff & yuv[uIn]);
-                output[vOut] = (byte) (0xff & yuv[vIn]);
-            }
+            // Start autofocus
+            previewRequestBuilder.set(CaptureRequest.CONTROL_AF_TRIGGER, CameraMetadata.CONTROL_AF_TRIGGER_START);
+            captureSession.capture(previewRequestBuilder.build(), new CameraCaptureSession.CaptureCallback() {
+                @Override
+                public void onCaptureCompleted(@NonNull CameraCaptureSession session, @NonNull CaptureRequest request, @NonNull TotalCaptureResult result) {
+                    clearFocusRetry();
+                    focusRetryCount = 0;
+                    handleFocusResult(result, pointX, pointY, callback);
+                }
+            }, mBackgroundHandler);
+        } catch (Exception e) {
+            logException(e);
         }
-        return output;
     }
 
-    public void setOpacity(final float opacity) {
-        Log.d(TAG, "set opacity:" + opacity);
-        this.opacity = opacity;
-        mPreview.setOpacity(opacity);
+
+    private void clearFocusRetry() {
+        if(focusHandler != null) focusHandler.removeCallbacksAndMessages(null);
     }
 
-    public void takeSnapshot(final int quality) {
-        mCamera.setPreviewCallback(
-            new Camera.PreviewCallback() {
-                @Override
-                public void onPreviewFrame(byte[] bytes, Camera camera) {
+    private void handleFocusResult(TotalCaptureResult result, final int pointX, final int pointY, final CameraCaptureSession.CaptureCallback callback) {
+        Integer afState = result.get(CaptureResult.CONTROL_AF_STATE);
+        if (afState == null) return;
+        switch (afState) {
+            case CaptureResult.CONTROL_AF_STATE_FOCUSED_LOCKED:
+            case CaptureResult.CONTROL_AF_STATE_NOT_FOCUSED_LOCKED:
+                // Focus is complete, reset AF trigger
+                clearFocusRetry();
+                previewRequestBuilder.set(CaptureRequest.CONTROL_AF_TRIGGER, CameraMetadata.CONTROL_AF_TRIGGER_IDLE);
+                try {
+                    captureSession.setRepeatingRequest(previewRequestBuilder.build(), null, mBackgroundHandler);
+                    callback.onCaptureCompleted(captureSession, previewRequestBuilder.build(), result);
+                } catch (Exception e) {
+                    logException(e);
+                }
+                break;
+
+            case CaptureResult.CONTROL_AF_STATE_INACTIVE:
+            case CaptureResult.CONTROL_AF_STATE_PASSIVE_SCAN:
+            case CaptureResult.CONTROL_AF_STATE_PASSIVE_FOCUSED:
+            case CaptureResult.CONTROL_AF_STATE_PASSIVE_UNFOCUSED:
+                // Retry autofocus if necessary
+                clearFocusRetry();
+                focusRetryCount++;
+                if (focusRetryCount >= MAX_FOCUS_RETRY_COUNT) {
+                    Log.d(TAG,"Max focus retry count reached");
+                    return;
+                }
+                focusHandler = new Handler(Looper.getMainLooper());
+                focusHandler.postDelayed(() -> {
                     try {
-                        Camera.Parameters parameters = camera.getParameters();
-                        Camera.Size size = parameters.getPreviewSize();
-                        int orientation = mPreview.getDisplayOrientation();
-                        if (mPreview.getCameraFacing() == Camera.CameraInfo.CAMERA_FACING_FRONT) {
-                            bytes = rotateNV21(bytes, size.width, size.height, (360 - orientation) % 360);
-                        } else {
-                            bytes = rotateNV21(bytes, size.width, size.height, orientation);
-                        }
-                        // switch width/height when rotating 90/270 deg
-                        Rect rect = orientation == 90 || orientation == 270
-                            ? new Rect(0, 0, size.height, size.width)
-                            : new Rect(0, 0, size.width, size.height);
-                        YuvImage yuvImage = new YuvImage(bytes, parameters.getPreviewFormat(), rect.width(), rect.height(), null);
-                        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
-                        yuvImage.compressToJpeg(rect, quality, byteArrayOutputStream);
-                        byte[] data = byteArrayOutputStream.toByteArray();
-                        byteArrayOutputStream.close();
-                        eventListener.onSnapshotTaken(Base64.encodeToString(data, Base64.NO_WRAP));
-                    } catch (IOException e) {
-                        Log.d(TAG, "CameraPreview IOException");
-                        eventListener.onSnapshotTakenError("IO Error");
-                    } finally {
-                        mCamera.setPreviewCallback(null);
+                        triggerAutofocus(pointX, pointY, callback);
+                    } catch (Exception e) {
+                        logException(e);
                     }
+                }, FOCUS_RETRY_INTERVAL_MS);
+                break;
+
+            case CaptureResult.CONTROL_AF_STATE_ACTIVE_SCAN:
+                // Autofocus is still in progress, wait and check again
+                clearFocusRetry();
+                focusRetryCount++;
+                if (focusRetryCount >= MAX_FOCUS_RETRY_COUNT) {
+                    Log.d(TAG,"Max focus retry count reached");
+                    return;
                 }
-            }
-        );
+                focusHandler = new Handler(Looper.getMainLooper());
+                focusHandler.postDelayed(() -> {
+                    try {
+                        handleFocusResult(result, pointX, pointY, callback);
+                    } catch (Exception e) {
+                        logException(e);
+                    }
+                }, FOCUS_RETRY_INTERVAL_MS);
+                break;
+        }
     }
 
-    public void takePicture(final int width, final int height, final int quality) {
-        Log.d(TAG, "CameraPreview takePicture width: " + width + ", height: " + height + ", quality: " + quality);
+    private Rect calculateTapArea(float x, float y, float coefficient) {
+        int areaSize = Math.round(200 * coefficient);
+
+        int left = clamp((int) x - areaSize / 2, 0, textureView.getWidth() - areaSize);
+        int top = clamp((int) y - areaSize / 2, 0, textureView.getHeight() - areaSize);
+
+        int right = left + areaSize;
+        int bottom = top + areaSize;
+
+        if (left >= right || top >= bottom) {
+            logError("Calculated tap area has invalid dimensions");
+            return null; // Return null for invalid dimensions
+        }
+
+        return new Rect(left, top, right, bottom);
+    }
+
+    /**
+     * Determine the space between the first two fingers
+     */
+    private static float getFingerSpacing(MotionEvent event) {
+        float x = event.getX(0) - event.getX(1);
+        float y = event.getY(0) - event.getY(1);
+        return (float) Math.sqrt(x * x + y * y);
+    }
 
-        if (mPreview != null) {
-            if (!canTakePicture) {
+    @SuppressLint("MissingPermission")
+    private void openCamera() {
+        CameraManager manager = (CameraManager) activity.getSystemService(Context.CAMERA_SERVICE);
+        try {
+            cameraId = findCameraIdForPosition();
+            mCameraCharacteristics = manager.getCameraCharacteristics(cameraId);
+            mSupportedPreviewSizes = getSupportedPreviewSizes(cameraId);
+            if (ActivityCompat.checkSelfPermission(activity, Manifest.permission.CAMERA) != PackageManager.PERMISSION_GRANTED) {
+                ActivityCompat.requestPermissions(activity, new String[]{Manifest.permission.CAMERA}, REQUEST_CAMERA_PERMISSION);
                 return;
             }
 
-            canTakePicture = false;
+            manager.openCamera(cameraId, stateCallback, null);
+        } catch (Exception e) {
+            logException(e);
+        }
+    }
+
+    private String findCameraIdForPosition() throws Exception {
+        CameraManager manager = (CameraManager) activity.getSystemService(Context.CAMERA_SERVICE);
+        for (String cameraId : manager.getCameraIdList()) {
+            CameraCharacteristics characteristics = manager.getCameraCharacteristics(cameraId);
+            int cOrientation = characteristics.get(CameraCharacteristics.LENS_FACING);
+            if (position.equals("front") && cOrientation == CameraCharacteristics.LENS_FACING_FRONT) {
+                return cameraId;
+            } else if (position.equals("back") && cOrientation == CameraCharacteristics.LENS_FACING_BACK) {
+                return cameraId;
+            }
+        }
+        return "0";
+    }
+
+    private void createCameraPreview() {
+        try {
+            SurfaceTexture texture = textureView.getSurfaceTexture();
 
-            new Thread() {
-                public void run() {
-                    Camera.Parameters params = mCamera.getParameters();
+            // Get display metrics
+            DisplayMetrics displayMetrics = new DisplayMetrics();
+            activity.getWindowManager().getDefaultDisplay().getMetrics(displayMetrics);
+            float density = displayMetrics.density; // DPR
 
-                    Camera.Size size = getOptimalPictureSize(width, height, params.getPreviewSize(), params.getSupportedPictureSizes());
-                    params.setPictureSize(size.width, size.height);
-                    currentQuality = quality;
+            int desiredWidthPx = (int) (textureView.getWidth() * density);
+            int desiredHeightPx = (int) (textureView.getHeight() * density);
 
-                    if (cameraCurrentlyLocked == Camera.CameraInfo.CAMERA_FACING_FRONT && !storeToFile) {
-                        // The image will be recompressed in the callback
-                        params.setJpegQuality(99);
-                    } else {
-                        params.setJpegQuality(quality);
-                    }
+            mPreviewSize = getOptimalPreviewSize(mSupportedPreviewSizes, desiredWidthPx, desiredHeightPx);
 
-                    if (cameraCurrentlyLocked == Camera.CameraInfo.CAMERA_FACING_FRONT && disableExifHeaderStripping) {
-                        Activity activity = getActivity();
-                        int rotation = activity.getWindowManager().getDefaultDisplay().getRotation();
-                        int degrees = 0;
-                        switch (rotation) {
-                            case Surface.ROTATION_0:
-                                degrees = 0;
-                                break;
-                            case Surface.ROTATION_90:
-                                degrees = 180;
-                                break;
-                            case Surface.ROTATION_180:
-                                degrees = 270;
-                                break;
-                            case Surface.ROTATION_270:
-                                degrees = 0;
-                                break;
-                        }
-                        int orientation;
-                        Camera.CameraInfo info = new Camera.CameraInfo();
-                        if (info.facing == Camera.CameraInfo.CAMERA_FACING_FRONT) {
-                            orientation = (info.orientation + degrees) % 360;
-                            if (degrees != 0) {
-                                orientation = (360 - orientation) % 360;
-                            }
-                        } else {
-                            orientation = (info.orientation - degrees + 360) % 360;
+            assert texture != null;
+            texture.setDefaultBufferSize(mPreviewSize.getWidth(), mPreviewSize.getHeight());
+            configureTransform(textureView.getWidth(), textureView.getHeight());
+            Surface surface = new Surface(texture);
+            previewRequestBuilder = cameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);
+            previewRequestBuilder.addTarget(surface);
+
+            cameraDevice.createCaptureSession(Collections.singletonList(surface), new CameraCaptureSession.StateCallback() {
+                @Override
+                public void onConfigured(@NonNull CameraCaptureSession cameraCaptureSession) {
+                    try{
+                        if (cameraDevice == null) {
+                            return;
                         }
-                        params.setRotation(orientation);
-                    } else {
-                        params.setRotation(mPreview.getDisplayOrientation());
+                        captureSession = cameraCaptureSession;
+                        eventListener.onCameraStarted();
+                        updatePreview();
+                    }catch (Exception e){
+                        logException(e);
                     }
+                }
 
-                    mCamera.setParameters(params);
-                    mCamera.takePicture(shutterCallback, null, jpegPictureCallback);
+                @Override
+                public void onConfigureFailed(@NonNull CameraCaptureSession cameraCaptureSession) {
+                    logException(new Exception("Camera preview configuration failed"));
                 }
-            }
-                .start();
-        } else {
-            canTakePicture = true;
+            }, null);
+        } catch (Exception e) {
+            logException(e);
         }
     }
 
-    public void startRecord(
-        final String filePath,
-        final String camera,
-        final int width,
-        final int height,
-        final int quality,
-        final boolean withFlash,
-        final int maxDuration
-    ) {
-        Log.d(TAG, "CameraPreview startRecord camera: " + camera + " width: " + width + ", height: " + height + ", quality: " + quality);
-        Activity activity = getActivity();
-        muteStream(true, activity);
-        if (this.mRecordingState == RecordingState.STARTED) {
-            Log.d(TAG, "Already Recording");
-            return;
+    private void updatePreview() {
+        if (cameraDevice == null) {
+            logException(new Exception("updatePreview error, return"));
+        }
+        previewRequestBuilder.set(CaptureRequest.CONTROL_MODE, CameraMetadata.CONTROL_MODE_AUTO);
+        try {
+            captureSession.setRepeatingRequest(previewRequestBuilder.build(), null, null);
+        } catch (Exception e) {
+            logException(e);
         }
+    }
 
-        this.recordFilePath = filePath;
-        int mOrientationHint = calculateOrientationHint();
-        int videoWidth = 0; //set whatever
-        int videoHeight = 0; //set whatever
+    @Override
+    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
+        if (requestCode == REQUEST_CAMERA_PERMISSION) {
+            if (grantResults[0] != PackageManager.PERMISSION_GRANTED) {
+                // Permission denied
+                activity.finish();
+            }
+        }
+    }
 
-        Camera.Parameters cameraParams = mCamera.getParameters();
-        if (withFlash) {
-            cameraParams.setFlashMode(withFlash ? Camera.Parameters.FLASH_MODE_TORCH : Camera.Parameters.FLASH_MODE_OFF);
-            mCamera.setParameters(cameraParams);
-            mCamera.startPreview();
+    private Size getOptimalPreviewSize(Size[] sizes, int w, int h) {
+        final double ASPECT_TOLERANCE = 0.1;
+        double targetRatio = (double) w / h;
+        int sensorOrientation = mCameraCharacteristics.get(CameraCharacteristics.SENSOR_ORIENTATION);
+        if (sensorOrientation == 90 || sensorOrientation == 270) {
+            targetRatio = (double) h / w;
         }
 
-        mCamera.unlock();
-        mRecorder = new MediaRecorder();
+        if (sizes == null) {
+            return null;
+        }
 
-        try {
-            mRecorder.setCamera(mCamera);
+        Size optimalSize = null;
+        double minDiff = Double.MAX_VALUE;
 
-            CamcorderProfile profile;
-            if (CamcorderProfile.hasProfile(defaultCameraId, CamcorderProfile.QUALITY_HIGH)) {
-                profile = CamcorderProfile.get(defaultCameraId, CamcorderProfile.QUALITY_HIGH);
-            } else {
-                if (CamcorderProfile.hasProfile(defaultCameraId, CamcorderProfile.QUALITY_480P)) {
-                    profile = CamcorderProfile.get(defaultCameraId, CamcorderProfile.QUALITY_480P);
-                } else {
-                    if (CamcorderProfile.hasProfile(defaultCameraId, CamcorderProfile.QUALITY_720P)) {
-                        profile = CamcorderProfile.get(defaultCameraId, CamcorderProfile.QUALITY_720P);
-                    } else {
-                        if (CamcorderProfile.hasProfile(defaultCameraId, CamcorderProfile.QUALITY_1080P)) {
-                            profile = CamcorderProfile.get(defaultCameraId, CamcorderProfile.QUALITY_1080P);
-                        } else {
-                            profile = CamcorderProfile.get(defaultCameraId, CamcorderProfile.QUALITY_LOW);
-                        }
-                    }
-                }
-            }
+        int targetHeight = h;
 
-            mRecorder.setAudioSource(MediaRecorder.AudioSource.VOICE_RECOGNITION);
-            mRecorder.setVideoSource(MediaRecorder.VideoSource.CAMERA);
-            mRecorder.setProfile(profile);
-            mRecorder.setOutputFile(filePath);
-            mRecorder.setOrientationHint(mOrientationHint);
-            mRecorder.setMaxDuration(maxDuration);
+        // Try to find an size match aspect ratio and size
+        for (Size size : sizes) {
+            double ratio = (double) size.getWidth() / size.getHeight();
+            if (Math.abs(ratio - targetRatio) > ASPECT_TOLERANCE) continue;
+            if (Math.abs(size.getHeight() - targetHeight) < minDiff) {
+                optimalSize = size;
+                minDiff = Math.abs(size.getHeight() - targetHeight);
+            }
+        }
 
-            mRecorder.prepare();
-            Log.d(TAG, "Starting recording");
-            mRecorder.start();
-            eventListener.onStartRecordVideo();
-        } catch (IOException e) {
-            eventListener.onStartRecordVideoError(e.getMessage());
+        // Cannot find the one match the aspect ratio, ignore the requirement
+        if (optimalSize == null) {
+            minDiff = Double.MAX_VALUE;
+            for (Size size : sizes) {
+                if (Math.abs(size.getHeight() - targetHeight) < minDiff) {
+                    optimalSize = size;
+                    minDiff = Math.abs(size.getHeight() - targetHeight);
+                }
+            }
         }
+
+//        Log.d(TAG, "optimal preview size: w: " + optimalSize.getWidth() + " h: " + optimalSize.getHeight());
+        return optimalSize;
     }
 
-    public int calculateOrientationHint() {
-        DisplayMetrics dm = new DisplayMetrics();
-        Camera.CameraInfo info = new Camera.CameraInfo();
-        Camera.getCameraInfo(defaultCameraId, info);
-        int cameraRotationOffset = info.orientation;
-        Activity activity = getActivity();
+    private int getOrientationHint() {
+        int deviceRotation = getDeviceOrientation();
+        int sensorOrientation = getSensorOrientation();
+        return (sensorOrientation - deviceRotation + 360) % 360;
+    }
 
-        activity.getWindowManager().getDefaultDisplay().getMetrics(dm);
-        int currentScreenRotation = activity.getWindowManager().getDefaultDisplay().getRotation();
+    private int getDeviceOrientation() {
+        WindowManager windowManager = (WindowManager) activity.getSystemService(Context.WINDOW_SERVICE);
+        int rotation = windowManager.getDefaultDisplay().getRotation();
 
-        int degrees = 0;
-        switch (currentScreenRotation) {
+        int deviceRotation = 0;
+        switch (rotation) {
             case Surface.ROTATION_0:
-                degrees = 0;
+                deviceRotation = 0;
                 break;
             case Surface.ROTATION_90:
-                degrees = 90;
+                deviceRotation = 90;
                 break;
             case Surface.ROTATION_180:
-                degrees = 180;
+                deviceRotation = 180;
                 break;
             case Surface.ROTATION_270:
-                degrees = 270;
+                deviceRotation = 270;
                 break;
         }
+        return deviceRotation;
+    }
 
-        int orientation;
-        if (info.facing == Camera.CameraInfo.CAMERA_FACING_FRONT) {
-            orientation = (cameraRotationOffset + degrees) % 360;
-            if (degrees != 0) {
-                orientation = (360 - orientation) % 360;
-            }
+    private int getSensorOrientation() {
+        if (mCameraCharacteristics == null) return -1;
+        return mCameraCharacteristics.get(CameraCharacteristics.SENSOR_ORIENTATION);
+    }
+
+    private void configureTransform(int viewWidth, int viewHeight) {
+        if (cameraDevice == null || !textureView.isAvailable() || mPreviewSize == null) {
+            return;
+        }
+
+        Matrix matrix = new Matrix();
+
+        int sensorRotation = getSensorOrientation();
+        int deviceRotation = getDeviceOrientation();
+
+        int centerX = viewWidth / 2;
+        int centerY = viewHeight / 2;
+
+        // Set the rotation transformation
+        if (getDeviceOrientation() == getSensorOrientation() || Math.abs(getDeviceOrientation() - getSensorOrientation()) == 180 || getDeviceOrientation() == 180) {
+            matrix.postRotate(-sensorRotation, centerX, centerY);
         } else {
-            orientation = (cameraRotationOffset - degrees + 360) % 360;
+            matrix.postRotate(sensorRotation, centerX, centerY);
         }
-        Log.w(TAG, "************orientationHint ***********= " + orientation);
 
-        return orientation;
-    }
 
-    public void stopRecord() {
-        Log.d(TAG, "stopRecord");
+        // Calculate aspect ratio scaling
+        float previewAspectRatio = (float) mPreviewSize.getWidth() / mPreviewSize.getHeight();
+        float viewAspectRatio = (float) viewWidth / viewHeight;
+        float scaleX = 1.0f;
+        float scaleY = 1.0f;
+
+        if (previewAspectRatio > viewAspectRatio) {
+            scaleX = previewAspectRatio / viewAspectRatio;
+        } else {
+            scaleY = viewAspectRatio / previewAspectRatio;
+        }
+
+        // Apply the scale transformation
+        matrix.postScale(scaleX, scaleY, centerX, centerY);
+
+        // Undo the rotation transformation
+        if (getDeviceOrientation() != getSensorOrientation()) {
+            if (Math.abs(getDeviceOrientation() - getSensorOrientation()) != 180) {
+                matrix.postRotate(-sensorRotation, centerX, centerY);
+            } else {
+                matrix.postRotate(sensorRotation - deviceRotation, centerX, centerY);
+            }
+
+        }
+
+        // Apply the transformation
+        textureView.setTransform(matrix);
+    }
 
+    public Size[] getSupportedPreviewSizes(String cameraId) {
+        CameraManager cameraManager = (CameraManager) context.getSystemService(Context.CAMERA_SERVICE);
         try {
-            mRecorder.stop();
-            mRecorder.reset(); // clear recorder configuration
-            mRecorder.release(); // release the recorder object
-            mRecorder = null;
-            mCamera.lock();
-            Camera.Parameters cameraParams = mCamera.getParameters();
-            cameraParams.setFlashMode(Camera.Parameters.FLASH_MODE_OFF);
-            mCamera.setParameters(cameraParams);
-            mCamera.startPreview();
-            eventListener.onStopRecordVideo(this.recordFilePath);
+            CameraCharacteristics characteristics = cameraManager.getCameraCharacteristics(cameraId);
+            StreamConfigurationMap map = characteristics.get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP);
+
+            if (map != null) {
+                return map.getOutputSizes(SurfaceTexture.class);
+            } else {
+                // Handle the case where map is null
+                return new Size[0];
+            }
         } catch (Exception e) {
-            eventListener.onStopRecordVideoError(e.getMessage());
+            logException(e);
+            // Handle the exception
+            return new Size[0];
         }
     }
 
-    public void muteStream(boolean mute, Activity activity) {
-        AudioManager audioManager = ((AudioManager) activity.getApplicationContext().getSystemService(Context.AUDIO_SERVICE));
-        int direction = mute ? audioManager.ADJUST_MUTE : audioManager.ADJUST_UNMUTE;
-    }
 
-    public void setFocusArea(final int pointX, final int pointY, final Camera.AutoFocusCallback callback) {
-        if (mCamera != null) {
-            mCamera.cancelAutoFocus();
+    @Override
+    public void onPause() {
+        closeCamera();
+        stopBackgroundThread();
 
-            Camera.Parameters parameters = mCamera.getParameters();
+        super.onPause();
+    }
 
-            Rect focusRect = calculateTapArea(pointX, pointY, 1f);
-            parameters.setFocusMode(Camera.Parameters.FOCUS_MODE_AUTO);
-            parameters.setFocusAreas(Arrays.asList(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)));
-            }
+    @Override
+    public void onResume() {
+        super.onResume();
+        if (textureView.isAvailable()) {
+            openCamera();
+        } else {
+            textureView.setSurfaceTextureListener(textureListener);
+        }
+        startBackgroundThread();
 
-            try {
-                setCameraParameters(parameters);
-                mCamera.autoFocus(callback);
-            } catch (Exception e) {
-                Log.d(TAG, e.getMessage());
-                callback.onAutoFocus(false, this.mCamera);
-            }
+    }
+
+    private void closeCamera() {
+        if (cameraDevice != null) {
+            cameraDevice.close();
+            cameraDevice = null;
+            mCameraCharacteristics = null;
+            mSupportedPreviewSizes = null;
+            mPreviewSize = null;
         }
     }
 
-    private Rect calculateTapArea(float x, float y, float coefficient) {
-        if (x < 100) {
-            x = 100;
+    private String getTempDirectoryPath() {
+        File cache = null;
+
+        // Use internal storage
+        cache = activity.getCacheDir();
+
+        // Create the cache directory if it doesn't exist
+        cache.mkdirs();
+        return cache.getAbsolutePath();
+    }
+
+    private String getTempFilePath() {
+        return getTempDirectoryPath() + "/cpcp_capture_" + UUID.randomUUID().toString().replace("-", "").substring(0, 8) + ".jpg";
+    }
+
+    private void startBackgroundThread() {
+        mBackgroundThread = new HandlerThread("Camera Background");
+        mBackgroundThread.start();
+        mBackgroundHandler = new Handler(mBackgroundThread.getLooper());
+    }
+
+    private void stopBackgroundThread() {
+        mBackgroundThread.quitSafely();
+        try {
+            mBackgroundThread.join();
+            mBackgroundThread = null;
+            mBackgroundHandler = null;
+        } catch (Exception e) {
+            logException(e);
         }
-        if (x > width - 100) {
-            x = width - 100;
+    }
+
+    private void startPreview() throws Exception {
+        if (cameraDevice == null || !textureView.isAvailable() || mPreviewSize == null) {
+            return;
         }
-        if (y < 100) {
-            y = 100;
+        SurfaceTexture texture = textureView.getSurfaceTexture();
+        assert texture != null;
+        texture.setDefaultBufferSize(mPreviewSize.getWidth(), mPreviewSize.getHeight());
+        Surface surface = new Surface(texture);
+        previewRequestBuilder = cameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);
+        previewRequestBuilder.addTarget(surface);
+        cameraDevice.createCaptureSession(Collections.singletonList(surface), new CameraCaptureSession.StateCallback() {
+            @Override
+            public void onConfigured(@NonNull CameraCaptureSession cameraCaptureSession) {
+                try{
+                    if (cameraDevice == null) {
+                        return;
+                    }
+                    captureSession = cameraCaptureSession;
+                    updatePreview();
+                }catch (Exception e){
+                    logException(e);
+                }
+            }
+
+            @Override
+            public void onConfigureFailed(@NonNull CameraCaptureSession cameraCaptureSession) {
+                logException(new Exception("Configuration change"));
+            }
+        }, null);
+    }
+
+    private int getCameraToUse() {
+        if (cameraId != null) {
+            return Integer.parseInt(cameraId);
         }
-        if (y > height - 100) {
-            y = height - 100;
+        return 0;
+    }
+
+    private void logException(Exception e) {
+        logError(e.getMessage());
+    }
+
+    private void logException(String message, Exception e) {
+        logError(message + ": " + e.getMessage());
+    }
+
+    private void logError(String message) {
+        Log.e(TAG, message);
+        if (bridge != null) {
+            try{
+                String sanitisedMessage = message.replace("\"", "\\\"");
+                bridge.triggerWindowJSEvent("CameraPreview.error", "{ \"message\": \"" + sanitisedMessage + "\" }");
+            }catch (Exception e){
+                Log.e(TAG, "Error in logError: " + e.getMessage());
+            }
         }
-        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)
-        );
     }
 
-    /**
-     * Determine the space between the first two fingers
-     */
-    private static float getFingerSpacing(MotionEvent event) {
-        // ...
-        float x = event.getX(0) - event.getX(1);
-        float y = event.getY(0) - event.getY(1);
-        return (float) Math.sqrt(x * x + y * y);
+    private void logMessage(String message) {
+        Log.d(TAG, message);
+        if (bridge != null) {
+            try{
+                String sanitisedMessage = message.replace("\"", "\\\"");
+                bridge.triggerWindowJSEvent("CameraPreview.log", "{ \"message\": \"" + sanitisedMessage + "\" }");
+            }catch (Exception e){
+                Log.e(TAG, "Error in logMessage: " + e.getMessage());
+            }
+        }
     }
 }
diff --git a/android/src/main/java/com/ahm/capacitor/camera/preview/CameraPreview.java b/android/src/main/java/com/ahm/capacitor/camera/preview/CameraPreview.java
index 784a15b6..a94a8406 100644
--- a/android/src/main/java/com/ahm/capacitor/camera/preview/CameraPreview.java
+++ b/android/src/main/java/com/ahm/capacitor/camera/preview/CameraPreview.java
@@ -2,19 +2,30 @@
 
 import static android.Manifest.permission.CAMERA;
 
+import android.annotation.SuppressLint;
 import android.app.FragmentManager;
 import android.app.FragmentTransaction;
+import android.content.Context;
 import android.content.pm.ActivityInfo;
+import android.content.res.Configuration;
 import android.graphics.Color;
 import android.graphics.Point;
 import android.hardware.Camera;
+import android.hardware.camera2.CameraCharacteristics;
+import android.hardware.camera2.CameraDevice;
+import android.hardware.camera2.CameraManager;
+import android.hardware.camera2.params.StreamConfigurationMap;
+import android.os.Build;
 import android.util.DisplayMetrics;
+import android.util.Size;
+import android.util.SizeF;
 import android.util.TypedValue;
 import android.view.Display;
 import android.view.MotionEvent;
 import android.view.View;
 import android.view.ViewGroup;
 import android.widget.FrameLayout;
+
 import com.getcapacitor.JSObject;
 import com.getcapacitor.Logger;
 import com.getcapacitor.PermissionState;
@@ -25,8 +36,13 @@
 import com.getcapacitor.annotation.Permission;
 import com.getcapacitor.annotation.PermissionCallback;
 import java.io.File;
+import java.lang.reflect.Field;
+import java.lang.reflect.Modifier;
 import java.util.List;
+import java.util.Set;
+
 import org.json.JSONArray;
+import org.json.JSONObject;
 
 @CapacitorPlugin(name = "CameraPreview", permissions = { @Permission(strings = { CAMERA }, alias = CameraPreview.CAMERA_PERMISSION_ALIAS) })
 public class CameraPreview extends Plugin implements CameraActivity.CameraPreviewListener {
@@ -46,21 +62,29 @@ public class CameraPreview extends Plugin implements CameraActivity.CameraPrevie
 
     private CameraActivity fragment;
     private int containerViewId = 20;
+    
 
     @PluginMethod
     public void start(PluginCall call) {
-        if (PermissionState.GRANTED.equals(getPermissionState(CAMERA_PERMISSION_ALIAS))) {
-            startCamera(call);
-        } else {
-            requestPermissionForAlias(CAMERA_PERMISSION_ALIAS, call, "handleCameraPermissionResult");
+        try{
+            if (PermissionState.GRANTED.equals(getPermissionState(CAMERA_PERMISSION_ALIAS))) {
+                startCamera(call);
+            } else {
+                requestPermissionForAlias(CAMERA_PERMISSION_ALIAS, call, "handleCameraPermissionResult");
+            }    
+        }catch (Exception e) {
+            Logger.debug(getLogTag(), "Start camera exception: " + e);
+            call.reject("failed to start camera");
         }
     }
 
     @PluginMethod
     public void flip(PluginCall call) {
         try {
+            bridge.saveCall(call);
+            cameraStartCallbackId = call.getCallbackId();
             fragment.switchCamera();
-            call.resolve();
+            call.setKeepAlive(true);
         } catch (Exception e) {
             Logger.debug(getLogTag(), "Camera flip exception: " + e);
             call.reject("failed to flip camera");
@@ -68,313 +92,773 @@ public void flip(PluginCall call) {
     }
 
     @PluginMethod
-    public void setOpacity(PluginCall call) {
-        if (this.hasCamera(call) == false) {
-            call.error("Camera is not running");
-            return;
-        }
+    public void getCameraCharacteristics(PluginCall call) {
+        try {
+            // if device is running Android P or later, list available cameras and their focal lengths
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
+                CameraManager manager = (CameraManager) this.bridge.getContext().getSystemService(Context.CAMERA_SERVICE);
+                try {
+                    JSONArray logicalCameras = new JSONArray();
+                    String[] cameraIdList = manager.getCameraIdList();
+                    for (String id : cameraIdList) {
+                        /*
+                         * Logical camera details
+                         */
+                        JSObject logicalCamera = new JSObject();
+                        logicalCamera.put("LOGICAL_ID", id);
+                        JSONArray physicalCameras = new JSONArray();
+
+                        CameraCharacteristics characteristics = manager.getCameraCharacteristics(id);
+
+                        // INFO_SUPPORTED_HARDWARE_LEVEL
+                        Integer supportLevel = characteristics.get(CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL);
+                        if(supportLevel != null) logicalCamera.put("INFO_SUPPORTED_HARDWARE_LEVEL", supportLevel);
+
+                        // LENS_FACING
+                        Integer lensFacing = characteristics.get(CameraCharacteristics.LENS_FACING);
+                        if(lensFacing != null) logicalCamera.put("LENS_FACING", lensFacing);
+
+                        // SENSOR_INFO_PHYSICAL_SIZE
+                        SizeF sensorInfoPhysicalSize = characteristics.get(CameraCharacteristics.SENSOR_INFO_PHYSICAL_SIZE);
+                        if(sensorInfoPhysicalSize != null) {
+                            logicalCamera.put("SENSOR_INFO_PHYSICAL_SIZE_WIDTH", sensorInfoPhysicalSize.getWidth());
+                            logicalCamera.put("SENSOR_INFO_PHYSICAL_SIZE_HEIGHT", sensorInfoPhysicalSize.getHeight());
+                        }
+
+                        // SENSOR_INFO_PIXEL_ARRAY_SIZE
+                        Size sensorInfoPixelSize = characteristics.get(CameraCharacteristics.SENSOR_INFO_PIXEL_ARRAY_SIZE);
+                        if(sensorInfoPixelSize != null) {
+                            logicalCamera.put("SENSOR_INFO_PIXEL_ARRAY_SIZE_WIDTH", sensorInfoPixelSize.getWidth());
+                            logicalCamera.put("SENSOR_INFO_PIXEL_ARRAY_SIZE_HEIGHT", sensorInfoPixelSize.getHeight());
+                        }
+
+                        // LENS_INFO_AVAILABLE_FOCAL_LENGTHS
+                        float[] focalLengths = characteristics.get(CameraCharacteristics.LENS_INFO_AVAILABLE_FOCAL_LENGTHS);
+                        JSONArray focalLengthsArray = new JSONArray();
+                        for (int focusId=0; focusId<focalLengths.length; focusId++) {
+                            JSONObject focalLengthsData = new JSONObject();
+                            focalLengthsData.put("FOCAL_LENGTH", new Double(focalLengths[focusId]));
+                            focalLengthsArray.put(focalLengthsData);
+                        }
+                        logicalCamera.put("LENS_INFO_AVAILABLE_FOCAL_LENGTHS", focalLengthsArray);
+
+                        /*
+                         * Physical camera details
+                         */
+                        Set<String> physicalCameraIds = characteristics.getPhysicalCameraIds();
+                        for (String physicalId : physicalCameraIds) {
+                            JSObject physicalCamera = new JSObject();
+                            physicalCamera.put("PHYSICAL_ID", physicalId);
+                            
+                            CameraCharacteristics physicalCharacteristics = manager.getCameraCharacteristics(physicalId);
+
+                            float[] lensFocalLengths = physicalCharacteristics.get(CameraCharacteristics.LENS_INFO_AVAILABLE_FOCAL_LENGTHS);
+                            if (lensFocalLengths != null && focalLengths.length > 0) {
+                                float focalLength = lensFocalLengths[0];
+                                physicalCamera.put("LENS_INFO_AVAILABLE_FOCAL_LENGTHS", focalLength);
+                            }
+
+                            StreamConfigurationMap map = physicalCharacteristics.get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP);
+                            if (map != null) {
+                                int[] outputFormats = map.getOutputFormats();
+                                JSONArray formats = new JSONArray();
+                                for (int format : outputFormats) {
+                                    formats.put(format);
+                                }
+                                physicalCamera.put("SCALER_STREAM_CONFIGURATION_MAP", formats);
+                            }
+
+                            Size[] outputSizes = map.getOutputSizes(256);
+                            if(outputSizes != null && outputSizes.length > 0) {
+                                JSONArray sizes = new JSONArray();
+                                for (Size size : outputSizes) {
+                                    JSONObject sizeObject = new JSONObject();
+                                    sizeObject.put("WIDTH", size.getWidth());
+                                    sizeObject.put("HEIGHT", size.getHeight());
+                                    sizes.put(sizeObject);
+                                }
+                                physicalCamera.put("OUTPUT_SIZES", sizes);
+                            }
+
+                            Size[] inputSizes = map.getInputSizes(256);
+                            if(inputSizes != null && inputSizes.length > 0) {
+                                JSONArray sizes = new JSONArray();
+                                for (Size size : inputSizes) {
+                                    JSONObject sizeObject = new JSONObject();
+                                    sizeObject.put("WIDTH", size.getWidth());
+                                    sizeObject.put("HEIGHT", size.getHeight());
+                                    sizes.put(sizeObject);
+                                }
+                                physicalCamera.put("INPUT_SIZES", sizes);
+                            }
+
+                            // get the list of available capabilities
+                            int[] capabilities = physicalCharacteristics.get(CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES);
+                            if(capabilities != null && capabilities.length > 0) {
+                                JSONArray capabilitiesJson = new JSONArray();
+                                for (int capability : capabilities) {
+                                    String capabilityName;
+                                    switch(capability){
+                                        case CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES_BACKWARD_COMPATIBLE:
+                                            capabilityName = "REQUEST_AVAILABLE_CAPABILITIES_BACKWARD_COMPATIBLE";
+                                            break;
+                                        case CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES_MANUAL_POST_PROCESSING:
+                                            capabilityName = "REQUEST_AVAILABLE_CAPABILITIES_MANUAL_POST_PROCESSING";
+                                            break;
+                                        case CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES_MANUAL_SENSOR:
+                                            capabilityName = "REQUEST_AVAILABLE_CAPABILITIES_MANUAL_SENSOR";
+                                            break;
+                                        case CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES_RAW:
+                                            capabilityName = "REQUEST_AVAILABLE_CAPABILITIES_RAW";
+                                            break;
+                                        case CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES_READ_SENSOR_SETTINGS:
+                                            capabilityName = "REQUEST_AVAILABLE_CAPABILITIES_READ_SENSOR_SETTINGS";
+                                            break;
+                                        case CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES_BURST_CAPTURE:
+                                            capabilityName = "REQUEST_AVAILABLE_CAPABILITIES_BURST_CAPTURE";
+                                            break;
+                                        case CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES_PRIVATE_REPROCESSING:
+                                            capabilityName = "REQUEST_AVAILABLE_CAPABILITIES_PRIVATE_REPROCESSING";
+                                            break;
+                                        case CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES_YUV_REPROCESSING:
+                                            capabilityName = "REQUEST_AVAILABLE_CAPABILITIES_YUV_REPROCESSING";
+                                            break;
+                                        case CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES_DEPTH_OUTPUT:
+                                            capabilityName = "REQUEST_AVAILABLE_CAPABILITIES_DEPTH_OUTPUT";
+                                            break;
+                                        case CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES_CONSTRAINED_HIGH_SPEED_VIDEO:
+                                            capabilityName = "REQUEST_AVAILABLE_CAPABILITIES_CONSTRAINED_HIGH_SPEED_VIDEO";
+                                            break;
+                                        case CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES_MOTION_TRACKING:
+                                            capabilityName = "REQUEST_AVAILABLE_CAPABILITIES_MOTION_TRACKING";
+                                            break;
+                                        case CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES_LOGICAL_MULTI_CAMERA:
+                                            capabilityName = "REQUEST_AVAILABLE_CAPABILITIES_LOGICAL_MULTI_CAMERA";
+                                            break;
+                                        case CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES_MONOCHROME:
+                                            capabilityName = "REQUEST_AVAILABLE_CAPABILITIES_MONOCHROME";
+                                            break;
+                                        case CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES_SECURE_IMAGE_DATA:
+                                            capabilityName = "REQUEST_AVAILABLE_CAPABILITIES_SECURE_IMAGE_DATA";
+                                            break;
+                                        default:
+                                            capabilityName = String.valueOf(capability);
+                                    }
+
+                                    capabilitiesJson.put(capabilityName);
+                                }
+                                physicalCamera.put("REQUEST_AVAILABLE_CAPABILITIES", capabilitiesJson);
+                            }
+
+                            int[] controlModes = physicalCharacteristics.get(CameraCharacteristics.CONTROL_AVAILABLE_MODES);
+                            if(controlModes != null && controlModes.length > 0) {
+                                JSONArray controlModesArray = new JSONArray();
+                                for (int mode : controlModes) {
+                                    controlModesArray.put(mode);
+                                }
+                                physicalCamera.put("CONTROL_AVAILABLE_MODES", controlModesArray);
+                            }
+
+                            int[] effects = physicalCharacteristics.get(CameraCharacteristics.CONTROL_AVAILABLE_EFFECTS);
+                            if(effects != null && effects.length > 0) {
+                                JSONArray effectsArray = new JSONArray();
+                                for (int effect : effects) {
+                                    effectsArray.put(effect);
+                                }
+                                physicalCamera.put("CONTROL_AVAILABLE_EFFECTS", effectsArray);
+                            }
 
-        bridge.saveCall(call);
-        Float opacity = call.getFloat("opacity", 1F);
-        fragment.setOpacity(opacity);
+                            int[] sceneModes = physicalCharacteristics.get(CameraCharacteristics.CONTROL_AVAILABLE_SCENE_MODES);
+                            if(sceneModes != null && sceneModes.length > 0) {
+                                JSONArray sceneModesArray = new JSONArray();
+                                for (int mode : sceneModes) {
+                                    sceneModesArray.put(mode);
+                                }
+                                physicalCamera.put("CONTROL_AVAILABLE_SCENE_MODES", sceneModesArray);
+                            }
+
+                            int[] antiBandingModes = physicalCharacteristics.get(CameraCharacteristics.CONTROL_AE_AVAILABLE_ANTIBANDING_MODES);
+                            if(antiBandingModes != null && antiBandingModes.length > 0) {
+                                JSONArray antiBandingModesArray = new JSONArray();
+                                for (int mode : antiBandingModes) {
+                                    antiBandingModesArray.put(mode);
+                                }
+                                physicalCamera.put("CONTROL_AE_AVAILABLE_ANTIBANDING_MODES", antiBandingModesArray);
+                            }
+
+                            int[] autoExposureModes = physicalCharacteristics.get(CameraCharacteristics.CONTROL_AE_AVAILABLE_MODES);
+                            if(autoExposureModes != null && autoExposureModes.length > 0) {
+                                JSONArray autoExposureModesArray = new JSONArray();
+                                for (int mode : autoExposureModes) {
+                                    autoExposureModesArray.put(mode);
+                                }
+                                physicalCamera.put("CONTROL_AE_AVAILABLE_MODES", autoExposureModesArray);
+                            }
+
+                            int[] autoFocusModes = physicalCharacteristics.get(CameraCharacteristics.CONTROL_AF_AVAILABLE_MODES);
+                            if(autoFocusModes != null && autoFocusModes.length > 0) {
+                                JSONArray autoFocusModesArray = new JSONArray();
+                                for (int mode : autoFocusModes) {
+                                    autoFocusModesArray.put(mode);
+                                }
+                                physicalCamera.put("CONTROL_AF_AVAILABLE_MODES", autoFocusModesArray);
+                            }
+
+                            int[] autoWhiteBalanceModes = physicalCharacteristics.get(CameraCharacteristics.CONTROL_AWB_AVAILABLE_MODES);
+                            if(autoWhiteBalanceModes != null && autoWhiteBalanceModes.length > 0) {
+                                JSONArray autoWhiteBalanceModesArray = new JSONArray();
+                                for (int mode : autoWhiteBalanceModes) {
+                                    autoWhiteBalanceModesArray.put(mode);
+                                }
+                                physicalCamera.put("CONTROL_AWB_AVAILABLE_MODES", autoWhiteBalanceModesArray);
+                            }
+
+                            int[] colorCorrectionAberrationModes = physicalCharacteristics.get(CameraCharacteristics.COLOR_CORRECTION_AVAILABLE_ABERRATION_MODES);
+                            if(colorCorrectionAberrationModes != null && colorCorrectionAberrationModes.length > 0) {
+                                JSONArray colorCorrectionAberrationModesArray = new JSONArray();
+                                for (int mode : colorCorrectionAberrationModes) {
+                                    colorCorrectionAberrationModesArray.put(mode);
+                                }
+                                physicalCamera.put("COLOR_CORRECTION_AVAILABLE_ABERRATION_MODES", colorCorrectionAberrationModesArray);
+                            }
+
+                            int[] edgeModes = physicalCharacteristics.get(CameraCharacteristics.EDGE_AVAILABLE_EDGE_MODES);
+                            if(edgeModes != null && edgeModes.length > 0) {
+                                JSONArray edgeModesArray = new JSONArray();
+                                for (int mode : edgeModes) {
+                                    edgeModesArray.put(mode);
+                                }
+                                physicalCamera.put("EDGE_AVAILABLE_EDGE_MODES", edgeModesArray);
+                            }
+
+                            int[] hotPixelModes = physicalCharacteristics.get(CameraCharacteristics.HOT_PIXEL_AVAILABLE_HOT_PIXEL_MODES);
+                            if(hotPixelModes != null && hotPixelModes.length > 0) {
+                                JSONArray hotPixelModesArray = new JSONArray();
+                                for (int mode : hotPixelModes) {
+                                    hotPixelModesArray.put(mode);
+                                }
+                                physicalCamera.put("HOT_PIXEL_AVAILABLE_HOT_PIXEL_MODES", hotPixelModesArray);
+                            }
+
+                            int[] lensShadingModes = physicalCharacteristics.get(CameraCharacteristics.LENS_INFO_AVAILABLE_OPTICAL_STABILIZATION);
+                            if(lensShadingModes != null && lensShadingModes.length > 0) {
+                                JSONArray lensShadingModesArray = new JSONArray();
+                                for (int mode : lensShadingModes) {
+                                    lensShadingModesArray.put(mode);
+                                }
+                                physicalCamera.put("LENS_INFO_AVAILABLE_OPTICAL_STABILIZATION", lensShadingModesArray);
+                            }
+
+                            int[] noiseReductionModes = physicalCharacteristics.get(CameraCharacteristics.NOISE_REDUCTION_AVAILABLE_NOISE_REDUCTION_MODES);
+                            if(noiseReductionModes != null && noiseReductionModes.length > 0) {
+                                JSONArray noiseReductionModesArray = new JSONArray();
+                                for (int mode : noiseReductionModes) {
+                                    noiseReductionModesArray.put(mode);
+                                }
+                                physicalCamera.put("NOISE_REDUCTION_AVAILABLE_NOISE_REDUCTION_MODES", noiseReductionModesArray);
+                            }
+
+                            int[] tonemapModes = physicalCharacteristics.get(CameraCharacteristics.TONEMAP_AVAILABLE_TONE_MAP_MODES);
+                            if(tonemapModes != null && tonemapModes.length > 0) {
+                                JSONArray tonemapModesArray = new JSONArray();
+                                for (int mode : tonemapModes) {
+                                    tonemapModesArray.put(mode);
+                                }
+                                physicalCamera.put("TONEMAP_AVAILABLE_TONE_MAP_MODES", tonemapModesArray);
+                            }
+                            physicalCameras.put(physicalCamera);
+                        }
+                        if(physicalCameras.length() > 0){
+                            logicalCamera.put("PHYSICAL_CAMERAS", physicalCameras);
+                        }
+                        logicalCameras.put(logicalCamera);
+                    }
+                    JSObject result = new JSObject();
+                    result.put("LOGICAL_CAMERAS", logicalCameras);
+                    call.resolve(result);
+                } catch (Exception e) {
+                    call.reject("Exception retrieving camera characteristics: " + e);
+                }
+            }else{
+                call.reject("This feature is only available on Android P or later.");
+            }
+        } catch (Exception e) {
+            Logger.debug(getLogTag(), "Exception retrieving camera characteristics: " + e);
+            call.reject("failed to retrieve camera characteristics");
+        }
     }
 
     @PluginMethod
-    public void capture(PluginCall call) {
-        if (this.hasCamera(call) == false) {
-            call.reject("Camera is not running");
-            return;
-        }
-        bridge.saveCall(call);
-        captureCallbackId = call.getCallbackId();
+    public void setOpacity(PluginCall call) {
+        try{
+            if (this.hasCamera(call) == false) {
+                call.reject("Camera is not running");
+                return;
+            }
 
-        Integer quality = call.getInt("quality", 85);
-        // Image Dimensions - Optional
-        Integer width = call.getInt("width", 0);
-        Integer height = call.getInt("height", 0);
-        fragment.takePicture(width, height, quality);
+            bridge.saveCall(call);
+            Float opacity = call.getFloat("opacity", 1F);
+            fragment.setOpacity(opacity);
+        }catch (Exception e) {
+            Logger.debug(getLogTag(), "Set camera opacity exception: " + e);
+            call.reject("failed to set camera opacity");
+        }
     }
 
     @PluginMethod
-    public void captureSample(PluginCall call) {
-        if (this.hasCamera(call) == false) {
-            call.reject("Camera is not running");
-            return;
+    public void setZoom(PluginCall call) {
+        try {
+            if (this.hasCamera(call) == false) {
+                call.reject("Camera is not running");
+                return;
+            }
+            
+            float zoom = call.getFloat("zoom", 1F);
+            if(fragment.isZoomSupported()) {
+                fragment.setCurrentZoomLevel(zoom);
+                call.resolve();
+            } else {
+                call.reject("Zoom not supported");
+            }
+        } catch (Exception e) {
+            Logger.debug(getLogTag(), "Set camera zoom exception: " + e);
+            call.reject("failed to zoom camera");
         }
-        bridge.saveCall(call);
-        snapshotCallbackId = call.getCallbackId();
+    }
+
+    @PluginMethod
+    public void getZoom(PluginCall call) {
+        try {
+            if (this.hasCamera(call) == false) {
+                call.reject("Camera is not running");
+                return;
+            }
 
-        Integer quality = call.getInt("quality", 85);
-        fragment.takeSnapshot(quality);
+            if(fragment.isZoomSupported()) {
+                float currentZoom = fragment.getCurrentZoomLevel();
+                JSObject jsObject = new JSObject();
+                jsObject.put("value", currentZoom);
+                call.resolve(jsObject);
+            } else {
+                call.reject("Zoom not supported");
+            }
+        } catch (Exception e) {
+            Logger.debug(getLogTag(), "Get camera zoom exception: " + e);
+            call.reject("failed to get camera zoom");
+        }
     }
 
     @PluginMethod
-    public void stop(final PluginCall call) {
-        bridge
-            .getActivity()
-            .runOnUiThread(
-                new Runnable() {
-                    @Override
-                    public void run() {
-                        FrameLayout containerView = getBridge().getActivity().findViewById(containerViewId);
-
-                        // allow orientation changes after closing camera:
-                        getBridge().getActivity().setRequestedOrientation(previousOrientationRequest);
-
-                        if (containerView != null) {
-                            ((ViewGroup) getBridge().getWebView().getParent()).removeView(containerView);
-                            getBridge().getWebView().setBackgroundColor(Color.WHITE);
-                            FragmentManager fragmentManager = getActivity().getFragmentManager();
-                            FragmentTransaction fragmentTransaction = fragmentManager.beginTransaction();
-                            fragmentTransaction.remove(fragment);
-                            fragmentTransaction.commit();
-                            fragment = null;
-
-                            call.resolve();
-                        } else {
-                            call.reject("camera already stopped");
-                        }
-                    }
-                }
-            );
+    public void getMaxZoom(PluginCall call) {
+        try {
+            if (this.hasCamera(call) == false) {
+                call.reject("Camera is not running");
+                return;
+            }
+
+            if(fragment.isZoomSupported()) {
+                float maxZoom = fragment.getMaxZoomLevel();
+                JSObject jsObject = new JSObject();
+                jsObject.put("value", maxZoom);
+                call.resolve(jsObject);
+            } else {
+                call.reject("Zoom not supported");
+            }
+        } catch (Exception e) {
+            Logger.debug(getLogTag(), "Get max camera zoom exception: " + e);
+            call.reject("failed to get max camera zoom");
+        }
     }
 
     @PluginMethod
-    public void getSupportedFlashModes(PluginCall call) {
-        if (this.hasCamera(call) == false) {
-            call.reject("Camera is not running");
-            return;
+    public void getMaxZoomLimit(PluginCall call) {
+        try {
+            float maxZoomLimit = fragment.maxZoomLimit;
+            String value = maxZoomLimit == fragment.NO_MAX_ZOOM_LIMIT ? null : String.valueOf(maxZoomLimit);
+            JSObject jsObject = new JSObject();
+            jsObject.put("value", value);
+            call.resolve(jsObject);
+        } catch (Exception e) {
+            Logger.debug(getLogTag(), "Get max  zoom limit exception: " + e);
+            call.reject("failed to get max zoom limit");
         }
+    }
 
-        Camera camera = fragment.getCamera();
-        Camera.Parameters params = camera.getParameters();
-        List<String> supportedFlashModes;
-        supportedFlashModes = params.getSupportedFlashModes();
-        JSONArray jsonFlashModes = new JSONArray();
+    @PluginMethod
+    public void setMaxZoomLimit(PluginCall call) {
+        try {
+            float maxZoomLimit = call.getFloat("maxZoomLimit", fragment.NO_MAX_ZOOM_LIMIT);
+            fragment.maxZoomLimit = maxZoomLimit;
+            call.resolve();
+        } catch (Exception e) {
+            Logger.debug(getLogTag(), "Set max zoom limit exception: " + e);
+            call.reject("failed to set max zoom limit");
+        }
+    }
 
-        if (supportedFlashModes != null) {
-            for (int i = 0; i < supportedFlashModes.size(); i++) {
-                jsonFlashModes.put(new String(supportedFlashModes.get(i)));
+    @PluginMethod
+    public void capture(PluginCall call) {
+        try{
+            if (this.hasCamera(call) == false) {
+                call.reject("Camera is not running");
+                return;
             }
+            bridge.saveCall(call);
+            captureCallbackId = call.getCallbackId();
+
+            Integer quality = call.getInt("quality", 85);
+            // Image Dimensions - Optional
+            Integer width = call.getInt("width", 0);
+            Integer height = call.getInt("height", 0);
+            fragment.takePicture(width, height, quality);
+        } catch (Exception e) {
+            Logger.debug(getLogTag(), "Capture exception: " + e);
+            call.reject("failed to capture image");
         }
-
-        JSObject jsObject = new JSObject();
-        jsObject.put("result", jsonFlashModes);
-        call.resolve(jsObject);
     }
 
     @PluginMethod
-    public void setFlashMode(PluginCall call) {
-        if (this.hasCamera(call) == false) {
-            call.reject("Camera is not running");
-            return;
+    public void captureSample(PluginCall call) {
+        try{
+            if (this.hasCamera(call) == false) {
+                call.reject("Camera is not running");
+                return;
+            }
+            bridge.saveCall(call);
+            snapshotCallbackId = call.getCallbackId();
+
+            Integer quality = call.getInt("quality", 85);
+            fragment.takeSnapshot(quality);
+        } catch (Exception e) {
+            Logger.debug(getLogTag(), "Capture sample exception: " + e);
+            call.reject("failed to capture sample");
         }
+    }
 
-        String flashMode = call.getString("flashMode");
-        if (flashMode == null || flashMode.isEmpty() == true) {
-            call.reject("flashMode required parameter is missing");
-            return;
+    @PluginMethod
+    public void stop(final PluginCall call) {
+        try{
+            bridge
+                    .getActivity()
+                    .runOnUiThread(
+                            new Runnable() {
+                                @SuppressLint("WrongConstant")
+                                @Override
+                                public void run() {
+                                    try{
+                                        FrameLayout containerView = getBridge().getActivity().findViewById(containerViewId);
+
+                                        // allow orientation changes after closing camera:
+                                        if(previousOrientationRequest != -1 && !fragment.lockOrientation){
+                                            getBridge().getActivity().setRequestedOrientation(previousOrientationRequest);
+                                        }
+
+
+                                        if (containerView != null) {
+                                            ((ViewGroup) getBridge().getWebView().getParent()).removeView(containerView);
+                                            getBridge().getWebView().setBackgroundColor(Color.WHITE);
+                                            FragmentManager fragmentManager = getActivity().getFragmentManager();
+                                            FragmentTransaction fragmentTransaction = fragmentManager.beginTransaction();
+                                            fragmentTransaction.remove(fragment);
+                                            fragmentTransaction.commit();
+                                            fragment = null;
+
+                                            call.resolve();
+                                        } else {
+                                            call.reject("camera already stopped");
+                                        }
+                                    }catch (Exception e) {
+                                        Logger.debug(getLogTag(), "Stop camera exception: " + e);
+                                        call.reject("failed to stop camera");
+                                    }
+                                }
+                            }
+                    );
+        }catch (Exception e) {
+            Logger.debug(getLogTag(), "Stop camera exception: " + e);
+            call.reject("failed to stop camera");
         }
+    }
 
-        Camera camera = fragment.getCamera();
-        Camera.Parameters params = camera.getParameters();
+    @PluginMethod
+    public void getSupportedFlashModes(PluginCall call) {
+        try{
+            if (this.hasCamera(call) == false) {
+                call.reject("Camera is not running");
+                return;
+            }
 
-        List<String> supportedFlashModes;
-        supportedFlashModes = camera.getParameters().getSupportedFlashModes();
-        if (supportedFlashModes.indexOf(flashMode) > -1) {
-            params.setFlashMode(flashMode);
-        } else {
-            call.reject("Flash mode not recognised: " + flashMode);
-            return;
-        }
+            String[] supportedFlashModes = fragment.getSupportedFlashModes();
+            JSONArray jsonFlashModes = new JSONArray();
 
-        fragment.setCameraParameters(params);
+            if (supportedFlashModes != null) {
+                for (String supportedFlashMode : supportedFlashModes) {
+                    jsonFlashModes.put(supportedFlashMode);
+                }
+            }
 
-        call.resolve();
+            JSObject jsObject = new JSObject();
+            jsObject.put("result", jsonFlashModes);
+            call.resolve(jsObject);
+        }catch (Exception e) {
+            Logger.debug(getLogTag(), "Get supported flash modes exception: " + e);
+            call.reject("failed to get supported flash modes");
+        }
     }
 
     @PluginMethod
-    public void startRecordVideo(final PluginCall call) {
-        if (this.hasCamera(call) == false) {
-            call.reject("Camera is not running");
-            return;
-        }
-        final String filename = "videoTmp";
-        VIDEO_FILE_PATH = getActivity().getCacheDir().toString() + "/";
-
-        final String position = call.getString("position", "front");
-        final Integer width = call.getInt("width", 0);
-        final Integer height = call.getInt("height", 0);
-        final Boolean withFlash = call.getBoolean("withFlash", false);
-        final Integer maxDuration = call.getInt("maxDuration", 0);
-        // final Integer quality = call.getInt("quality", 0);
-        bridge.saveCall(call);
-        recordCallbackId = call.getCallbackId();
-
-        bridge
-            .getActivity()
-            .runOnUiThread(
-                new Runnable() {
-                    @Override
-                    public void run() {
-                        // fragment.startRecord(getFilePath(filename), position, width, height, quality, withFlash);
-                        fragment.startRecord(getFilePath(filename), position, width, height, 70, withFlash, maxDuration);
+    public void setFlashMode(PluginCall call) {
+        try{
+            if (this.hasCamera(call) == false) {
+                call.reject("Camera is not running");
+                return;
+            }
+
+            String flashMode = call.getString("flashMode");
+            if (flashMode == null || flashMode.isEmpty() == true) {
+                call.reject("flashMode required parameter is missing");
+                return;
+            }
+
+            String[] supportedFlashModes = fragment.getSupportedFlashModes();
+
+            if (supportedFlashModes != null && supportedFlashModes.length > 0) {
+                boolean isSupported = false;
+                for (String supportedFlashMode : supportedFlashModes) {
+                    if (supportedFlashMode.equals(flashMode)) {
+                        isSupported = true;
+                        break;
                     }
                 }
-            );
+                if (!isSupported) {
+                    call.reject("Flash mode not supported: " + flashMode);
+                    return;
+                }
+            }
+            fragment.setFlashMode(flashMode);
+            call.resolve();
+        }catch (Exception e) {
+            Logger.debug(getLogTag(), "Set flash mode exception: " + e);
+            call.reject("failed to set flash mode");
+        }
+    }
 
-        call.resolve();
+    @PluginMethod
+    public void startRecordVideo(final PluginCall call) {
+        try{
+            if (this.hasCamera(call) == false) {
+                call.reject("Camera is not running");
+                return;
+            }
+            final String filename = "videoTmp";
+            VIDEO_FILE_PATH = getActivity().getCacheDir().toString() + "/";
+
+            final String position = call.getString("position", "front");
+            final Integer width = call.getInt("width", 0);
+            final Integer height = call.getInt("height", 0);
+            final Boolean withFlash = call.getBoolean("withFlash", false);
+            final Integer maxDuration = call.getInt("maxDuration", 0);
+            // final Integer quality = call.getInt("quality", 0);
+            bridge.saveCall(call);
+            call.setKeepAlive(true);
+            recordCallbackId = call.getCallbackId();
+
+            bridge
+                    .getActivity()
+                    .runOnUiThread(
+                            new Runnable() {
+                                @Override
+                                public void run() {
+                                    // fragment.startRecord(getFilePath(filename), position, width, height, quality, withFlash);
+                                    try{
+                                        fragment.startRecord(getFilePath(filename), position, width, height, 70, withFlash, maxDuration);
+                                        call.resolve();
+                                    } catch (Exception e) {
+                                        Logger.debug(getLogTag(), "Start record video exception: " + e);
+                                        call.reject("failed to start record video");
+                                    }
+                                }
+                            }
+                    );
+        }catch (Exception e) {
+            Logger.debug(getLogTag(), "Start record video exception: " + e);
+            call.reject("failed to start record video");
+            }
     }
 
     @PluginMethod
     public void stopRecordVideo(PluginCall call) {
-        if (this.hasCamera(call) == false) {
-            call.reject("Camera is not running");
-            return;
-        }
-
-        System.out.println("stopRecordVideo - Callbackid=" + call.getCallbackId());
-
-        bridge.saveCall(call);
-        recordCallbackId = call.getCallbackId();
+        try{
+            if (this.hasCamera(call) == false) {
+                call.reject("Camera is not running");
+                return;
+            }
 
-        // bridge.getActivity().runOnUiThread(new Runnable() {
-        //     @Override
-        //     public void run() {
-        //         fragment.stopRecord();
-        //     }
-        // });
+            System.out.println("stopRecordVideo - Callbackid=" + call.getCallbackId());
 
-        fragment.stopRecord();
-        // call.resolve();
+            bridge.saveCall(call);
+            recordCallbackId = call.getCallbackId();
+            fragment.stopRecord();
+            call.resolve();
+        }catch (Exception e) {
+            Logger.debug(getLogTag(), "Stop record video exception: " + e);
+            call.reject("failed to stop record video");
+        }
     }
 
     @PermissionCallback
     private void handleCameraPermissionResult(PluginCall call) {
-        if (PermissionState.GRANTED.equals(getPermissionState(CAMERA_PERMISSION_ALIAS))) {
-            startCamera(call);
-        } else {
-            Logger.debug(getLogTag(), "User denied camera permission: " + getPermissionState(CAMERA_PERMISSION_ALIAS).toString());
-            call.reject("Permission failed: user denied access to camera.");
+        try{
+            if (PermissionState.GRANTED.equals(getPermissionState(CAMERA_PERMISSION_ALIAS))) {
+                startCamera(call);
+            } else {
+                Logger.debug(getLogTag(), "User denied camera permission: " + getPermissionState(CAMERA_PERMISSION_ALIAS).toString());
+                call.reject("Permission failed: user denied access to camera.");
+            }
+        }catch (Exception e) {
+            Logger.debug(getLogTag(), "Handle camera permission result exception: " + e);
+            call.reject("failed to handle camera permission result");
         }
     }
 
     private void startCamera(final PluginCall call) {
-        String position = call.getString("position");
-
-        if (position == null || position.isEmpty() || "rear".equals(position)) {
-            position = "back";
-        } else {
-            position = "front";
-        }
-
-        final Integer x = call.getInt("x", 0);
-        final Integer y = call.getInt("y", 0);
-        final Integer width = call.getInt("width", 0);
-        final Integer height = call.getInt("height", 0);
-        final Integer paddingBottom = call.getInt("paddingBottom", 0);
-        final Boolean toBack = call.getBoolean("toBack", false);
-        final Boolean storeToFile = call.getBoolean("storeToFile", false);
-        final Boolean enableOpacity = call.getBoolean("enableOpacity", false);
-        final Boolean enableZoom = call.getBoolean("enableZoom", false);
-        final Boolean disableExifHeaderStripping = call.getBoolean("disableExifHeaderStripping", true);
-        final Boolean lockOrientation = call.getBoolean("lockAndroidOrientation", false);
-        previousOrientationRequest = getBridge().getActivity().getRequestedOrientation();
-
-        fragment = new CameraActivity();
-        fragment.setEventListener(this);
-        fragment.defaultCamera = position;
-        fragment.tapToTakePicture = false;
-        fragment.dragEnabled = false;
-        fragment.tapToFocus = true;
-        fragment.disableExifHeaderStripping = disableExifHeaderStripping;
-        fragment.storeToFile = storeToFile;
-        fragment.toBack = toBack;
-        fragment.enableOpacity = enableOpacity;
-        fragment.enableZoom = enableZoom;
-
-        bridge
-            .getActivity()
-            .runOnUiThread(
-                new Runnable() {
-                    @Override
-                    public void run() {
-                        DisplayMetrics metrics = getBridge().getActivity().getResources().getDisplayMetrics();
-                        // lock orientation if specified in options:
-                        if (lockOrientation) {
-                            getBridge().getActivity().setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LOCKED);
-                        }
-
-                        // offset
-                        int computedX = (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, x, metrics);
-                        int computedY = (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, y, metrics);
-
-                        // size
-                        int computedWidth;
-                        int computedHeight;
-                        int computedPaddingBottom;
-
-                        if (paddingBottom != 0) {
-                            computedPaddingBottom = (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, paddingBottom, metrics);
-                        } else {
-                            computedPaddingBottom = 0;
-                        }
-
-                        if (width != 0) {
-                            computedWidth = (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, width, metrics);
-                        } else {
-                            Display defaultDisplay = getBridge().getActivity().getWindowManager().getDefaultDisplay();
-                            final Point size = new Point();
-                            defaultDisplay.getSize(size);
-
-                            computedWidth = (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_PX, size.x, metrics);
-                        }
-
-                        if (height != 0) {
-                            computedHeight =
-                                (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, height, metrics) - computedPaddingBottom;
-                        } else {
-                            Display defaultDisplay = getBridge().getActivity().getWindowManager().getDefaultDisplay();
-                            final Point size = new Point();
-                            defaultDisplay.getSize(size);
+        try{
+            String position = call.getString("position");
 
-                            computedHeight =
-                                (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_PX, size.y, metrics) - computedPaddingBottom;
-                        }
+            if (position == null || position.isEmpty() || "rear".equals(position)) {
+                position = "back";
+            } else {
+                position = "front";
+            }
 
-                        fragment.setRect(computedX, computedY, computedWidth, computedHeight);
+            final Integer x = call.getInt("x", 0);
+            final Integer y = call.getInt("y", 0);
+            final Integer width = call.getInt("width", 0);
+            final Integer height = call.getInt("height", 0);
+            final Integer paddingBottom = call.getInt("paddingBottom", 0);
+            final Boolean toBack = call.getBoolean("toBack", false);
+            final Boolean storeToFile = call.getBoolean("storeToFile", false);
+            final Boolean enableOpacity = call.getBoolean("enableOpacity", false);
+            final Boolean enableZoom = call.getBoolean("enableZoom", false);
+            final Boolean cropToPreview = call.getBoolean("cropToPreview", true);
+            final Boolean disableExifHeaderStripping = call.getBoolean("disableExifHeaderStripping", true);
+            final Boolean lockOrientation = call.getBoolean("lockAndroidOrientation", false);
+            previousOrientationRequest = getBridge().getActivity().getRequestedOrientation();
+
+            fragment = new CameraActivity();
+            fragment.setEventListener(this);
+            fragment.cameraPreview = this;
+            fragment.bridge = getBridge();
+            fragment.activity = getActivity();
+            fragment.context = getContext();
+            fragment.position = position;
+            fragment.tapToTakePicture = false;
+            fragment.dragEnabled = false;
+            fragment.tapToFocus = true;
+            fragment.disableExifHeaderStripping = disableExifHeaderStripping;
+            fragment.storeToFile = storeToFile;
+            fragment.toBack = toBack;
+            fragment.enableOpacity = enableOpacity;
+            fragment.enableZoom = enableZoom;
+            fragment.cropToPreview = cropToPreview;
+            final float maxZoomLimit = call.getFloat("maxZoomLimit", fragment.NO_MAX_ZOOM_LIMIT);
+            fragment.maxZoomLimit = maxZoomLimit;
+            fragment.lockOrientation = lockOrientation;
+
+            // lock orientation if specified in options:
+            if (lockOrientation) {
+                getBridge().getActivity().setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LOCKED);
+            }
 
-                        FrameLayout containerView = getBridge().getActivity().findViewById(containerViewId);
-                        if (containerView == null) {
-                            containerView = new FrameLayout(getActivity().getApplicationContext());
-                            containerView.setId(containerViewId);
 
-                            getBridge().getWebView().setBackgroundColor(Color.TRANSPARENT);
-                            ((ViewGroup) getBridge().getWebView().getParent()).addView(containerView);
-                            if (toBack == true) {
-                                getBridge().getWebView().getParent().bringChildToFront(getBridge().getWebView());
-                                setupBroadcast();
+            bridge
+                    .getActivity()
+                    .runOnUiThread(
+                            new Runnable() {
+                                @Override
+                                public void run() {
+                                    try{
+                                        DisplayMetrics metrics = getBridge().getActivity().getResources().getDisplayMetrics();
+
+
+                                        // offset
+                                        int computedX = (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, x, metrics);
+                                        int computedY = (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, y, metrics);
+
+                                        // size
+                                        int computedWidth;
+                                        int computedHeight;
+                                        int computedPaddingBottom;
+
+                                        if (paddingBottom != 0) {
+                                            computedPaddingBottom = (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, paddingBottom, metrics);
+                                        } else {
+                                            computedPaddingBottom = 0;
+                                        }
+
+                                        if (width != 0) {
+                                            computedWidth = (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, width, metrics);
+                                        } else {
+                                            Display defaultDisplay = getBridge().getActivity().getWindowManager().getDefaultDisplay();
+                                            final Point size = new Point();
+                                            defaultDisplay.getSize(size);
+
+                                            computedWidth = (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_PX, size.x, metrics);
+                                        }
+
+                                        if (height != 0) {
+                                            computedHeight =
+                                                    (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, height, metrics) - computedPaddingBottom;
+                                        } else {
+                                            Display defaultDisplay = getBridge().getActivity().getWindowManager().getDefaultDisplay();
+                                            final Point size = new Point();
+                                            defaultDisplay.getSize(size);
+
+                                            computedHeight =
+                                                    (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_PX, size.y, metrics) - computedPaddingBottom;
+                                        }
+
+                                        fragment.setRect(computedX, computedY, computedWidth, computedHeight);
+
+                                        FrameLayout containerView = getBridge().getActivity().findViewById(containerViewId);
+                                        if (containerView == null) {
+                                            containerView = new FrameLayout(getActivity().getApplicationContext());
+                                            containerView.setId(containerViewId);
+
+                                            getBridge().getWebView().setBackgroundColor(Color.TRANSPARENT);
+                                            ((ViewGroup) getBridge().getWebView().getParent()).addView(containerView);
+                                            if (toBack == true) {
+                                                getBridge().getWebView().getParent().bringChildToFront(getBridge().getWebView());
+                                                setupBroadcast();
+                                            }
+
+                                            FragmentManager fragmentManager = getBridge().getActivity().getFragmentManager();
+                                            FragmentTransaction fragmentTransaction = fragmentManager.beginTransaction();
+                                            fragmentTransaction.add(containerView.getId(), fragment);
+                                            fragmentTransaction.commit();
+
+                                            // NOTE: we don't return invoke call.resolve here because it must be invoked in onCameraStarted
+                                            // otherwise the plugin start method might resolve/return before the camera is actually set in CameraActivity
+                                            // onResume method and the next subsequent plugin
+                                            // method invocations (for example, getSupportedFlashModes) might fails with "Camera is not running" error
+                                            // because camera is not available yet and hasCamera method will return false
+                                            // Please also see https://developer.android.com/reference/android/hardware/Camera.html#open%28int%29
+                                            bridge.saveCall(call);
+                                            cameraStartCallbackId = call.getCallbackId();
+                                        } else {
+                                            call.reject("camera already started");
+                                        }
+                                    }catch (Exception e) {
+                                        Logger.debug(getLogTag(), "Start camera exception: " + e);
+                                        call.reject("failed to start camera");
+                                    }
+                                }
                             }
-
-                            FragmentManager fragmentManager = getBridge().getActivity().getFragmentManager();
-                            FragmentTransaction fragmentTransaction = fragmentManager.beginTransaction();
-                            fragmentTransaction.add(containerView.getId(), fragment);
-                            fragmentTransaction.commit();
-
-                            // NOTE: we don't return invoke call.resolve here because it must be invoked in onCameraStarted
-                            // otherwise the plugin start method might resolve/return before the camera is actually set in CameraActivity
-                            // onResume method (see this line mCamera = Camera.open(defaultCameraId);) and the next subsequent plugin
-                            // method invocations (for example, getSupportedFlashModes) might fails with "Camera is not running" error
-                            // because camera is not available yet and hasCamera method will return false
-                            // Please also see https://developer.android.com/reference/android/hardware/Camera.html#open%28int%29
-                            bridge.saveCall(call);
-                            cameraStartCallbackId = call.getCallbackId();
-                        } else {
-                            call.reject("camera already started");
-                        }
-                    }
-                }
-            );
+                    );
+        }catch (Exception e) {
+            Logger.debug(getLogTag(), "Start camera exception: " + e);
+            call.reject("failed to start camera");
+        }
     }
 
     @Override
@@ -382,28 +866,85 @@ protected void handleOnResume() {
         super.handleOnResume();
     }
 
+    @Override
+    protected void handleOnConfigurationChanged(Configuration newConfig) {
+        super.handleOnConfigurationChanged(newConfig);
+        try{
+            if(fragment == null || fragment.lockOrientation) {
+                return;
+            }
+            if (newConfig.orientation == Configuration.ORIENTATION_LANDSCAPE) {
+                fragment.onOrientationChange("landscape");
+            } else if (newConfig.orientation == Configuration.ORIENTATION_PORTRAIT) {
+                fragment.onOrientationChange("portrait");
+            }else{
+                fragment.onOrientationChange("unknown");
+            }
+        }catch (Exception e) {
+            Logger.debug(getLogTag(), "Handle on configuration changed exception: " + e);
+        }
+    }
+
+
     @Override
     public void onPictureTaken(String originalPicture) {
-        JSObject jsObject = new JSObject();
-        jsObject.put("value", originalPicture);
-        bridge.getSavedCall(captureCallbackId).resolve(jsObject);
+        try{
+            JSObject jsObject = new JSObject();
+            jsObject.put("value", originalPicture);
+            bridge.getSavedCall(captureCallbackId).resolve(jsObject);
+        }catch (Exception e) {
+            Logger.debug(getLogTag(), "On picture taken exception: " + e);
+            if(!captureCallbackId.isEmpty() && bridge.getSavedCall(captureCallbackId) != null){
+                bridge.getSavedCall(captureCallbackId).reject("failed to capture image");
+            }else{
+                Logger.debug(getLogTag(), "Capture callback id is empty");
+            }
+        }
+
     }
 
     @Override
     public void onPictureTakenError(String message) {
-        bridge.getSavedCall(captureCallbackId).reject(message);
+        try{
+            bridge.getSavedCall(captureCallbackId).reject(message);
+        }catch (Exception e) {
+            Logger.debug(getLogTag(), "On picture taken error exception: " + e);
+            if (!captureCallbackId.isEmpty() && bridge.getSavedCall(captureCallbackId) != null) {
+                bridge.getSavedCall(captureCallbackId).reject("failed to capture image");
+            } else {
+                Logger.debug(getLogTag(), "Capture callback id is empty");
+            }
+        }
     }
 
     @Override
     public void onSnapshotTaken(String originalPicture) {
-        JSObject jsObject = new JSObject();
-        jsObject.put("value", originalPicture);
-        bridge.getSavedCall(snapshotCallbackId).resolve(jsObject);
+        try{
+            JSObject jsObject = new JSObject();
+            jsObject.put("value", originalPicture);
+            bridge.getSavedCall(snapshotCallbackId).resolve(jsObject);
+        }catch (Exception e) {
+            Logger.debug(getLogTag(), "On snapshot taken exception: " + e);
+            if (!snapshotCallbackId.isEmpty() && bridge.getSavedCall(snapshotCallbackId) != null) {
+                bridge.getSavedCall(snapshotCallbackId).reject("failed to capture sample");
+            } else {
+                Logger.debug(getLogTag(), "Snapshot callback id is empty");
+            }
+        }
     }
 
     @Override
     public void onSnapshotTakenError(String message) {
-        bridge.getSavedCall(snapshotCallbackId).reject(message);
+        try{
+            bridge.getSavedCall(snapshotCallbackId).reject(message);
+        }catch (Exception e) {
+            Logger.debug(getLogTag(), "On snapshot taken error exception: " + e);
+            if (!snapshotCallbackId.isEmpty() && bridge.getSavedCall(snapshotCallbackId) != null) {
+                bridge.getSavedCall(snapshotCallbackId).reject("failed to capture sample");
+            } else {
+                Logger.debug(getLogTag(), "Snapshot callback id is empty");
+            }
+        }
     }
 
     @Override
@@ -417,9 +958,22 @@ public void onBackButton() {}
 
     @Override
     public void onCameraStarted() {
-        PluginCall pluginCall = bridge.getSavedCall(cameraStartCallbackId);
-        pluginCall.resolve();
-        bridge.releaseCall(pluginCall);
+        try{
+            if(cameraStartCallbackId.isEmpty()) {
+                return;
+            }
+            PluginCall pluginCall = bridge.getSavedCall(cameraStartCallbackId);
+            pluginCall.resolve();
+            bridge.releaseCall(pluginCall);
+            cameraStartCallbackId = "";
+        }catch (Exception e) {
+            Logger.debug(getLogTag(), "On camera started exception: " + e);
+            if(!cameraStartCallbackId.isEmpty() && bridge.getSavedCall(cameraStartCallbackId) != null){
+                bridge.getSavedCall(cameraStartCallbackId).reject("failed to start camera");
+            }else{
+                Logger.debug(getLogTag(), "Camera start callback id is empty");
+            }
+        }
     }
 
     @Override
@@ -427,20 +981,47 @@ public void onStartRecordVideo() {}
 
     @Override
     public void onStartRecordVideoError(String message) {
-        bridge.getSavedCall(recordCallbackId).reject(message);
+        try{
+            bridge.getSavedCall(recordCallbackId).reject(message);
+        }catch (Exception e) {
+            Logger.debug(getLogTag(), "On start record video error exception: " + e);
+            if (!recordCallbackId.isEmpty() && bridge.getSavedCall(recordCallbackId) != null) {
+                bridge.getSavedCall(recordCallbackId).reject("failed to start record video");
+            } else {
+                Logger.debug(getLogTag(), "Record callback id is empty");
+            }
+        }
     }
 
     @Override
     public void onStopRecordVideo(String file) {
-        PluginCall pluginCall = bridge.getSavedCall(recordCallbackId);
-        JSObject jsObject = new JSObject();
-        jsObject.put("videoFilePath", file);
-        pluginCall.resolve(jsObject);
+        try{
+            PluginCall pluginCall = bridge.getSavedCall(recordCallbackId);
+            JSObject jsObject = new JSObject();
+            jsObject.put("videoFilePath", file);
+            pluginCall.resolve(jsObject);
+        }catch (Exception e) {
+            Logger.debug(getLogTag(), "On stop record video exception: " + e);
+            if (!recordCallbackId.isEmpty() && bridge.getSavedCall(recordCallbackId) != null) {
+                bridge.getSavedCall(recordCallbackId).reject("failed to stop record video");
+            } else {
+                Logger.debug(getLogTag(), "Record callback id is empty");
+            }
+        }
     }
 
     @Override
     public void onStopRecordVideoError(String error) {
-        bridge.getSavedCall(recordCallbackId).reject(error);
+        try{
+            bridge.getSavedCall(recordCallbackId).reject(error);
+        }catch (Exception e) {
+            Logger.debug(getLogTag(), "On stop record video error exception: " + e);
+            if (!recordCallbackId.isEmpty() && bridge.getSavedCall(recordCallbackId) != null) {
+                bridge.getSavedCall(recordCallbackId).reject("failed to stop record video");
+            } else {
+                Logger.debug(getLogTag(), "Record callback id is empty");
+            }
+        }
     }
 
     private boolean hasView(PluginCall call) {
@@ -487,8 +1068,12 @@ private void setupBroadcast() {
                 new View.OnTouchListener() {
                     @Override
                     public boolean onTouch(View v, MotionEvent event) {
-                        if ((null != fragment) && (fragment.toBack == true)) {
-                            fragment.frameContainerLayout.dispatchTouchEvent(event);
+                        try{
+                            if ((null != fragment) && (fragment.toBack == true)) {
+                                fragment.frameContainerLayout.dispatchTouchEvent(event);
+                            }
+                        }catch (Exception e) {
+                            Logger.debug(getLogTag(), "Broadcast touch event exception: " + e);
                         }
                         return false;
                     }
diff --git a/android/src/main/java/com/ahm/capacitor/camera/preview/CustomSurfaceView.java b/android/src/main/java/com/ahm/capacitor/camera/preview/CustomSurfaceView.java
deleted file mode 100644
index 051a07fb..00000000
--- a/android/src/main/java/com/ahm/capacitor/camera/preview/CustomSurfaceView.java
+++ /dev/null
@@ -1,23 +0,0 @@
-package com.ahm.capacitor.camera.preview;
-
-import android.content.Context;
-import android.view.SurfaceHolder;
-import android.view.SurfaceView;
-
-class CustomSurfaceView extends SurfaceView implements SurfaceHolder.Callback {
-
-    private final String TAG = "CustomSurfaceView";
-
-    CustomSurfaceView(Context context) {
-        super(context);
-    }
-
-    @Override
-    public void surfaceCreated(SurfaceHolder holder) {}
-
-    @Override
-    public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {}
-
-    @Override
-    public void surfaceDestroyed(SurfaceHolder holder) {}
-}
diff --git a/android/src/main/java/com/ahm/capacitor/camera/preview/CustomTextureView.java b/android/src/main/java/com/ahm/capacitor/camera/preview/CustomTextureView.java
deleted file mode 100644
index 6baac0e5..00000000
--- a/android/src/main/java/com/ahm/capacitor/camera/preview/CustomTextureView.java
+++ /dev/null
@@ -1,29 +0,0 @@
-package com.ahm.capacitor.camera.preview;
-
-import android.content.Context;
-import android.graphics.SurfaceTexture;
-import android.view.SurfaceHolder;
-import android.view.TextureView;
-
-class CustomTextureView extends TextureView implements TextureView.SurfaceTextureListener {
-
-    private final String TAG = "CustomTextureView";
-
-    CustomTextureView(Context context) {
-        super(context);
-    }
-
-    @Override
-    public void onSurfaceTextureAvailable(SurfaceTexture surface, int width, int height) {}
-
-    @Override
-    public void onSurfaceTextureSizeChanged(SurfaceTexture surface, int width, int height) {}
-
-    @Override
-    public boolean onSurfaceTextureDestroyed(SurfaceTexture surface) {
-        return true;
-    }
-
-    @Override
-    public void onSurfaceTextureUpdated(SurfaceTexture surface) {}
-}
diff --git a/android/src/main/java/com/ahm/capacitor/camera/preview/Preview.java b/android/src/main/java/com/ahm/capacitor/camera/preview/Preview.java
deleted file mode 100644
index 6daa426f..00000000
--- a/android/src/main/java/com/ahm/capacitor/camera/preview/Preview.java
+++ /dev/null
@@ -1,386 +0,0 @@
-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.util.Log;
-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 java.util.List;
-
-class Preview extends RelativeLayout implements SurfaceHolder.Callback, TextureView.SurfaceTextureListener {
-
-    private final String TAG = "Preview";
-
-    CustomSurfaceView mSurfaceView;
-    CustomTextureView mTextureView;
-    SurfaceHolder mHolder;
-    SurfaceTexture mSurface;
-    Camera.Size mPreviewSize;
-    List<Camera.Size> mSupportedPreviewSizes;
-    Camera mCamera;
-    int cameraId;
-    int displayOrientation;
-    int facing = Camera.CameraInfo.CAMERA_FACING_BACK;
-    int viewWidth;
-    int viewHeight;
-    private boolean enableOpacity = false;
-    private float opacity = 1F;
-
-    Preview(Context context) {
-        this(context, false);
-    }
-
-    Preview(Context context, boolean enableOpacity) {
-        super(context);
-        this.enableOpacity = enableOpacity;
-        if (!enableOpacity) {
-            mSurfaceView = new CustomSurfaceView(context);
-            addView(mSurfaceView);
-            requestLayout();
-
-            // Install a SurfaceHolder.Callback so we get notified when the
-            // underlying surface is created and destroyed.
-            mHolder = mSurfaceView.getHolder();
-            mHolder.addCallback(this);
-            mHolder.setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);
-        } else {
-            // Use a TextureView so we can manage opacity
-            mTextureView = new CustomTextureView(context);
-            // Install a SurfaceTextureListener so we get notified
-            mTextureView.setSurfaceTextureListener(this);
-            mTextureView.setLayerType(View.LAYER_TYPE_HARDWARE, null);
-            addView(mTextureView);
-            requestLayout();
-        }
-    }
-
-    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 int getDisplayOrientation() {
-        return displayOrientation;
-    }
-
-    public int getCameraFacing() {
-        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;
-        }
-
-        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) {
-        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;
-            }
-
-            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());
-        }
-    }
-
-    @Override
-    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
-        // We purposely disregard child measurements because act as a
-        // wrapper to a SurfaceView that centers the camera preview instead
-        // of stretching it.
-        final int width = resolveSize(getSuggestedMinimumWidth(), widthMeasureSpec);
-        final int height = resolveSize(getSuggestedMinimumHeight(), heightMeasureSpec);
-        setMeasuredDimension(width, height);
-
-        if (mSupportedPreviewSizes != null) {
-            mPreviewSize = getOptimalPreviewSize(mSupportedPreviewSizes, width, height);
-        }
-    }
-
-    @Override
-    protected void onLayout(boolean changed, int l, int t, int r, int b) {
-        if (changed && getChildCount() > 0) {
-            final View child = getChildAt(0);
-
-            int width = r - l;
-            int height = b - t;
-
-            int previewWidth = width;
-            int previewHeight = height;
-
-            if (mPreviewSize != null) {
-                previewWidth = mPreviewSize.width;
-                previewHeight = mPreviewSize.height;
-
-                if (displayOrientation == 90 || displayOrientation == 270) {
-                    previewWidth = mPreviewSize.height;
-                    previewHeight = mPreviewSize.width;
-                }
-                //        LOG.d(TAG, "previewWidth:" + previewWidth + " previewHeight:" + previewHeight);
-            }
-
-            int nW;
-            int nH;
-            int top;
-            int left;
-
-            float scale = 1.0f;
-
-            // Center the child SurfaceView within the parent.
-            if (width * previewHeight < height * previewWidth) {
-                Log.d(TAG, "center horizontally");
-                int scaledChildWidth = (int) ((previewWidth * height / previewHeight) * scale);
-                nW = (width + scaledChildWidth) / 2;
-                nH = (int) (height * scale);
-                top = 0;
-                left = (width - scaledChildWidth) / 2;
-            } else {
-                Log.d(TAG, "center vertically");
-                int scaledChildHeight = (int) ((previewHeight * width / previewWidth) * scale);
-                nW = (int) (width * scale);
-                nH = (height + scaledChildHeight) / 2;
-                top = (height - scaledChildHeight) / 2;
-                left = 0;
-            }
-            child.layout(left, top, nW, nH);
-
-            Log.d("layout", "left:" + left);
-            Log.d("layout", "top:" + top);
-            Log.d("layout", "right:" + nW);
-            Log.d("layout", "bottom:" + nH);
-        }
-    }
-
-    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;
-        }
-
-        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);
-            }
-        }
-
-        // 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);
-                }
-            }
-        }
-
-        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);
-            }
-        }
-    }
-
-    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
-
-    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) {}
-
-    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) {}
-
-    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);
-        }
-    }
-}
diff --git a/demo/package.json b/demo/package.json
index 615a52ea..b648d8ab 100644
--- a/demo/package.json
+++ b/demo/package.json
@@ -3,7 +3,7 @@
   "version": "0.0.1",
   "private": true,
   "dependencies": {
-    "@capacitor-community/camera-preview": "^5.0.0",
+    "@capacitor-community/camera-preview": "file:..",
     "@capacitor/android": "^5.0.0",
     "@capacitor/core": "^5.0.0",
     "@capacitor/ios": "^5.0.0",
diff --git a/demo/src/pages/Home.tsx b/demo/src/pages/Home.tsx
index 2624c545..c04b9cba 100644
--- a/demo/src/pages/Home.tsx
+++ b/demo/src/pages/Home.tsx
@@ -62,6 +62,37 @@ const Home: React.FC = () => {
         >
           Flip
         </IonButton>
+        <IonButton
+          style={{ zIndex: "99999" }}
+          onClick={() => {
+            CameraPreview.getMaxZoom().then((result:any) => {
+              console.log(`Max Zoom: ${result.value}`);
+            });
+          }}
+        >
+          Get Max Zoom
+        </IonButton>
+        <IonButton
+          style={{ zIndex: "99999" }}
+          onClick={() => {
+            CameraPreview.getZoom().then((result:any) => {
+              console.log(`Zoom: ${result.value}`);
+            });
+          }}
+        >
+          Get Zoom
+        </IonButton>
+        <IonButton
+          style={{ zIndex: "99999" }}
+          onClick={() => {
+            CameraPreview.getMaxZoom().then((result:any) => {
+              console.log(`Setting Zoom: ${result.value}`);
+              CameraPreview.setZoom({ zoom: result.value });
+            });
+          }}
+        >
+          Set Zoom
+        </IonButton>
         <IonButton
           style={{ zIndex: "99999" }}
           onClick={async () => {
diff --git a/demo/yarn.lock b/demo/yarn.lock
index c1a84786..64d46a35 100644
--- a/demo/yarn.lock
+++ b/demo/yarn.lock
@@ -1154,10 +1154,8 @@
     lodash "^4.17.19"
     to-fast-properties "^2.0.0"
 
-"@capacitor-community/camera-preview@^5.0.0":
+"@capacitor-community/camera-preview@file:..":
   version "5.0.0"
-  resolved "https://registry.yarnpkg.com/@capacitor-community/camera-preview/-/camera-preview-5.0.0.tgz#11ef4b93198e3f33b003631649c2e81c53541519"
-  integrity sha512-pnoWs8DpKpjoJGVanJ/tRzplp5kZL6iEpKUsRUwyf5BUH77SutZaLo1kF32CaHUaMGawNzvx/rep5Wa5TnxScg==
 
 "@capacitor/android@^5.0.0":
   version "5.0.4"
diff --git a/ios/Plugin/CameraController.swift b/ios/Plugin/CameraController.swift
index a09e72a0..20ed5a35 100644
--- a/ios/Plugin/CameraController.swift
+++ b/ios/Plugin/CameraController.swift
@@ -8,8 +8,10 @@
 
 import AVFoundation
 import UIKit
+import Capacitor
 
 class CameraController: NSObject {
+    var bridge: CAPBridgeProtocol?
     var captureSession: AVCaptureSession?
 
     var currentCameraPosition: CameraPosition?
@@ -36,6 +38,7 @@ class CameraController: NSObject {
     var audioInput: AVCaptureDeviceInput?
 
     var zoomFactor: CGFloat = 1.0
+    var maxZoomLimit: CGFloat = -1.0
 }
 
 extension CameraController {
@@ -395,6 +398,73 @@ extension CameraController {
         }
 
     }
+    
+    func getMaxZoom() throws -> CGFloat {
+        var currentCamera: AVCaptureDevice?
+        switch currentCameraPosition {
+        case .front:
+            currentCamera = self.frontCamera!
+        case .rear:
+            currentCamera = self.rearCamera!
+        default: break
+        }
+
+        guard
+            let device = currentCamera
+        else {
+            throw CameraControllerError.invalidOperation
+        }
+
+        return device.activeFormat.videoMaxZoomFactor
+    }
+    
+    func getZoom() throws -> CGFloat {
+        var currentCamera: AVCaptureDevice?
+        switch currentCameraPosition {
+        case .front:
+            currentCamera = self.frontCamera!
+        case .rear:
+            currentCamera = self.rearCamera!
+        default: break
+        }
+
+        guard
+            let device = currentCamera
+        else {
+            throw CameraControllerError.invalidOperation
+        }
+
+        return device.videoZoomFactor
+    }
+    
+    func setZoom(desiredZoomFactor: CGFloat) throws{
+        var currentCamera: AVCaptureDevice?
+        switch currentCameraPosition {
+        case .front:
+            currentCamera = self.frontCamera!
+        case .rear:
+            currentCamera = self.rearCamera!
+        default: break
+        }
+
+        guard
+            let device = currentCamera
+        else {
+            throw CameraControllerError.invalidOperation
+        }
+
+        do {
+            try device.lockForConfiguration()
+            var videoZoomFactor = max(1.0, min(desiredZoomFactor, device.activeFormat.videoMaxZoomFactor))
+            if(maxZoomLimit > -1){
+                videoZoomFactor = min(videoZoomFactor, maxZoomLimit);
+            }
+            device.videoZoomFactor = videoZoomFactor
+            device.unlockForConfiguration()
+        } catch {
+            throw CameraControllerError.invalidOperation
+        }
+    }
 
     func captureVideo(completion: @escaping (URL?, Error?) -> Void) {
         guard let captureSession = self.captureSession, captureSession.isRunning else {
@@ -458,7 +528,13 @@ extension CameraController: UIGestureRecognizerDelegate {
     private func handlePinch(_ pinch: UIPinchGestureRecognizer) {
         guard let device = self.currentCameraPosition == .rear ? rearCamera : frontCamera else { return }
 
-        func minMaxZoom(_ factor: CGFloat) -> CGFloat { return max(1.0, min(factor, device.activeFormat.videoMaxZoomFactor)) }
+        func minMaxZoom(_ factor: CGFloat) -> CGFloat {
+            var zoom = max(1.0, min(factor, device.activeFormat.videoMaxZoomFactor))
+            if(maxZoomLimit > -1){
+                zoom = min(zoom, maxZoomLimit);
+            }
+            return zoom
+        }
 
         func update(scale factor: CGFloat) {
             do {
@@ -466,6 +542,13 @@ extension CameraController: UIGestureRecognizerDelegate {
                 defer { device.unlockForConfiguration() }
 
                 device.videoZoomFactor = factor
+                
+                let data = """
+                {
+                    "level": \(factor)
+                }
+                """
+                bridge?.triggerWindowJSEvent(eventName: "CameraPreview.zoomLevelChanged", data: data)
             } catch {
                 debugPrint(error)
             }
diff --git a/ios/Plugin/Plugin.m b/ios/Plugin/Plugin.m
index 06fb55e1..19e1a959 100644
--- a/ios/Plugin/Plugin.m
+++ b/ios/Plugin/Plugin.m
@@ -13,4 +13,9 @@
            CAP_PLUGIN_METHOD(setFlashMode, CAPPluginReturnPromise);
            CAP_PLUGIN_METHOD(startRecordVideo, CAPPluginReturnPromise);
            CAP_PLUGIN_METHOD(stopRecordVideo, CAPPluginReturnPromise);
+           CAP_PLUGIN_METHOD(getMaxZoom, CAPPluginReturnPromise);
+           CAP_PLUGIN_METHOD(getZoom, CAPPluginReturnPromise);
+           CAP_PLUGIN_METHOD(setZoom, CAPPluginReturnPromise);
+           CAP_PLUGIN_METHOD(getMaxZoomLimit, CAPPluginReturnPromise);
+           CAP_PLUGIN_METHOD(setMaxZoomLimit, CAPPluginReturnPromise);
 )
diff --git a/ios/Plugin/Plugin.swift b/ios/Plugin/Plugin.swift
index 044a9e68..4b59f0df 100644
--- a/ios/Plugin/Plugin.swift
+++ b/ios/Plugin/Plugin.swift
@@ -45,6 +45,7 @@ public class CameraPreview: CAPPlugin {
         self.cameraPosition = call.getString("position") ?? "rear"
         self.highResolutionOutput = call.getBool("enableHighResolution") ?? false
         self.cameraController.highResolutionOutput = self.highResolutionOutput
+        self.cameraController.bridge = self.bridge
 
         if call.getInt("width") != nil {
             self.width = CGFloat(call.getInt("width")!)
@@ -56,8 +57,8 @@ public class CameraPreview: CAPPlugin {
         } else {
             self.height = UIScreen.main.bounds.size.height
         }
-        self.x = call.getInt("x") != nil ? CGFloat(call.getInt("x")!)/UIScreen.main.scale: 0
-        self.y = call.getInt("y") != nil ? CGFloat(call.getInt("y")!)/UIScreen.main.scale: 0
+        self.x = call.getInt("x") != nil ? CGFloat(call.getInt("x")!)/2: 0
+        self.y = call.getInt("y") != nil ? CGFloat(call.getInt("y")!)/2: 0
         if call.getInt("paddingBottom") != nil {
             self.paddingBottom = CGFloat(call.getInt("paddingBottom")!)
         }
@@ -67,6 +68,7 @@ public class CameraPreview: CAPPlugin {
         self.storeToFile = call.getBool("storeToFile") ?? false
         self.enableZoom = call.getBool("enableZoom") ?? false
         self.disableAudio = call.getBool("disableAudio") ?? false
+        self.cameraController.maxZoomLimit = CGFloat(call.getFloat("maxZoomLimit", -1))
 
         AVCaptureDevice.requestAccess(for: .video, completionHandler: { (granted: Bool) in
             guard granted else {
@@ -287,5 +289,50 @@ public class CameraPreview: CAPPlugin {
 
         }
     }
+    
+    @objc func getMaxZoom(_ call: CAPPluginCall) {
+        do {
+            let maxZoom = try self.cameraController.getMaxZoom()
+            call.resolve(["value": maxZoom])
+        } catch {
+            call.reject("failed to get max zoom")
+        }
+    }
+    
+    @objc func getZoom(_ call: CAPPluginCall) {
+        do {
+            let zoom = try self.cameraController.getZoom()
+            call.resolve(["value": zoom])
+        } catch {
+            call.reject("failed to get zoom")
+        }
+    }
+    
+    @objc func setZoom(_ call: CAPPluginCall) {
+        do {
+            guard let zoom = call.getFloat("zoom") else {
+                call.reject("failed to set zoom. required parameter zoom is missing")
+                return
+            }
+            try self.cameraController.setZoom(desiredZoomFactor: CGFloat(zoom))
+            call.resolve()
+        } catch {
+            call.reject("failed to set zoom")
+        }
+    }
+    
+    @objc func getMaxZoomLimit(_ call: CAPPluginCall) {
+        let zoom = self.cameraController.maxZoomLimit
+        call.resolve(["value": zoom])
+    }
+    
+    @objc func setMaxZoomLimit(_ call: CAPPluginCall) {
+        guard let maxZoomLimit = call.getFloat("zoom") else {
+            call.reject("failed to set maxZoomLimit. required parameter zoom is missing")
+            return
+        }
+        self.cameraController.maxZoomLimit = CGFloat(maxZoomLimit)
+        call.resolve()
+    }
 
 }
diff --git a/src/definitions.ts b/src/definitions.ts
index 1e4efe00..35fd15fd 100644
--- a/src/definitions.ts
+++ b/src/definitions.ts
@@ -34,6 +34,8 @@ export interface CameraPreviewOptions {
   enableOpacity?: boolean;
   /** Defaults to false - Android only.  Set if camera preview will support pinch to zoom. */
   enableZoom?: boolean;
+  /** Defaults to none. Sets the max allowed zoom level. */
+  maxZoomLimit?: number
 }
 export interface CameraPreviewPictureOptions {
   /** The picture height, optional, default 0 (Device default) */
@@ -69,6 +71,12 @@ export interface CameraPreviewPlugin {
     result: CameraPreviewFlashMode[];
   }>;
   setFlashMode(options: { flashMode: CameraPreviewFlashMode | string }): Promise<void>;
+  setZoom(options: { zoom: number }): Promise<void>;
+  getZoom(): Promise<{ value: number }>;
+  getMaxZoom(): Promise<{ value: number }>;
+  setMaxZoomLimit(options: { zoom: number }): Promise<void>;
+  getMaxZoomLimit(): Promise<{ value: number }>;
   flip(): Promise<void>;
   setOpacity(options: CameraOpacityOptions): Promise<{}>;
+  getCameraCharacteristics(): Promise<{}>;
 }
diff --git a/src/web.ts b/src/web.ts
index 5f9bf913..0d519ea7 100644
--- a/src/web.ts
+++ b/src/web.ts
@@ -174,10 +174,34 @@ export class CameraPreviewWeb extends WebPlugin implements CameraPreviewPlugin {
     throw new Error('flip not supported under the web platform');
   }
 
+  async getZoom(): Promise<{ value: number }> {
+    throw new Error('getZoom not supported under the web platform');
+  }
+
+  async setZoom(_options: { zoom: number }): Promise<void> {
+      throw new Error('setZoom not supported under the web platform');
+  }
+
+  async getMaxZoom(): Promise<{ value: number }> {
+      throw new Error('getMaxZoom not supported under the web platform');
+  }
+
+  async getMaxZoomLimit(): Promise<{ value: number }> {
+    throw new Error('getMaxZoomLimit not supported under the web platform');
+  }
+
+  async setMaxZoomLimit(_options: { zoom: number }): Promise<void> {
+    throw new Error('setMaxZoomLimit not supported under the web platform');
+  }
+
   async setOpacity(_options: CameraOpacityOptions): Promise<any> {
     const video = <HTMLVideoElement>document.getElementById('video');
     if (!!video && !!_options['opacity']) {
       video.style.setProperty('opacity', _options['opacity'].toString());
     }
   }
+
+  async getCameraCharacteristics(): Promise<any> {
+    throw new Error('getCameraCharacteristics not supported under the web platform');
+  }
 }