Video capture

plugin.xml

@@ -19,6 +19,7 @@
    <framework src="androidx.camera:camera-camera2:1.1.0" />
    <framework src="androidx.camera:camera-lifecycle:1.1.0" />
    <framework src="androidx.camera:camera-view:1.1.0" />
+   <framework src="androidx.camera:camera-video:1.1.0" />
 
     <source-file src="src/android/CameraPreviewFragment.java" target-dir="src/com/spoon/simplecamerapreview" />
     <source-file src="src/android/SimpleCameraPreview.java" target-dir="src/com/spoon/simplecamerapreview" />

src/android/CameraPreviewFragment.java

@@ -1,13 +1,17 @@
 package com.spoon.simplecamerapreview;
 
+import android.Manifest;
 import android.annotation.SuppressLint;
+import android.content.ContentValues;
 import android.content.Context;
+import android.content.pm.PackageManager;
 import android.content.res.Configuration;
 import android.graphics.Point;
 import android.hardware.camera2.CameraCharacteristics;
 import android.location.Location;
 import android.net.Uri;
 import android.os.Bundle;
+import android.provider.MediaStore;
 import android.os.Handler;
 import android.os.Looper;
 import android.util.Log;
@@ -29,8 +33,17 @@
 import androidx.camera.core.ImageCaptureException;
 import androidx.camera.core.Preview;
 import androidx.camera.lifecycle.ProcessCameraProvider;
+import androidx.camera.video.FileOutputOptions;
+import androidx.camera.video.Quality;
+import androidx.camera.video.QualitySelector;
+import androidx.camera.video.Recorder;
+import androidx.camera.video.Recording;
+import androidx.camera.video.VideoCapture;
+import androidx.camera.video.VideoRecordEvent;
 import androidx.camera.view.PreviewView;
+import androidx.core.app.ActivityCompat;
 import androidx.core.content.ContextCompat;
+
 import androidx.exifinterface.media.ExifInterface;
 import androidx.fragment.app.Fragment;
 
@@ -51,6 +64,11 @@ interface CameraCallback {
     void onCompleted(Exception err, String nativePath);
 }
 
+interface VideoCallback {
+    void onStart(Boolean recording, String nativePath);
+    void onStop(Boolean recording, String nativePath);
+}
+
 interface CameraStartedCallback {
     void onCameraStarted(Exception err);
 }
@@ -76,6 +94,9 @@ public class CameraPreviewFragment extends Fragment {
     private PreviewView viewFinder;
     private Preview preview;
     private ImageCapture imageCapture;
+    private VideoCapture<Recorder> videoCapture;
+    Recording recording = null;
+    ProcessCameraProvider cameraProvider = null;
     private Camera camera;
     private CameraStartedCallback startCameraCallback;
     private Location location;
@@ -86,6 +107,9 @@ public class CameraPreviewFragment extends Fragment {
     private static float ratio = (4 / (float) 3);
     private static final String TAG = "SimpleCameraPreview";
     private String captureDevice;
+    private String filename;
+    private File videoFile;
+    private VideoRecordEvent videoRecordEvent;
 
     public CameraPreviewFragment() {
 
@@ -120,13 +144,11 @@ public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup c
         viewFinder.setLayoutParams(new RelativeLayout.LayoutParams(RelativeLayout.LayoutParams.MATCH_PARENT, RelativeLayout.LayoutParams.MATCH_PARENT));
         containerView.addView(viewFinder);
         startCamera();
-
         return containerView;
     }
 
     public void startCamera() {
         ListenableFuture<ProcessCameraProvider> cameraProviderFuture = ProcessCameraProvider.getInstance(getActivity());
-        ProcessCameraProvider cameraProvider = null;
 
         try {
             cameraProvider = cameraProviderFuture.get();
@@ -136,8 +158,8 @@ public void startCamera() {
             startCameraCallback.onCameraStarted(new Exception("Unable to start camera"));
             return;
         }
-        setUpCamera(captureDevice,cameraProvider);
 
+        setUpCamera(captureDevice,cameraProvider);
         preview.setSurfaceProvider(viewFinder.getSurfaceProvider());
 
         if (startCameraCallback != null) {
@@ -258,6 +280,59 @@ public void hasFlash(HasFlashCallback hasFlashCallback) {
         hasFlashCallback.onResult(camera.getCameraInfo().hasFlashUnit());
     }
 
+    public void startVideoCapture(VideoCallback videoCallback) {
+        if (recording != null) {
+            recording.stop();
+            recording = null;
+            return;
+        }
+        UUID uuid = UUID.randomUUID();
+
+        String filename = uuid.toString() + ".mp4";
+        if (ActivityCompat.checkSelfPermission(this.getContext(), Manifest.permission.RECORD_AUDIO) != PackageManager.PERMISSION_GRANTED) {
+            ActivityCompat.requestPermissions(this.getActivity(), new String[]{Manifest.permission.RECORD_AUDIO}, 200);
+        }
+        File videoFile = new File(
+                getContext().getFilesDir(),
+                filename
+        );
+
+        FileOutputOptions outputOptions = new FileOutputOptions.Builder(videoFile).build();
+
+        recording = videoCapture.getOutput()
+                .prepareRecording(this.getContext().getApplicationContext(), outputOptions)
+                .withAudioEnabled()
+                .start(ContextCompat.getMainExecutor(this.getContext()), videoRecordEvent -> {
+                    if (videoRecordEvent instanceof VideoRecordEvent.Start) {
+                        videoCallback.onStart(true, null);
+                    } else if (videoRecordEvent instanceof VideoRecordEvent.Finalize) {
+                        VideoRecordEvent.Finalize finalizeEvent = (VideoRecordEvent.Finalize) videoRecordEvent;
+                        if (finalizeEvent.hasError()) {
+                            // Handle the error
+                            int errorCode = finalizeEvent.getError();
+                            Throwable errorCause = finalizeEvent.getCause();
+                            Log.e(TAG, "Video recording error: " + errorCode, errorCause);
+                        } else {
+                            // Handle video saved
+                            videoCallback.onStop(false, Uri.fromFile(videoFile).toString());
+                            Uri savedUri = finalizeEvent.getOutputResults().getOutputUri();
+                            Log.i(TAG, "Video saved to: " + savedUri);
+                        }
+                        recording = null;
+                    }
+                    // Other event types can be handled if needed
+                });
+
+    }
+    public void stopVideoCapture() {
+        if (recording !=null) {
+            recording.stop();
+            recording = null;
+        }
+    }
+
+
+
     public void takePicture(boolean useFlash, CameraCallback takePictureCallback) {
         if (torchActivated) {
             useFlash = true;
@@ -361,7 +436,7 @@ public void switchCameraTo(String device, CameraSwitchedCallback cameraSwitchedC
     @SuppressLint("RestrictedApi")
     public void setUpCamera(String captureDevice, ProcessCameraProvider cameraProvider) {
         CameraSelector cameraSelector;
-        if (captureDevice != null && captureDevice.equals("ultra-wide-angle")) {
+        if (captureDevice.equals("ultra-wide-angle")) {
             cameraSelector = new CameraSelector.Builder()
                     .addCameraFilter(cameraInfos -> {
                         List<Camera2CameraInfoImpl> backCameras = new ArrayList<>();
@@ -398,18 +473,24 @@ public void setUpCamera(String captureDevice, ProcessCameraProvider cameraProvid
             targetResolution = CameraPreviewFragment.calculateResolution(getContext(), targetSize);
         }
 
+        Recorder recorder = new Recorder.Builder()
+                .setQualitySelector(QualitySelector.from(Quality.LOWEST))
+                .build();
+        videoCapture = VideoCapture.withOutput(recorder);
+
+
         preview = new Preview.Builder().build();
         imageCapture = new ImageCapture.Builder()
                 .setTargetResolution(targetResolution)
                 .build();
-
         cameraProvider.unbindAll();
         try {
             camera = cameraProvider.bindToLifecycle(
                     getActivity(),
                     cameraSelector,
                     preview,
-                    imageCapture
+                    imageCapture,
+                    videoCapture
             );
         } catch (IllegalArgumentException e) {
             // Error with result in capturing image with default resolution
@@ -420,9 +501,9 @@ public void setUpCamera(String captureDevice, ProcessCameraProvider cameraProvid
                     getActivity(),
                     cameraSelector,
                     preview,
-                    imageCapture
+                    imageCapture,
+                    videoCapture
             );
         }
-
     }
 }

src/android/SimpleCameraPreview.java

@@ -39,10 +39,10 @@ public class SimpleCameraPreview extends CordovaPlugin {
     private CameraPreviewFragment fragment;
     private JSONObject options;
     private CallbackContext enableCallbackContext;
+    private CallbackContext videoCallbackContext;
     private LocationManager locationManager;
     private LocationListener mLocationCallback;
     private ViewParent webViewParent;
-
     private static final int containerViewId = 20;
     private static final int DIRECTION_FRONT = 0;
     private static final int DIRECTION_BACK = 1;
@@ -72,6 +72,15 @@ public boolean execute(String action, JSONArray args, CallbackContext callbackCo
                 case "torchSwitch":
                     return torchSwitch(args.getBoolean(0), callbackContext);
 
+                case "initVideoCallback":
+                    return initVideoCallback(callbackContext);
+
+                case "startCaptureVideo":
+                    return captureVideo(callbackContext);
+
+                case "stopCaptureVideo":
+                    return stopCaptureVideo(callbackContext);
+
                 case "deviceHasFlash":
                     return deviceHasFlash(callbackContext);
 
@@ -92,6 +101,14 @@ public boolean execute(String action, JSONArray args, CallbackContext callbackCo
         }
     }
 
+    private boolean initVideoCallback(CallbackContext callbackContext) {
+        this.videoCallbackContext = callbackContext;
+        PluginResult result = new PluginResult(PluginResult.Status.OK, "video callback initialized");
+        result.setKeepCallback(true);
+        this.videoCallbackContext.sendPluginResult(result);
+        return true;
+    }
+
     private boolean setOptions(JSONObject options, CallbackContext callbackContext) {
         int targetSize = 0;
         try {
@@ -267,6 +284,66 @@ public void fetchLocation() {
         }
     }
 
+    private boolean captureVideo(CallbackContext callbackContext) {
+        if (fragment == null) {
+            callbackContext.error("Camera is closed");
+            return true;
+        }
+
+        if (this.videoCallbackContext != null) {
+            fragment.startVideoCapture(new VideoCallback() {
+                public void onStart(Boolean recording, String nativePath) {
+                    JSONObject data = new JSONObject();
+                    if (recording) {
+                        try {
+                            data.put("recording", true);
+                            data.put("nativePath", null);
+                        } catch (JSONException e) {
+                            e.printStackTrace();
+                            callbackContext.error("Cannot send recording data");
+                            return;
+                        }
+
+                        PluginResult pluginResult = new PluginResult(PluginResult.Status.OK, data);
+                        pluginResult.setKeepCallback(true);
+                        callbackContext.sendPluginResult(pluginResult);
+                    }
+                }
+
+                public void onStop(Boolean recording, String nativePath) {
+                    JSONObject data = new JSONObject();
+                    try {
+                        data.put("recording", false);
+                        data.put("nativePath", nativePath);
+                    } catch (JSONException e) {
+                        e.printStackTrace();
+                        callbackContext.error("Cannot send recording data");
+                        return;
+                    }
+                    PluginResult pluginResult = new PluginResult(PluginResult.Status.OK, data);
+                    pluginResult.setKeepCallback(true);
+                    callbackContext.sendPluginResult(pluginResult);
+                }
+            });
+        }
+        callbackContext.success();
+        return true;
+    }
+
+    public boolean stopCaptureVideo(CallbackContext callbackContext) {
+        if (fragment == null) {
+            callbackContext.error("Camera is closed");
+            return true;
+        }
+
+        if (this.videoCallbackContext != null) {
+            fragment.stopVideoCapture();
+        }
+
+        callbackContext.success();
+        return true;
+    }
+
     private boolean capture(boolean useFlash, CallbackContext callbackContext) {
         if (fragment == null) {
             callbackContext.error("Camera is closed");

www/SimpleCameraPreview.js

@@ -2,6 +2,41 @@ var exec = require("cordova/exec");
 var PLUGIN_NAME = "SimpleCameraPreview";
 var SimpleCameraPreview = function () {};
 
+SimpleCameraPreview.videoInitialized = false;
+SimpleCameraPreview.videoCallback = null;
+
+SimpleCameraPreview.startVideoCapture = function (onSuccess, onError) {
+  if (!SimpleCameraPreview.videoCallback) {
+    console.error("Call setVideoCallback first");
+    onError("Call setVideoCallback first");
+    return;
+  }
+
+  if (!SimpleCameraPreview.videoInitialized) {
+    exec(
+        (info) => {
+          SimpleCameraPreview.videoInitialized = true;
+          this.videoCallback(info);
+        } ,
+          (err) => {
+            console.log("Error initializing video callback", err);
+        },
+        "SimpleCameraPreview",
+        "initVideoCallback",
+        []
+    );
+  }
+  exec(onSuccess, onError, PLUGIN_NAME, "startVideoCapture");
+};
+
+SimpleCameraPreview.stopVideoCapture = function (onSuccess, onError) {
+  exec(onSuccess, onError, PLUGIN_NAME, "stopVideoCapture");
+};
+
+SimpleCameraPreview.setVideoCallback = function (callback) {
+    this.videoCallback = callback;
+}
+
 SimpleCameraPreview.setOptions = function (options, onSuccess, onError) {
   exec(onSuccess, onError, PLUGIN_NAME, "setOptions", [options]);
 };
@@ -43,3 +78,4 @@ SimpleCameraPreview.deviceHasUltraWideCamera = function (onSuccess, onError) {
 };
 
 module.exports = SimpleCameraPreview;
+