@capgo/camera-preview 8.4.8 → 8.5.0

package/README.md

@@ -376,6 +376,12 @@ Documentation for the [uploader](https://github.com/Cap-go/capacitor-uploader)
 * [`setOpacity(...)`](#setopacity)
 * [`stopRecordVideo()`](#stoprecordvideo)
 * [`startRecordVideo(...)`](#startrecordvideo)
+* [`setVideoQuality(...)`](#setvideoquality)
+* [`getVideoQuality()`](#getvideoquality)
+* [`getSupportedVideoQualities()`](#getsupportedvideoqualities)
+* [`setVideoCodec(...)`](#setvideocodec)
+* [`getVideoCodec()`](#getvideocodec)
+* [`getSupportedVideoCodecs()`](#getsupportedvideocodecs)
 * [`isRunning()`](#isrunning)
 * [`getAvailableDevices()`](#getavailabledevices)
 * [`getZoom()`](#getzoom)
@@ -392,6 +398,7 @@ Documentation for the [uploader](https://github.com/Cap-go/capacitor-uploader)
 * [`addListener('orientationChange', ...)`](#addlistenerorientationchange-)
 * [`addListener('barcodeScanned', ...)`](#addlistenerbarcodescanned-)
 * [`addListener('barcodeScanError', ...)`](#addlistenerbarcodescanerror-)
+* [`addListener('recordingFinished', ...)`](#addlistenerrecordingfinished-)
 * [`deleteFile(...)`](#deletefile)
 * [`getSafeAreaInsets()`](#getsafeareainsets)
 * [`getOrientation()`](#getorientation)
@@ -728,12 +735,12 @@ Sets the opacity of the camera preview.
 ### stopRecordVideo()
 
 ```typescript
-stopRecordVideo() => Promise<{ videoFilePath: string; }>
+stopRecordVideo() => Promise<RecordingFinishedEvent>
 ```
 
 Stops an ongoing video recording.
 
-**Returns:** <code>Promise&lt;{ videoFilePath: string; }&gt;</code>
+**Returns:** <code>Promise&lt;<a href="#recordingfinishedevent">RecordingFinishedEvent</a>&gt;</code>
 
 **Since:** 0.0.1
 
@@ -748,15 +755,109 @@ startRecordVideo(options: CameraPreviewOptions) => Promise<void>
 
 Starts recording a video.
 
-| Param         | Type                                                                  | Description                                  |
-| ------------- | --------------------------------------------------------------------- | -------------------------------------------- |
-| **`options`** | <code><a href="#camerapreviewoptions">CameraPreviewOptions</a></code> | - The options for video recording. Only iOS. |
+| Param         | Type                                                                  | Description                        |
+| ------------- | --------------------------------------------------------------------- | ---------------------------------- |
+| **`options`** | <code><a href="#camerapreviewoptions">CameraPreviewOptions</a></code> | - The options for video recording. |
 
 **Since:** 0.0.1
 
 --------------------
 
 
+### setVideoQuality(...)
+
+```typescript
+setVideoQuality(options: { quality: VideoQuality; }) => Promise<void>
+```
+
+Sets the video recording quality for the active camera session.
+
+| Param         | Type                                                                | Description                  |
+| ------------- | ------------------------------------------------------------------- | ---------------------------- |
+| **`options`** | <code>{ quality: <a href="#videoquality">VideoQuality</a>; }</code> | - The desired video quality. |
+
+**Since:** 8.5.0
+
+--------------------
+
+
+### getVideoQuality()
+
+```typescript
+getVideoQuality() => Promise<{ quality: VideoQuality; }>
+```
+
+Gets the current video recording quality.
+
+**Returns:** <code>Promise&lt;{ quality: <a href="#videoquality">VideoQuality</a>; }&gt;</code>
+
+**Since:** 8.5.0
+
+--------------------
+
+
+### getSupportedVideoQualities()
+
+```typescript
+getSupportedVideoQualities() => Promise<{ qualities: VideoQuality[]; }>
+```
+
+Returns the video qualities supported by the active camera.
+
+**Returns:** <code>Promise&lt;{ qualities: VideoQuality[]; }&gt;</code>
+
+**Since:** 8.5.0
+
+--------------------
+
+
+### setVideoCodec(...)
+
+```typescript
+setVideoCodec(options: { codec: VideoCodec; }) => Promise<void>
+```
+
+Sets the video codec used when recording.
+
+| Param         | Type                                                          | Description          |
+| ------------- | ------------------------------------------------------------- | -------------------- |
+| **`options`** | <code>{ codec: <a href="#videocodec">VideoCodec</a>; }</code> | - The desired codec. |
+
+**Since:** 8.5.0
+
+--------------------
+
+
+### getVideoCodec()
+
+```typescript
+getVideoCodec() => Promise<{ codec: VideoCodec; }>
+```
+
+Gets the current video codec used for recording.
+
+**Returns:** <code>Promise&lt;{ codec: <a href="#videocodec">VideoCodec</a>; }&gt;</code>
+
+**Since:** 8.5.0
+
+--------------------
+
+
+### getSupportedVideoCodecs()
+
+```typescript
+getSupportedVideoCodecs() => Promise<{ codecs: VideoCodec[]; }>
+```
+
+Returns the video codecs supported by the active camera.
+
+**Returns:** <code>Promise&lt;{ codecs: VideoCodec[]; }&gt;</code>
+
+**Since:** 8.5.0
+
+--------------------
+
+
 ### isRunning()
 
 ```typescript
@@ -1031,6 +1132,26 @@ Adds a listener for non-fatal barcode scanner errors.
 --------------------
 
 
+### addListener('recordingFinished', ...)
+
+```typescript
+addListener(eventName: 'recordingFinished', listenerFunc: (data: RecordingFinishedEvent) => void) => Promise<PluginListenerHandle>
+```
+
+Adds a listener fired when a video recording finishes natively, including automatic stops.
+
+| Param              | Type                                                                                         |
+| ------------------ | -------------------------------------------------------------------------------------------- |
+| **`eventName`**    | <code>'recordingFinished'</code>                                                             |
+| **`listenerFunc`** | <code>(data: <a href="#recordingfinishedevent">RecordingFinishedEvent</a>) =&gt; void</code> |
+
+**Returns:** <code>Promise&lt;<a href="#pluginlistenerhandle">PluginListenerHandle</a>&gt;</code>
+
+**Since:** 8.4.7
+
+--------------------
+
+
 ### deleteFile(...)
 
 ```typescript
@@ -1218,7 +1339,10 @@ Defines the configuration options for starting the camera preview.
 | **`positioning`**                   | <code><a href="#camerapositioning">CameraPositioning</a></code>                    | The vertical positioning of the camera preview.                                                                                                                                                                                     | <code>"center"</code>  | 2.3.0  |
 | **`enableVideoMode`**               | <code>boolean</code>                                                               | If true, enables video capture capabilities when the camera starts.                                                                                                                                                                 | <code>false</code>     | 7.11.0 |
 | **`force`**                         | <code>boolean</code>                                                               | If true, forces the camera to start/restart even if it's already running or busy. This will kill the current camera session and start a new one, ignoring all state checks.                                                         | <code>false</code>     |        |
-| **`videoQuality`**                  | <code>'low' \| 'medium' \| 'high'</code>                                           | Sets the quality of video for recording. Options: 'low', 'medium', 'high'                                                                                                                                                           | <code>"high"</code>    |        |
+| **`videoQuality`**                  | <code><a href="#videoquality">VideoQuality</a></code>                              | Sets the quality of video for recording. Options: 'low', 'medium', 'high', '2160p', '1080p', '720p', '480p', '4:3'                                                                                                                  | <code>"high"</code>    |        |
+| **`maxDuration`**                   | <code>number</code>                                                                | Maximum recording duration in seconds. Recording stops automatically when reached.                                                                                                                                                  |                        |        |
+| **`maxFileSize`**                   | <code>number</code>                                                                | Maximum recording file size in bytes. Recording stops automatically when reached.                                                                                                                                                   |                        |        |
+| **`videoCodec`**                    | <code><a href="#videocodec">VideoCodec</a></code>                                  | Preferred video codec for recording.                                                                                                                                                                                                | <code>"avc1"</code>    |        |
 | **`barcodeScanner`**                | <code>boolean \| <a href="#barcodescanneroptions">BarcodeScannerOptions</a></code> | Starts barcode scanning together with the camera preview. Set to `true` or pass options to scan all supported formats. Omit this option to keep barcode scanning disabled at startup.                                               |                        | 8.8.0  |
 
 
@@ -1310,6 +1434,14 @@ Defines the options for setting the camera preview's opacity.
 | **`opacity`** | <code>number</code> | The opacity percentage, from 0.0 (fully transparent) to 1.0 (fully opaque). | <code>1.0</code> |
 
 
+#### RecordingFinishedEvent
+
+| Prop                | Type                                                                        | Description                          |
+| ------------------- | --------------------------------------------------------------------------- | ------------------------------------ |
+| **`videoFilePath`** | <code>string</code>                                                         | The path to the recorded video file. |
+| **`reason`**        | <code><a href="#recordingfinishedreason">RecordingFinishedReason</a></code> | Why the recording stopped.           |
+
+
 #### CameraDevice
 
 Represents a physical camera on the device (e.g., the front-facing camera).
@@ -1417,6 +1549,20 @@ iOS: Values are expressed in physical pixels and exclude status bar.
 <code>'center' | 'top' | 'bottom'</code>
 
 
+#### VideoQuality
+
+<code>'low' | 'medium' | 'high' | '2160p' | '1080p' | '720p' | '480p' | '4:3'</code>
+
+
+#### VideoCodec
+
+Video codec identifiers used when recording.
+- `avc1`: H.264
+- `hvc1`: HEVC / H.265
+
+<code>'avc1' | 'hvc1' | 'jpeg' | 'apcn' | 'ap4h'</code>
+
+
 #### BarcodeScannerFormat
 
 <code>'aztec' | 'codabar' | 'code_39' | 'code_93' | 'code_128' | 'data_matrix' | 'ean_8' | 'ean_13' | 'itf' | 'pdf417' | 'qr_code' | 'upc_a' | 'upc_e'</code>
@@ -1447,6 +1593,11 @@ From T, pick a set of properties whose keys are in the union K
 <code>{
 [P in K]: T[P];
 }</code>
 
 
+#### RecordingFinishedReason
+
+<code>'manual' | 'maxDuration' | 'maxFileSize'</code>
+
+
 #### FlashMode
 
 <code><a href="#camerapreviewflashmode">CameraPreviewFlashMode</a></code>

package/android/src/main/java/app/capgo/capacitor/camera/preview/CameraPreview.java

@@ -51,6 +51,7 @@ import com.getcapacitor.annotation.PermissionCallback;
 import com.google.android.gms.location.FusedLocationProviderClient;
 import com.google.android.gms.location.LocationServices;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.List;
 import java.util.Locale;
 import java.util.Objects;
@@ -2372,6 +2373,14 @@ public class CameraPreview extends Plugin implements CameraXView.CameraXViewList
         notifyListeners("barcodeScanError", data);
     }
 
+    @Override
+    public void onVideoRecordingFinished(String filePath, String reason) {
+        JSObject data = new JSObject();
+        data.put("videoFilePath", filePath);
+        data.put("reason", reason);
+        notifyListeners("recordingFinished", data);
+    }
+
     @Override
     public void onCameraStartError(CameraXView source, String message) {
         if (cameraXView != null && cameraXView != source) {
@@ -2602,6 +2611,96 @@ public class CameraPreview extends Plugin implements CameraXView.CameraXViewList
         }
     }
 
+    @PluginMethod
+    public void setVideoQuality(PluginCall call) {
+        if (cameraXView == null || !cameraXView.isRunning()) {
+            call.reject("Camera is not running");
+            return;
+        }
+        String quality = call.getString("quality");
+        if (quality == null) {
+            call.reject("quality is required");
+            return;
+        }
+        try {
+            cameraXView.setVideoQualitySetting(quality);
+            call.resolve();
+        } catch (IllegalArgumentException e) {
+            call.reject(e.getMessage());
+        } catch (Exception e) {
+            call.reject("Failed to set video quality: " + e.getMessage());
+        }
+    }
+
+    @PluginMethod
+    public void getVideoQuality(PluginCall call) {
+        if (cameraXView == null || !cameraXView.isRunning()) {
+            call.reject("Camera is not running");
+            return;
+        }
+        JSObject ret = new JSObject();
+        ret.put("quality", cameraXView.getVideoQualitySetting());
+        call.resolve(ret);
+    }
+
+    @PluginMethod
+    public void getSupportedVideoQualities(PluginCall call) {
+        List<String> qualities = cameraXView != null
+            ? cameraXView.getSupportedVideoQualities()
+            : Arrays.asList("low", "medium", "high", "2160p", "1080p", "720p", "480p", "4:3");
+        JSONArray arr = new JSONArray();
+        for (String quality : qualities) {
+            arr.put(quality);
+        }
+        JSObject ret = new JSObject();
+        ret.put("qualities", arr);
+        call.resolve(ret);
+    }
+
+    @PluginMethod
+    public void setVideoCodec(PluginCall call) {
+        if (cameraXView == null || !cameraXView.isRunning()) {
+            call.reject("Camera is not running");
+            return;
+        }
+        String codec = call.getString("codec");
+        if (codec == null) {
+            call.reject("codec is required");
+            return;
+        }
+        try {
+            cameraXView.setVideoCodecSetting(codec);
+            call.resolve();
+        } catch (IllegalArgumentException e) {
+            call.reject(e.getMessage());
+        } catch (Exception e) {
+            call.reject("Failed to set video codec: " + e.getMessage());
+        }
+    }
+
+    @PluginMethod
+    public void getVideoCodec(PluginCall call) {
+        if (cameraXView == null || !cameraXView.isRunning()) {
+            call.reject("Camera is not running");
+            return;
+        }
+        JSObject ret = new JSObject();
+        ret.put("codec", cameraXView.getVideoCodecSetting());
+        call.resolve(ret);
+    }
+
+    @PluginMethod
+    public void getSupportedVideoCodecs(PluginCall call) {
+        List<String> codecs = cameraXView != null ? cameraXView.getSupportedVideoCodecs() : Arrays.asList("avc1");
+        JSONArray arr = new JSONArray();
+        for (String codec : codecs) {
+            arr.put(codec);
+        }
+        JSObject ret = new JSObject();
+        ret.put("codecs", arr);
+        call.resolve(ret);
+    }
+
     @PluginMethod
     public void startRecordVideo(PluginCall call) {
         if (cameraXView == null || !cameraXView.isRunning()) {
@@ -2617,7 +2716,8 @@ public class CameraPreview extends Plugin implements CameraXView.CameraXViewList
 
         if (PermissionState.GRANTED.equals(getPermissionState(permissionAlias))) {
             try {
-                cameraXView.startRecordVideo();
+                applyVideoCodecFromCall(call);
+                cameraXView.startRecordVideo(getMaxDurationMillis(call), getMaxFileSize(call));
                 call.resolve();
             } catch (Exception e) {
                 call.reject("Failed to start video recording: " + e.getMessage());
@@ -2640,11 +2740,12 @@ public class CameraPreview extends Plugin implements CameraXView.CameraXViewList
             cameraXView.stopRecordVideo(
                 new CameraXView.VideoRecordingCallback() {
                     @Override
-                    public void onSuccess(String filePath) {
+                    public void onSuccess(String filePath, String reason) {
                         PluginCall saved = bridge.getSavedCall(cbId);
                         if (saved != null) {
                             JSObject result = new JSObject();
                             result.put("videoFilePath", filePath);
+                            result.put("reason", reason);
                             saved.resolve(result);
                             bridge.releaseCall(saved);
                         }
@@ -2665,6 +2766,32 @@ public class CameraPreview extends Plugin implements CameraXView.CameraXViewList
         }
     }
 
+    private void applyVideoCodecFromCall(PluginCall call) {
+        String codec = call.getString("videoCodec");
+        if (codec != null && cameraXView != null) {
+            cameraXView.setVideoCodecSetting(codec);
+        }
+    }
+
+    private Long getMaxDurationMillis(PluginCall call) {
+        if (!call.getData().has("maxDuration") || call.getData().isNull("maxDuration")) {
+            return null;
+        }
+        double seconds = call.getData().optDouble("maxDuration", 0D);
+        if (seconds <= 0D) {
+            return null;
+        }
+        return Math.max(1L, Math.round(seconds * 1000D));
+    }
+
+    private Long getMaxFileSize(PluginCall call) {
+        if (!call.getData().has("maxFileSize") || call.getData().isNull("maxFileSize")) {
+            return null;
+        }
+        long bytes = call.getData().optLong("maxFileSize", 0L);
+        return bytes > 0L ? bytes : null;
+    }
+
     @PermissionCallback
     private void handleVideoRecordingPermissionResult(PluginCall call) {
         // Use the persisted session value to determine which permission we requested
@@ -2676,7 +2803,8 @@ public class CameraPreview extends Plugin implements CameraXView.CameraXViewList
             PermissionState.GRANTED.equals(getPermissionState(CAMERA_WITH_AUDIO_PERMISSION_ALIAS))
         ) {
             try {
-                cameraXView.startRecordVideo();
+                applyVideoCodecFromCall(call);
+                cameraXView.startRecordVideo(getMaxDurationMillis(call), getMaxFileSize(call));
                 call.resolve();
             } catch (Exception e) {
                 call.reject("Failed to start video recording: " + e.getMessage());

package/android/src/main/java/app/capgo/capacitor/camera/preview/CameraXView.java

@@ -23,6 +23,8 @@ import android.hardware.camera2.CameraManager;
 import android.hardware.camera2.CaptureRequest;
 import android.location.Location;
 import android.media.Image;
+import android.media.MediaCodecList;
+import android.media.MediaFormat;
 import android.media.MediaScannerConnection;
 import android.os.Build;
 import android.os.Environment;
@@ -128,6 +130,7 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
         void onSampleTakenError(String message);
         void onBarcodesScanned(JSONArray barcodes);
         void onBarcodeScanError(String message);
+        void onVideoRecordingFinished(String filePath, String reason);
         void onCameraStarted(int width, int height, int x, int y);
         void onCameraStartError(CameraXView source, String message);
         void onCameraStopped(CameraXView source);
@@ -139,7 +142,7 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
     }
 
     public interface VideoRecordingCallback {
-        void onSuccess(String filePath);
+        void onSuccess(String filePath, String reason);
         void onError(String message);
     }
 
@@ -1093,24 +1096,36 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
                     // Get quality from sessionConfig default to high if null
                     String videoQuality = sessionConfig.getVideoQuality() != null ? sessionConfig.getVideoQuality() : "high";
 
-                    switch (videoQuality.toLowerCase()) {
-                        case "low":
-                            // Target SD, allow falling back to lower if needed
+                    switch (videoQuality.toLowerCase(Locale.US)) {
+                        case "2160p":
                             qualitySelector = QualitySelector.fromOrderedList(
-                                Arrays.asList(Quality.SD, Quality.LOWEST),
-                                FallbackStrategy.lowerQualityOrHigherThan(Quality.SD)
+                                Arrays.asList(Quality.UHD, Quality.FHD, Quality.HD, Quality.SD),
+                                FallbackStrategy.lowerQualityOrHigherThan(Quality.UHD)
                             );
                             break;
+                        case "1080p":
+                            qualitySelector = QualitySelector.fromOrderedList(
+                                Arrays.asList(Quality.FHD, Quality.HD, Quality.SD),
+                                FallbackStrategy.higherQualityOrLowerThan(Quality.FHD)
+                            );
+                            break;
+                        case "720p":
                         case "medium":
-                            // Target HD, allow falling back to SD
                             qualitySelector = QualitySelector.fromOrderedList(
                                 Arrays.asList(Quality.HD, Quality.SD),
                                 FallbackStrategy.lowerQualityOrHigherThan(Quality.HD)
                             );
                             break;
+                        case "480p":
+                        case "low":
+                            qualitySelector = QualitySelector.fromOrderedList(
+                                Arrays.asList(Quality.SD, Quality.LOWEST),
+                                FallbackStrategy.lowerQualityOrHigherThan(Quality.SD)
+                            );
+                            break;
                         case "high":
+                        case "4:3":
                         default:
-                            // Target FHD allow falling back SD
                             qualitySelector = QualitySelector.fromOrderedList(
                                 Arrays.asList(Quality.FHD, Quality.HD, Quality.SD),
                                 FallbackStrategy.higherQualityOrLowerThan(Quality.FHD)
@@ -1118,7 +1133,12 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
                             break;
                     }
 
-                    Recorder recorder = new Recorder.Builder().setQualitySelector(qualitySelector).build();
+                    Recorder.Builder recorderBuilder = new Recorder.Builder().setQualitySelector(qualitySelector);
+                    String videoCodec = sessionConfig.getVideoCodec() != null ? sessionConfig.getVideoCodec() : "avc1";
+                    if ("hvc1".equalsIgnoreCase(videoCodec)) {
+                        recorderBuilder.setVideoCapabilitiesSource(Recorder.VIDEO_CAPABILITIES_SOURCE_CODEC_CAPABILITIES);
+                    }
+                    Recorder recorder = recorderBuilder.build();
                     videoCapture = VideoCapture.withOutput(recorder);
                 }
 
@@ -4644,7 +4664,7 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
     }
 
     /** @noinspection ResultOfMethodCallIgnored*/
-    public void startRecordVideo() throws Exception {
+    public void startRecordVideo(Long maxDurationMillis, Long maxFileSize) throws Exception {
         if (videoCapture == null) {
             throw new Exception("VideoCapture is not initialized");
         }
@@ -4666,7 +4686,14 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
         }
         currentVideoFile = new File(outputDir, fileName);
 
-        FileOutputOptions outputOptions = new FileOutputOptions.Builder(currentVideoFile).build();
+        FileOutputOptions.Builder outputOptionsBuilder = new FileOutputOptions.Builder(currentVideoFile);
+        if (maxDurationMillis != null && maxDurationMillis > 0) {
+            outputOptionsBuilder.setDurationLimitMillis(maxDurationMillis);
+        }
+        if (maxFileSize != null && maxFileSize > 0) {
+            outputOptionsBuilder.setFileSizeLimit(maxFileSize);
+        }
+        FileOutputOptions outputOptions = outputOptionsBuilder.build();
 
         // Create recording event listener
         androidx.core.util.Consumer<VideoRecordEvent> videoRecordEventListener = (videoRecordEvent) -> {
@@ -4712,11 +4739,18 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
     }
 
     private void handleRecordingFinalized(VideoRecordEvent.Finalize finalizeEvent) {
-        if (!finalizeEvent.hasError()) {
-            Log.d(TAG, "Video recording completed successfully");
+        String reason = getRecordingFinishReason(finalizeEvent.getError());
+        boolean hasVideoFile = currentVideoFile != null && currentVideoFile.exists();
+        boolean finishedWithUsableFile = !finalizeEvent.hasError() || isRecordingLimitReached(finalizeEvent.getError());
+
+        if (finishedWithUsableFile && hasVideoFile) {
+            String filePath = "file://" + currentVideoFile.getAbsolutePath();
+            Log.d(TAG, "Video recording completed: " + reason);
             if (currentVideoCallback != null) {
-                String filePath = "file://" + currentVideoFile.getAbsolutePath();
-                currentVideoCallback.onSuccess(filePath);
+                currentVideoCallback.onSuccess(filePath, reason);
+            }
+            if (listener != null) {
+                listener.onVideoRecordingFinished(filePath, reason);
             }
         } else {
             Log.e(TAG, "Video recording failed: " + finalizeEvent.getError());
@@ -4730,4 +4764,104 @@ public class CameraXView implements LifecycleOwner, LifecycleObserver {
         currentVideoFile = null;
         currentVideoCallback = null;
     }
+
+    private boolean isRecordingLimitReached(int error) {
+        return (
+            error == VideoRecordEvent.Finalize.ERROR_DURATION_LIMIT_REACHED ||
+            error == VideoRecordEvent.Finalize.ERROR_FILE_SIZE_LIMIT_REACHED
+        );
+    }
+
+    private String getRecordingFinishReason(int error) {
+        if (error == VideoRecordEvent.Finalize.ERROR_DURATION_LIMIT_REACHED) {
+            return "maxDuration";
+        }
+        if (error == VideoRecordEvent.Finalize.ERROR_FILE_SIZE_LIMIT_REACHED) {
+            return "maxFileSize";
+        }
+        return "manual";
+    }
+
+    private static final List<String> ALL_VIDEO_QUALITIES = Arrays.asList("low", "medium", "high", "2160p", "1080p", "720p", "480p", "4:3");
+
+    private static final List<String> ALL_VIDEO_CODECS = Arrays.asList("avc1", "hvc1");
+
+    public String getVideoQualitySetting() {
+        if (sessionConfig == null) {
+            return "high";
+        }
+        return sessionConfig.getVideoQuality();
+    }
+
+    public void setVideoQualitySetting(String quality) {
+        if (sessionConfig == null) {
+            throw new IllegalStateException("Camera session is not running");
+        }
+        String normalized = quality != null ? quality.toLowerCase(Locale.US) : "high";
+        if (!ALL_VIDEO_QUALITIES.contains(normalized)) {
+            throw new IllegalArgumentException("Unsupported video quality: " + quality);
+        }
+        if (normalized.equals(sessionConfig.getVideoQuality())) {
+            return;
+        }
+        sessionConfig.setVideoQuality(normalized);
+        if (sessionConfig.isVideoModeEnabled() && isRunning) {
+            mainExecutor.execute(this::bindCameraUseCases);
+        }
+    }
+
+    public List<String> getSupportedVideoQualities() {
+        return new ArrayList<>(ALL_VIDEO_QUALITIES);
+    }
+
+    public String getVideoCodecSetting() {
+        if (sessionConfig == null) {
+            return "avc1";
+        }
+        return sessionConfig.getVideoCodec();
+    }
+
+    public void setVideoCodecSetting(String codec) {
+        if (sessionConfig == null) {
+            throw new IllegalStateException("Camera session is not running");
+        }
+        String normalized = codec != null ? codec.toLowerCase(Locale.US) : "avc1";
+        if (!ALL_VIDEO_CODECS.contains(normalized)) {
+            throw new IllegalArgumentException("Unsupported video codec: " + codec);
+        }
+        if (normalized.equals(sessionConfig.getVideoCodec())) {
+            return;
+        }
+        sessionConfig.setVideoCodec(normalized);
+        if (sessionConfig.isVideoModeEnabled() && isRunning) {
+            mainExecutor.execute(this::bindCameraUseCases);
+        }
+    }
+
+    public List<String> getSupportedVideoCodecs() {
+        List<String> codecs = new ArrayList<>();
+        codecs.add("avc1");
+        if (isVideoCodecSupported(MediaFormat.MIMETYPE_VIDEO_HEVC)) {
+            codecs.add("hvc1");
+        }
+        return codecs;
+    }
+
+    private boolean isVideoCodecSupported(String mimeType) {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP) {
+            return false;
+        }
+        MediaCodecList codecList = new MediaCodecList(MediaCodecList.REGULAR_CODECS);
+        for (android.media.MediaCodecInfo codecInfo : codecList.getCodecInfos()) {
+            if (!codecInfo.isEncoder()) {
+                continue;
+            }
+            for (String type : codecInfo.getSupportedTypes()) {
+                if (mimeType.equalsIgnoreCase(type)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
 }