@capgo/camera-preview 3.6.23 → 4.0.0

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

@@ -28,488 +28,603 @@ import java.io.File;
 import java.util.List;
 import org.json.JSONArray;
 
-@CapacitorPlugin(name = "CameraPreview", permissions = { @Permission(strings = { CAMERA }, alias = CameraPreview.CAMERA_PERMISSION_ALIAS) })
-public class CameraPreview extends Plugin implements CameraActivity.CameraPreviewListener {
-
-    static final String CAMERA_PERMISSION_ALIAS = "camera";
-
-    private static String VIDEO_FILE_PATH = "";
-    private static String VIDEO_FILE_EXTENSION = ".mp4";
-
-    private String captureCallbackId = "";
-    private String snapshotCallbackId = "";
-    private String recordCallbackId = "";
-    private String cameraStartCallbackId = "";
-
-    // keep track of previously specified orientation to support locking orientation:
-    private int previousOrientationRequest = -1;
-
-    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");
-        }
+@CapacitorPlugin(
+  name = "CameraPreview",
+  permissions = {
+    @Permission(
+      strings = { CAMERA },
+      alias = CameraPreview.CAMERA_PERMISSION_ALIAS
+    ),
+  }
+)
+public class CameraPreview
+  extends Plugin
+  implements CameraActivity.CameraPreviewListener {
+
+  static final String CAMERA_PERMISSION_ALIAS = "camera";
+
+  private static String VIDEO_FILE_PATH = "";
+  private static String VIDEO_FILE_EXTENSION = ".mp4";
+
+  private String captureCallbackId = "";
+  private String snapshotCallbackId = "";
+  private String recordCallbackId = "";
+  private String cameraStartCallbackId = "";
+
+  // keep track of previously specified orientation to support locking orientation:
+  private int previousOrientationRequest = -1;
+
+  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"
+      );
     }
-
-    @PluginMethod
-    public void flip(PluginCall call) {
-        try {
-            fragment.switchCamera();
-            call.resolve();
-        } catch (Exception e) {
-            Logger.debug(getLogTag(), "Camera flip exception: " + e);
-            call.reject("failed to flip camera");
-        }
+  }
+
+  @PluginMethod
+  public void flip(PluginCall call) {
+    try {
+      fragment.switchCamera();
+      call.resolve();
+    } catch (Exception e) {
+      Logger.debug(getLogTag(), "Camera flip exception: " + e);
+      call.reject("failed to flip camera");
     }
+  }
 
-    @PluginMethod
-    public void setOpacity(PluginCall call) {
-        if (this.hasCamera(call) == false) {
-            call.error("Camera is not running");
-            return;
-        }
-
-        bridge.saveCall(call);
-        Float opacity = call.getFloat("opacity", 1F);
-        fragment.setOpacity(opacity);
+  @PluginMethod
+  public void setOpacity(PluginCall call) {
+    if (this.hasCamera(call) == false) {
+      call.error("Camera is not running");
+      return;
     }
 
-    @PluginMethod
-    public void capture(PluginCall call) {
-        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);
-    }
-
-    @PluginMethod
-    public void captureSample(PluginCall call) {
-        if (this.hasCamera(call) == false) {
-            call.reject("Camera is not running");
-            return;
-        }
-        bridge.saveCall(call);
-        snapshotCallbackId = call.getCallbackId();
+    bridge.saveCall(call);
+    Float opacity = call.getFloat("opacity", 1F);
+    fragment.setOpacity(opacity);
+  }
 
-        Integer quality = call.getInt("quality", 85);
-        fragment.takeSnapshot(quality);
+  @PluginMethod
+  public void capture(PluginCall call) {
+    if (this.hasCamera(call) == false) {
+      call.reject("Camera is not running");
+      return;
     }
-
-    @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");
-                        }
-                    }
-                }
-            );
+    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);
+  }
+
+  @PluginMethod
+  public void captureSample(PluginCall call) {
+    if (this.hasCamera(call) == false) {
+      call.reject("Camera is not running");
+      return;
     }
-
-    @PluginMethod
-    public void getSupportedFlashModes(PluginCall call) {
-        if (this.hasCamera(call) == false) {
-            call.reject("Camera is not running");
-            return;
-        }
-
-        Camera camera = fragment.getCamera();
-        Camera.Parameters params = camera.getParameters();
-        List<String> supportedFlashModes;
-        supportedFlashModes = params.getSupportedFlashModes();
-        JSONArray jsonFlashModes = new JSONArray();
-
-        if (supportedFlashModes != null) {
-            for (int i = 0; i < supportedFlashModes.size(); i++) {
-                jsonFlashModes.put(new String(supportedFlashModes.get(i)));
+    bridge.saveCall(call);
+    snapshotCallbackId = call.getCallbackId();
+
+    Integer quality = call.getInt("quality", 85);
+    fragment.takeSnapshot(quality);
+  }
+
+  @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");
             }
+          }
         }
-
-        JSObject jsObject = new JSObject();
-        jsObject.put("result", jsonFlashModes);
-        call.resolve(jsObject);
+      );
+  }
+
+  @PluginMethod
+  public void getSupportedFlashModes(PluginCall call) {
+    if (this.hasCamera(call) == false) {
+      call.reject("Camera is not running");
+      return;
     }
 
-    @PluginMethod
-    public void getHorizontalFov(PluginCall call) {
-        if (this.hasCamera(call) == false) {
-            call.reject("Camera is not running");
-            return;
-        }
-
-        Camera camera = fragment.getCamera();
-        Camera.Parameters params = camera.getParameters();
+    Camera camera = fragment.getCamera();
+    Camera.Parameters params = camera.getParameters();
+    List<String> supportedFlashModes;
+    supportedFlashModes = params.getSupportedFlashModes();
+    JSONArray jsonFlashModes = new JSONArray();
 
-        float horizontalViewAngle = params.getHorizontalViewAngle();
-
-        JSObject jsObject = new JSObject();
-        jsObject.put("result", horizontalViewAngle);
-        call.resolve(jsObject);
+    if (supportedFlashModes != null) {
+      for (int i = 0; i < supportedFlashModes.size(); i++) {
+        jsonFlashModes.put(new String(supportedFlashModes.get(i)));
+      }
     }
 
-    @PluginMethod
-    public void setFlashMode(PluginCall call) {
-        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;
-        }
-
-        Camera camera = fragment.getCamera();
-        Camera.Parameters params = camera.getParameters();
-
-        List<String> supportedFlashModes;
-        supportedFlashModes = camera.getParameters().getSupportedFlashModes();
-        if (supportedFlashModes.indexOf(flashMode) > -1) {
-            params.setFlashMode(flashMode);
-        } else {
-            call.reject("Flash mode not recognised: " + flashMode);
-            return;
-        }
+    JSObject jsObject = new JSObject();
+    jsObject.put("result", jsonFlashModes);
+    call.resolve(jsObject);
+  }
 
-        fragment.setCameraParameters(params);
-
-        call.resolve();
+  @PluginMethod
+  public void getHorizontalFov(PluginCall call) {
+    if (this.hasCamera(call) == false) {
+      call.reject("Camera is not running");
+      return;
     }
 
-    @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);
-                    }
-                }
-            );
-
-        call.resolve();
-    }
+    Camera camera = fragment.getCamera();
+    Camera.Parameters params = camera.getParameters();
 
-    @PluginMethod
-    public void stopRecordVideo(PluginCall call) {
-        if (this.hasCamera(call) == false) {
-            call.reject("Camera is not running");
-            return;
-        }
+    float horizontalViewAngle = params.getHorizontalViewAngle();
 
-        System.out.println("stopRecordVideo - Callbackid=" + call.getCallbackId());
+    JSObject jsObject = new JSObject();
+    jsObject.put("result", horizontalViewAngle);
+    call.resolve(jsObject);
+  }
 
-        bridge.saveCall(call);
-        recordCallbackId = call.getCallbackId();
-
-        // bridge.getActivity().runOnUiThread(new Runnable() {
-        //     @Override
-        //     public void run() {
-        //         fragment.stopRecord();
-        //     }
-        // });
+  @PluginMethod
+  public void setFlashMode(PluginCall call) {
+    if (this.hasCamera(call) == false) {
+      call.reject("Camera is not running");
+      return;
+    }
 
-        fragment.stopRecord();
-        // call.resolve();
+    String flashMode = call.getString("flashMode");
+    if (flashMode == null || flashMode.isEmpty() == true) {
+      call.reject("flashMode required parameter is missing");
+      return;
     }
 
-    @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.");
-        }
+    Camera camera = fragment.getCamera();
+    Camera.Parameters params = camera.getParameters();
+
+    List<String> supportedFlashModes;
+    supportedFlashModes = camera.getParameters().getSupportedFlashModes();
+    if (
+      supportedFlashModes != null && supportedFlashModes.indexOf(flashMode) > -1
+    ) {
+      params.setFlashMode(flashMode);
+    } else {
+      call.reject("Flash mode not recognised: " + flashMode);
+      return;
     }
 
-    private void startCamera(final PluginCall call) {
-        String position = call.getString("position");
+    fragment.setCameraParameters(params);
 
-        if (position == null || position.isEmpty() || "rear".equals(position)) {
-            position = "back";
-        } else {
-            position = "front";
-        }
+    call.resolve();
+  }
 
-        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);
-
-                            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 (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");
-                        }
-                    }
-                }
-            );
+  @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
+            );
+          }
+        }
+      );
 
-    @Override
-    protected void handleOnResume() {
-        super.handleOnResume();
-    }
+    call.resolve();
+  }
 
-    @Override
-    public void onPictureTaken(String originalPicture) {
-        JSObject jsObject = new JSObject();
-        jsObject.put("value", originalPicture);
-        bridge.getSavedCall(captureCallbackId).resolve(jsObject);
+  @PluginMethod
+  public void stopRecordVideo(PluginCall call) {
+    if (this.hasCamera(call) == false) {
+      call.reject("Camera is not running");
+      return;
     }
 
-    @Override
-    public void onPictureTakenError(String message) {
-        bridge.getSavedCall(captureCallbackId).reject(message);
+    System.out.println("stopRecordVideo - Callbackid=" + call.getCallbackId());
+
+    bridge.saveCall(call);
+    recordCallbackId = call.getCallbackId();
+
+    // bridge.getActivity().runOnUiThread(new Runnable() {
+    //     @Override
+    //     public void run() {
+    //         fragment.stopRecord();
+    //     }
+    // });
+
+    fragment.stopRecord();
+    // call.resolve();
+  }
+
+  @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.");
     }
+  }
 
-    @Override
-    public void onSnapshotTaken(String originalPicture) {
-        JSObject jsObject = new JSObject();
-        jsObject.put("value", originalPicture);
-        bridge.getSavedCall(snapshotCallbackId).resolve(jsObject);
-    }
+  private void startCamera(final PluginCall call) {
+    String position = call.getString("position");
 
-    @Override
-    public void onSnapshotTakenError(String message) {
-        bridge.getSavedCall(snapshotCallbackId).reject(message);
+    if (position == null || position.isEmpty() || "rear".equals(position)) {
+      position = "back";
+    } else {
+      position = "front";
     }
 
-    @Override
-    public void onFocusSet(int pointX, int pointY) {}
-
-    @Override
-    public void onFocusSetError(String message) {}
-
-    @Override
-    public void onBackButton() {}
+    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
+                );
+            }
 
-    @Override
-    public void onCameraStarted() {
-        PluginCall pluginCall = bridge.getSavedCall(cameraStartCallbackId);
-        pluginCall.resolve();
-        bridge.releaseCall(pluginCall);
-    }
+            // offset
+            int computedX = (int) TypedValue.applyDimension(
+              TypedValue.COMPLEX_UNIT_DIP,
+              x,
+              metrics
+            );
+            int computedY = (int) TypedValue.applyDimension(
+              TypedValue.COMPLEX_UNIT_DIP,
+              y,
+              metrics
+            );
 
-    @Override
-    public void onStartRecordVideo() {}
+            // size
+            int computedWidth;
+            int computedHeight;
+            int computedPaddingBottom;
+
+            if (paddingBottom != 0) {
+              computedPaddingBottom =
+                (int) TypedValue.applyDimension(
+                  TypedValue.COMPLEX_UNIT_DIP,
+                  paddingBottom,
+                  metrics
+                );
+            } else {
+              computedPaddingBottom = 0;
+            }
 
-    @Override
-    public void onStartRecordVideoError(String message) {
-        bridge.getSavedCall(recordCallbackId).reject(message);
-    }
+            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
+                );
+            }
 
-    @Override
-    public void onStopRecordVideo(String file) {
-        PluginCall pluginCall = bridge.getSavedCall(recordCallbackId);
-        JSObject jsObject = new JSObject();
-        jsObject.put("videoFilePath", file);
-        pluginCall.resolve(jsObject);
-    }
+            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;
+            }
 
-    @Override
-    public void onStopRecordVideoError(String error) {
-        bridge.getSavedCall(recordCallbackId).reject(error);
-    }
+            fragment.setRect(
+              computedX,
+              computedY,
+              computedWidth,
+              computedHeight
+            );
 
-    private boolean hasView(PluginCall call) {
-        if (fragment == null) {
-            return false;
+            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 (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");
+            }
+          }
         }
-
-        return true;
+      );
+  }
+
+  @Override
+  protected void handleOnResume() {
+    super.handleOnResume();
+  }
+
+  @Override
+  public void onPictureTaken(String originalPicture) {
+    JSObject jsObject = new JSObject();
+    jsObject.put("value", originalPicture);
+    bridge.getSavedCall(captureCallbackId).resolve(jsObject);
+  }
+
+  @Override
+  public void onPictureTakenError(String message) {
+    bridge.getSavedCall(captureCallbackId).reject(message);
+  }
+
+  @Override
+  public void onSnapshotTaken(String originalPicture) {
+    JSObject jsObject = new JSObject();
+    jsObject.put("value", originalPicture);
+    bridge.getSavedCall(snapshotCallbackId).resolve(jsObject);
+  }
+
+  @Override
+  public void onSnapshotTakenError(String message) {
+    bridge.getSavedCall(snapshotCallbackId).reject(message);
+  }
+
+  @Override
+  public void onFocusSet(int pointX, int pointY) {}
+
+  @Override
+  public void onFocusSetError(String message) {}
+
+  @Override
+  public void onBackButton() {}
+
+  @Override
+  public void onCameraStarted() {
+    PluginCall pluginCall = bridge.getSavedCall(cameraStartCallbackId);
+    pluginCall.resolve();
+    bridge.releaseCall(pluginCall);
+  }
+
+  @Override
+  public void onStartRecordVideo() {}
+
+  @Override
+  public void onStartRecordVideoError(String message) {
+    bridge.getSavedCall(recordCallbackId).reject(message);
+  }
+
+  @Override
+  public void onStopRecordVideo(String file) {
+    PluginCall pluginCall = bridge.getSavedCall(recordCallbackId);
+    JSObject jsObject = new JSObject();
+    jsObject.put("videoFilePath", file);
+    pluginCall.resolve(jsObject);
+  }
+
+  @Override
+  public void onStopRecordVideoError(String error) {
+    bridge.getSavedCall(recordCallbackId).reject(error);
+  }
+
+  private boolean hasView(PluginCall call) {
+    if (fragment == null) {
+      return false;
     }
 
-    private boolean hasCamera(PluginCall call) {
-        if (this.hasView(call) == false) {
-            return false;
-        }
+    return true;
+  }
 
-        if (fragment.getCamera() == null) {
-            return false;
-        }
+  private boolean hasCamera(PluginCall call) {
+    if (this.hasView(call) == false) {
+      return false;
+    }
 
-        return true;
+    if (fragment.getCamera() == null) {
+      return false;
     }
 
-    private String getFilePath(String filename) {
-        String fileName = filename;
+    return true;
+  }
 
-        int i = 1;
+  private String getFilePath(String filename) {
+    String fileName = filename;
 
-        while (new File(VIDEO_FILE_PATH + fileName + VIDEO_FILE_EXTENSION).exists()) {
-            // Add number suffix if file exists
-            fileName = filename + '_' + i;
-            i++;
-        }
+    int i = 1;
 
-        return VIDEO_FILE_PATH + fileName + VIDEO_FILE_EXTENSION;
+    while (
+      new File(VIDEO_FILE_PATH + fileName + VIDEO_FILE_EXTENSION).exists()
+    ) {
+      // Add number suffix if file exists
+      fileName = filename + '_' + i;
+      i++;
     }
 
-    private void setupBroadcast() {
-        /** When touch event is triggered, relay it to camera view if needed so it can support pinch zoom */
-
-        getBridge().getWebView().setClickable(true);
-        getBridge()
-            .getWebView()
-            .setOnTouchListener(
-                new View.OnTouchListener() {
-                    @Override
-                    public boolean onTouch(View v, MotionEvent event) {
-                        if ((null != fragment) && (fragment.toBack == true)) {
-                            fragment.frameContainerLayout.dispatchTouchEvent(event);
-                        }
-                        return false;
-                    }
-                }
-            );
-    }
+    return VIDEO_FILE_PATH + fileName + VIDEO_FILE_EXTENSION;
+  }
+
+  private void setupBroadcast() {
+    /** When touch event is triggered, relay it to camera view if needed so it can support pinch zoom */
+
+    getBridge().getWebView().setClickable(true);
+    getBridge()
+      .getWebView()
+      .setOnTouchListener(
+        new View.OnTouchListener() {
+          @Override
+          public boolean onTouch(View v, MotionEvent event) {
+            if ((null != fragment) && (fragment.toBack == true)) {
+              fragment.frameContainerLayout.dispatchTouchEvent(event);
+            }
+            return false;
+          }
+        }
+      );
+  }
 }