tauri-plugin-camera-kessdev 0.2.0-beta.0 → 0.2.0-beta.2

package/README.md

@@ -2,7 +2,8 @@
 
 A [Tauri v2](https://v2.tauri.app) plugin that provides a **unified JavaScript API** for
 camera access across Android, iOS and desktop. It supports live preview, photo capture,
-video recording (with audio), camera controls (front/back, flash, zoom), saving to the
+video recording (with audio), camera controls (front/back, flash, zoom), camera
+introspection (list the available cameras and query their capabilities), saving to the
 photo gallery, and camera permission management.
 
 | Platform | Supported |
@@ -25,7 +26,7 @@ Add the Rust crate to `src-tauri/Cargo.toml`:
 
 ```toml
 [dependencies]
-tauri-plugin-camera-kessdev = "0.1.0"
+tauri-plugin-camera-kessdev = "0.2.0-beta.0"   # beta
 # or from a git/path source:
 # tauri-plugin-camera-kessdev = { path = "../tauri-plugin-camera" }
 ```
@@ -61,15 +62,16 @@ Add the default permission set to `src-tauri/capabilities/default.json`:
 {
   "permissions": [
     "core:default",
-    "camera:default"
+    "camera-kessdev:default"
   ]
 }
 ```
 
 To allow only specific commands, use the granular permissions instead of
-`camera:default` (e.g. `camera:allow-capture`, `camera:allow-start-recording`,
-`camera:allow-check-permissions`, …). The full list is generated under
-`permissions/autogenerated/commands/` as `allow-<command>` / `deny-<command>`.
+`camera-kessdev:default` (e.g. `camera-kessdev:allow-capture`,
+`camera-kessdev:allow-start-recording`, `camera-kessdev:allow-check-permissions`, …).
+The full list is generated under `permissions/autogenerated/commands/` as
+`allow-<command>` / `deny-<command>`.
 
 ### Android
 
@@ -135,6 +137,7 @@ import {
   saveToGallery,
   checkPermissions,
   requestPermissions,
+  openAppSettings,
   getPreviewStream,
   convertFileSrc
 } from 'tauri-plugin-camera-kessdev'
@@ -146,6 +149,10 @@ import {
 // windowed: true keeps the webview transparent so your UI renders over the camera.
 await startPreview({ camera: 'back', windowed: true })
 
+// Or pick a specific lens by id (from getAvailableCameras()); cameraId takes precedence.
+const cameras = await getAvailableCameras()
+await startPreview({ cameraId: cameras[0].id })
+
 // Desktop: attach the stream to a <video> element.
 const stream = await getPreviewStream()
 if (stream) videoEl.srcObject = stream
@@ -164,6 +171,17 @@ const photo = await capture({ flash: 'auto' })
 imageEl.src = convertFileSrc(photo.path)
 ```
 
+Configurable (mobile and desktop):
+
+```ts
+await capture({
+  resolution: { width: 1920, height: 1080 }, // nearest supported size (best-effort)
+  aspectRatio: '16:9',                        // '4:3' | '16:9' | '1:1' | ...
+  format: 'jpeg',                             // 'jpeg' | 'png' | 'heif' (mobile jpeg; desktop jpeg/png)
+  quality: 0.9                                // 0..1 for lossy formats
+})
+```
+
 ### Video recording (with audio)
 
 ```ts
@@ -175,8 +193,16 @@ const video = await stopRecording()
 // Optionally request a base64 JPEG thumbnail of the recording:
 const withThumbnail = await stopRecording({ thumbnail: true })
 // withThumbnail.thumbnail: string | undefined
+
+// Configure quality/fps/bitrate (mobile and desktop):
+await startRecording({ quality: 'fhd', fps: 30, bitrate: 2_000_000 }) // quality: 'sd' | 'hd' | 'fhd' | 'uhd'
 ```
 
+On desktop the preview stays alive during recording: the recording reuses the
+preview's video track (only the microphone is acquired separately), so the
+`<video>` element bound to `getPreviewStream()` keeps playing. The recording
+mime type is chosen from the browser's supported types (WebM or MP4).
+
 ### Video thumbnail
 
 Pass `{ thumbnail: true }` to `stopRecording()` to include a base64-encoded JPEG
@@ -240,6 +266,31 @@ const zoom = await getZoom() // number
 On desktop `getZoom()` rejects with a descriptive error (consistent with
 `setZoom`).
 
+### Fine controls
+
+Torch, tap-to-focus, exposure and white balance (mobile; desktop throws):
+
+```ts
+await setTorch(true)                 // continuous light (independent from capture flash)
+await setFocusPoint(0.5, 0.5)        // normalized 0..1, top-left origin
+await setFocusMode('continuous')     // 'auto' | 'continuous' | 'locked'
+await setExposureCompensation(1.5)   // EV, clamped to getCapabilities().exposureRange
+await setExposureMode('locked')      // 'auto' | 'locked'
+await setWhiteBalance({ mode: 'locked', temperatureK: 5000 })  // Kelvin; 'auto' | 'locked'
+```
+
+Details:
+
+- **Torch** is independent from the capture flash (`setFlash`); query `hasTorch`.
+- **Focus** uses normalized coordinates (0..1, top-left origin); query `supportsFocus` / `focusModes`.
+- **Exposure**: `ev` is clamped to `exposureRange`; `exposureModes` is `['auto', 'locked']`.
+- **White balance** is uniform across platforms: `mode: 'auto' | 'locked'`. In `locked`, `temperatureK` (Kelvin) is applied where the hardware supports it (`supportsWhiteBalanceTemperature`); when unsupported, the plugin locks the current gains (or rejects) instead of inventing a temperature. `auto` uses the platform's continuous AWB.
+
+On desktop all of these controls reject with a descriptive error. Query the
+supported values with `getCapabilities()` first: `hasTorch`,
+`supportsFocus`/`focusModes`, `exposureRange`/`exposureModes`,
+`whiteBalanceModes`/`supportsWhiteBalanceTemperature`.
+
 ### Camera introspection
 
 Use `getAvailableCameras()` to list the cameras (physical/logical lenses) and
@@ -252,7 +303,8 @@ const cameras = await getAvailableCameras()
 // No argument: the active camera, or the default (back) camera without a preview.
 const caps = await getCapabilities(cameras[0].id)
 // { cameraId, hasFlash, hasTorch, zoomRange?, supportsFocus, focusModes?,
-//   photoFormats?, supportsPause }
+//   exposureRange?, exposureModes?, whiteBalanceModes?, supportsWhiteBalanceTemperature?,
+//   photoResolutions?, photoAspects?, videoQualities?, videoFps?, photoFormats?, supportsPause }
 ```
 
 The plugin follows one rule to avoid ambiguity:
@@ -282,6 +334,9 @@ webm, 3gp, mkv are treated as video); pass `{ type }` to force it.
 ```ts
 const state = await checkPermissions()   // 'granted' | 'denied' | 'prompt'
 await requestPermissions()
+
+// Mobile: open the OS settings screen (e.g. after a permanent denial).
+await openAppSettings()
 ```
 
 ## Image return pattern
@@ -305,7 +360,7 @@ hardware, emulator or device is required.
 | Rust    | `src/models.rs` (inline tests)             | `cargo test`   | plugin root         | Rust + Cargo                      |
 | JS      | `guest-js/index.test.ts`                   | `npm test`     | plugin root         | Node.js 18+ + npm                 |
 | Android | `android/src/test/java/CameraPluginTest.kt`| `gradle test`  | `android/` (or generated app) | JDK 17+, Android SDK, Gradle |
-| iOS     | `ios/Tests/PluginTests/PluginTests.swift`  | `swift test`   | `ios/`              | macOS + Xcode                     |
+| iOS     | `ios/Tests/PluginTests/PluginTests.swift`  | `xcodebuild test` | iOS Simulator (generated app) | macOS + Xcode                     |
 
 ### Prerequisites
 
@@ -417,6 +472,12 @@ destination from the generated Xcode project (`src-tauri/gen/apple`).
 | `setFlash(mode)` | ✓ | ✗ (throws) |
 | `setZoom(factor)` | ✓ | ✗ (throws) |
 | `getZoom()` | ✓ | ✗ (throws) |
+| `setTorch(on)` | ✓ | ✗ (throws) |
+| `setFocusPoint(x, y)` | ✓ | ✗ (throws) |
+| `setFocusMode(mode)` | ✓ | ✗ (throws) |
+| `setExposureCompensation(ev)` | ✓ | ✗ (throws) |
+| `setExposureMode(mode)` | ✓ | ✗ (throws) |
+| `setWhiteBalance(options)` | ✓ | ✗ (throws) |
 | `getAvailableCameras()` | ✓ | ✓ |
 | `getCapabilities(cameraId?)` | ✓ | ✓ (partial) |
 | `startRecording(options?)` | ✓ `VideoCapture` / `AVCaptureMovieFileOutput` | ✓ `MediaRecorder` |
@@ -428,3 +489,88 @@ destination from the generated Xcode project (`src-tauri/gen/apple`).
 | `requestPermissions()` | ✓ | ✓ |
 | `openAppSettings()` | ✓ | ✗ (throws) |
 | `getPreviewStream()` | `null` | `MediaStream` |
+
+## Types
+
+```ts
+type CameraDirection = 'front' | 'back'
+type FlashMode = 'on' | 'off' | 'auto'
+type CameraFacing = 'front' | 'back' | 'external'
+type CameraLens = 'wide' | 'ultraWide' | 'telephoto' | (string & {})
+type FocusMode = 'auto' | 'continuous' | 'locked'
+type ExposureMode = 'auto' | 'locked'
+type WhiteBalanceMode = 'auto' | 'locked'
+type PhotoFormat = 'jpeg' | 'png' | 'heif'
+type VideoQuality = 'sd' | 'hd' | 'fhd' | 'uhd'
+type PermissionState = 'granted' | 'denied' | 'prompt'  // re-exported from @tauri-apps/api/core
+
+interface StartPreviewOptions { camera?: CameraDirection; cameraId?: string; windowed?: boolean }
+interface CaptureOptions {
+  flash?: FlashMode
+  resolution?: Resolution
+  aspectRatio?: string
+  format?: PhotoFormat
+  quality?: number
+}
+interface Resolution { width: number; height: number }
+interface ExposureRange { minEv: number; maxEv: number }
+interface WhiteBalanceOptions { mode: WhiteBalanceMode; temperatureK?: number }
+
+interface Photo {
+  path?: string          // mobile: absolute path to the captured file
+  dataUrl?: string       // desktop: base64 data URL
+  blob?: Blob            // desktop
+  width: number
+  height: number
+  orientation: number    // EXIF orientation
+  format: string
+  thumbnail?: string     // base64 JPEG thumbnail (mobile; desktop reuses dataUrl)
+}
+
+interface Video {
+  path?: string          // mobile
+  duration: number
+  blob?: Blob            // desktop
+  url?: string           // desktop object URL
+  thumbnail?: string     // base64 JPEG when requested via stopRecording({ thumbnail: true })
+}
+
+interface ZoomRange { min: number; max: number }
+
+interface CameraInfo {
+  id: string             // native, session-stable identifier
+  facing?: CameraFacing
+  lens?: CameraLens
+  label?: string
+}
+
+interface CameraCapabilities {
+  cameraId?: string
+  hasFlash: boolean
+  hasTorch: boolean
+  zoomRange?: ZoomRange
+  supportsFocus: boolean
+  focusModes?: string[]
+  exposureRange?: ExposureRange
+  exposureModes?: ExposureMode[]
+  whiteBalanceModes?: WhiteBalanceMode[]
+  supportsWhiteBalanceTemperature?: boolean
+  photoResolutions?: Resolution[]
+  photoAspects?: string[]
+  videoQualities?: VideoQuality[]
+  videoFps?: number[]
+  photoFormats?: string[]
+  supportsPause: boolean
+}
+
+interface RecordingProgress { duration: number; bytesRecorded?: number; bitrate?: number }
+
+interface StartRecordingOptions {
+  onProgress?: Channel<RecordingProgress>
+  quality?: VideoQuality
+  fps?: number
+  bitrate?: number
+}
+interface StopRecordingOptions { thumbnail?: boolean }
+interface SaveToGalleryOptions { type?: 'image' | 'video' }
+```

package/dist-js/index.cjs

@@ -18,6 +18,7 @@ function isMobile() {
 let activeStream = null;
 let activeVideo = null;
 let mediaRecorder = null;
+let recordingAudioStream = null;
 let recordedChunks = [];
 let recordedBytes = 0;
 let recordingStartedAt = 0;
@@ -26,10 +27,28 @@ let progressTimer = null;
 const RECORDING_PROGRESS_INTERVAL_MS = 250;
 /** Ask MediaRecorder for data chunks at least this often so size is known live. */
 const RECORDING_TIMESLICE_MS = 1000;
+/** Picks an explicit recording mime type supported by this browser, if any. */
+function pickDesktopRecordingMimeType() {
+    if (typeof MediaRecorder === 'undefined' || typeof MediaRecorder.isTypeSupported !== 'function') {
+        return undefined;
+    }
+    const candidates = [
+        'video/webm;codecs=vp9,opus',
+        'video/webm;codecs=vp8,opus',
+        'video/webm',
+        'video/mp4'
+    ];
+    return candidates.find((type) => MediaRecorder.isTypeSupported(type));
+}
 function buildRecordingProgress(duration, bytes) {
-    const progress = { duration, bytesRecorded: bytes };
-    if (duration > 0) {
-        progress.bitrate = Math.round((bytes * 8) / duration);
+    // Omit the size-derived fields until a real chunk has arrived, matching the
+    // mobile backends (do not report a misleading 0).
+    const progress = { duration };
+    if (bytes > 0) {
+        progress.bytesRecorded = bytes;
+        if (duration > 0) {
+            progress.bitrate = Math.round((bytes * 8) / duration);
+        }
     }
     return progress;
 }
@@ -48,12 +67,14 @@ function stopProgressTimer() {
 async function ensureDesktopStream(options) {
     if (activeStream)
         return activeStream;
-    const constraints = {
-        video: {
-            facingMode: options?.camera === 'front' ? 'user' : 'environment'
-        },
-        audio: false
-    };
+    const videoConstraints = {};
+    if (options?.cameraId) {
+        videoConstraints.deviceId = { exact: options.cameraId };
+    }
+    else {
+        videoConstraints.facingMode = options?.camera === 'front' ? 'user' : 'environment';
+    }
+    const constraints = { video: videoConstraints, audio: false };
     const stream = await navigator.mediaDevices.getUserMedia(constraints);
     activeStream = stream;
     const video = document.createElement('video');
@@ -70,6 +91,8 @@ function teardownDesktopStream() {
         mediaRecorder.stop();
     }
     mediaRecorder = null;
+    recordingAudioStream?.getTracks().forEach((t) => t.stop());
+    recordingAudioStream = null;
     recordedChunks = [];
     recordedBytes = 0;
     if (activeStream) {
@@ -78,12 +101,55 @@ function teardownDesktopStream() {
     activeStream = null;
     activeVideo = null;
 }
-function captureDesktopFrame() {
+/** Parses an aspect ratio like '4:3' into a number (4/3), or null. */
+function parseAspectRatio(value) {
+    const [w, h] = value.split(':').map((n) => Number(n));
+    if (!w || !h)
+        return null;
+    return w / h;
+}
+/** Target capture height (px) for a video quality preset (desktop best-effort). */
+function qualityHeight(quality) {
+    switch (quality) {
+        case 'sd':
+            return 480;
+        case 'hd':
+            return 720;
+        case 'fhd':
+            return 1080;
+        case 'uhd':
+            return 2160;
+    }
+}
+/** MIME type for a photo format on desktop, or null when unsupported. */
+function desktopPhotoMime(format) {
+    switch (format) {
+        case 'jpeg':
+            return 'image/jpeg';
+        case 'png':
+            return 'image/png';
+        default:
+            return null;
+    }
+}
+function captureDesktopFrame(options) {
     if (!activeVideo) {
         throw new Error('Camera preview is not active. Call startPreview() first.');
     }
-    const width = activeVideo.videoWidth;
-    const height = activeVideo.videoHeight;
+    const format = options?.format ?? 'jpeg';
+    const mime = desktopPhotoMime(format);
+    if (!mime) {
+        throw new Error(`${format} is not supported on desktop.`);
+    }
+    const sourceWidth = activeVideo.videoWidth;
+    const sourceHeight = activeVideo.videoHeight;
+    let width = options?.resolution?.width ?? sourceWidth;
+    let height = options?.resolution?.height ?? sourceHeight;
+    if (!options?.resolution && options?.aspectRatio) {
+        const ratio = parseAspectRatio(options.aspectRatio);
+        if (ratio)
+            height = Math.round(width / ratio);
+    }
     const canvas = document.createElement('canvas');
     canvas.width = width;
     canvas.height = height;
@@ -92,13 +158,13 @@ function captureDesktopFrame() {
         throw new Error('Failed to create canvas context for capture.');
     }
     ctx.drawImage(activeVideo, 0, 0, width, height);
-    const dataUrl = canvas.toDataURL('image/jpeg');
+    const dataUrl = canvas.toDataURL(mime, options?.quality);
     return {
         dataUrl,
         width,
         height,
         orientation: 1,
-        format: 'jpeg',
+        format,
         thumbnail: dataUrl
     };
 }
@@ -152,7 +218,7 @@ async function capture(options) {
     if (isMobile()) {
         return await core.invoke('plugin:camera-kessdev|capture', { ...options });
     }
-    return captureDesktopFrame();
+    return captureDesktopFrame(options);
 }
 // ---------------------------------------------------------------------------
 // Camera controls
@@ -273,6 +339,57 @@ async function getCapabilities(cameraId) {
     return desktopCapabilities(cameraId);
 }
 // ---------------------------------------------------------------------------
+// Fine controls (torch, focus, exposure, white balance)
+// ---------------------------------------------------------------------------
+/** Turns the torch (continuous light) on or off (mobile). */
+async function setTorch(on) {
+    if (isMobile()) {
+        await core.invoke('plugin:camera-kessdev|set_torch', { on });
+        return;
+    }
+    throw new Error('setTorch is not supported on desktop.');
+}
+/** Sets the focus point in normalized coordinates (0..1, top-left origin) (mobile). */
+async function setFocusPoint(x, y) {
+    if (isMobile()) {
+        await core.invoke('plugin:camera-kessdev|set_focus_point', { x, y });
+        return;
+    }
+    throw new Error('setFocusPoint is not supported on desktop.');
+}
+/** Sets the focus mode (mobile). */
+async function setFocusMode(mode) {
+    if (isMobile()) {
+        await core.invoke('plugin:camera-kessdev|set_focus_mode', { mode });
+        return;
+    }
+    throw new Error('setFocusMode is not supported on desktop.');
+}
+/** Sets the exposure compensation in EV (mobile). */
+async function setExposureCompensation(ev) {
+    if (isMobile()) {
+        await core.invoke('plugin:camera-kessdev|set_exposure_compensation', { ev });
+        return;
+    }
+    throw new Error('setExposureCompensation is not supported on desktop.');
+}
+/** Sets the exposure mode (mobile). */
+async function setExposureMode(mode) {
+    if (isMobile()) {
+        await core.invoke('plugin:camera-kessdev|set_exposure_mode', { mode });
+        return;
+    }
+    throw new Error('setExposureMode is not supported on desktop.');
+}
+/** Sets the white balance mode (with an optional Kelvin temperature when `locked`) (mobile). */
+async function setWhiteBalance(options) {
+    if (isMobile()) {
+        await core.invoke('plugin:camera-kessdev|set_white_balance', { ...options });
+        return;
+    }
+    throw new Error('setWhiteBalance is not supported on desktop.');
+}
+// ---------------------------------------------------------------------------
 // Video recording
 // ---------------------------------------------------------------------------
 /** Starts video recording (with audio). */
@@ -281,22 +398,44 @@ async function startRecording(options) {
         await core.invoke('plugin:camera-kessdev|start_recording', { ...options });
         return;
     }
-    if (activeStream) {
-        activeStream.getTracks().forEach((t) => t.stop());
-        activeStream = null;
-        activeVideo = null;
+    // Reuse the active preview video track when possible so the preview is not
+    // invalidated (which would freeze the app's <video> element).
+    let videoTrack = activeStream?.getVideoTracks()[0];
+    if (!videoTrack) {
+        const videoConstraints = {};
+        if (options?.quality)
+            videoConstraints.height = { ideal: qualityHeight(options.quality) };
+        if (options?.fps)
+            videoConstraints.frameRate = { ideal: options.fps };
+        const videoStream = await navigator.mediaDevices.getUserMedia({
+            video: videoConstraints,
+            audio: false
+        });
+        activeStream = videoStream;
+        videoTrack = videoStream.getVideoTracks()[0];
+    }
+    if (!videoTrack) {
+        throw new Error('No video track available for recording.');
     }
-    const stream = await navigator.mediaDevices.getUserMedia({ video: true, audio: true });
-    activeStream = stream;
-    const video = document.createElement('video');
-    video.muted = true;
-    video.playsInline = true;
-    video.srcObject = stream;
-    await video.play();
-    activeVideo = video;
+    if (!activeVideo) {
+        const video = document.createElement('video');
+        video.muted = true;
+        video.playsInline = true;
+        video.srcObject = activeStream;
+        await video.play();
+        activeVideo = video;
+    }
+    recordingAudioStream = await navigator.mediaDevices.getUserMedia({ audio: true });
+    const recordStream = new MediaStream([videoTrack, ...recordingAudioStream.getAudioTracks()]);
     recordedChunks = [];
     recordedBytes = 0;
-    mediaRecorder = new MediaRecorder(stream);
+    const recorderOptions = {};
+    if (options?.bitrate)
+        recorderOptions.videoBitsPerSecond = options.bitrate;
+    const mimeType = pickDesktopRecordingMimeType();
+    if (mimeType)
+        recorderOptions.mimeType = mimeType;
+    mediaRecorder = new MediaRecorder(recordStream, recorderOptions);
     mediaRecorder.ondataavailable = (event) => {
         if (event.data.size > 0) {
             recordedChunks.push(event.data);
@@ -331,9 +470,12 @@ async function stopRecording(options) {
     stopProgressTimer();
     return await new Promise((resolve, reject) => {
         mediaRecorder.onstop = () => {
-            const type = mediaRecorder.mimeType || 'video/webm';
+            const mimeType = mediaRecorder.mimeType || 'video/webm';
+            const type = mimeType.split(';')[0];
             const blob = new Blob(recordedChunks, { type });
             const url = URL.createObjectURL(blob);
+            recordingAudioStream?.getTracks().forEach((t) => t.stop());
+            recordingAudioStream = null;
             recordedChunks = [];
             recordedBytes = 0;
             mediaRecorder = null;
@@ -436,7 +578,13 @@ exports.getZoom = getZoom;
 exports.openAppSettings = openAppSettings;
 exports.requestPermissions = requestPermissions;
 exports.saveToGallery = saveToGallery;
+exports.setExposureCompensation = setExposureCompensation;
+exports.setExposureMode = setExposureMode;
 exports.setFlash = setFlash;
+exports.setFocusMode = setFocusMode;
+exports.setFocusPoint = setFocusPoint;
+exports.setTorch = setTorch;
+exports.setWhiteBalance = setWhiteBalance;
 exports.setZoom = setZoom;
 exports.startPreview = startPreview;
 exports.startRecording = startRecording;

package/dist-js/index.d.ts

@@ -6,10 +6,27 @@ export type CameraDirection = 'front' | 'back';
 export type FlashMode = 'on' | 'off' | 'auto';
 export interface StartPreviewOptions {
     camera?: CameraDirection;
+    /** Specific camera/lens id from `getAvailableCameras()`. Takes precedence over `camera`. */
+    cameraId?: string;
     windowed?: boolean;
 }
+export type PhotoFormat = 'jpeg' | 'png' | 'heif';
+export type VideoQuality = 'sd' | 'hd' | 'fhd' | 'uhd';
+/** A width/height pair in pixels. */
+export interface Resolution {
+    width: number;
+    height: number;
+}
 export interface CaptureOptions {
     flash?: FlashMode;
+    /** Target resolution (best-effort: the nearest supported is used). */
+    resolution?: Resolution;
+    /** Target aspect ratio (e.g. '4:3', '16:9', '1:1'). */
+    aspectRatio?: string;
+    /** Image format. Mobile supports `jpeg`; desktop `jpeg`/`png`. */
+    format?: PhotoFormat;
+    /** Compression quality (0..1) for lossy formats. */
+    quality?: number;
 }
 export interface Photo {
     /** Absolute path to the captured image (mobile). */
@@ -49,6 +66,23 @@ export type CameraFacing = 'front' | 'back' | 'external';
  * determine it (notably desktop) omit the field.
  */
 export type CameraLens = 'wide' | 'ultraWide' | 'telephoto' | (string & {});
+/** Camera focus mode. */
+export type FocusMode = 'auto' | 'continuous' | 'locked';
+/** Camera exposure mode. */
+export type ExposureMode = 'auto' | 'locked';
+/** White balance mode. */
+export type WhiteBalanceMode = 'auto' | 'locked';
+/** Supported exposure compensation range (EV). */
+export interface ExposureRange {
+    minEv: number;
+    maxEv: number;
+}
+/** Options for `setWhiteBalance`. */
+export interface WhiteBalanceOptions {
+    mode: WhiteBalanceMode;
+    /** Color temperature in Kelvin; only meaningful when `mode` is `locked`. */
+    temperatureK?: number;
+}
 /** A camera (physical or logical lens) available on the device. */
 export interface CameraInfo {
     /** Native, session-stable identifier (usable to reference this camera). */
@@ -75,6 +109,15 @@ export interface CameraCapabilities {
     zoomRange?: ZoomRange;
     supportsFocus: boolean;
     focusModes?: string[];
+    exposureRange?: ExposureRange;
+    exposureModes?: ExposureMode[];
+    whiteBalanceModes?: WhiteBalanceMode[];
+    /** Whether an arbitrary color temperature (Kelvin) can be applied. */
+    supportsWhiteBalanceTemperature?: boolean;
+    photoResolutions?: Resolution[];
+    photoAspects?: string[];
+    videoQualities?: VideoQuality[];
+    videoFps?: number[];
     photoFormats?: string[];
     supportsPause: boolean;
 }
@@ -96,6 +139,12 @@ export interface RecordingProgress {
 export interface StartRecordingOptions {
     /** Receives live recording telemetry while the recording is active. */
     onProgress?: Channel<RecordingProgress>;
+    /** Video quality preset. */
+    quality?: VideoQuality;
+    /** Target frame rate. */
+    fps?: number;
+    /** Target bitrate in bits per second. */
+    bitrate?: number;
 }
 export interface StopRecordingOptions {
     /** When true, the result includes a base64-encoded `thumbnail`. */
@@ -154,6 +203,18 @@ export declare function getAvailableCameras(): Promise<CameraInfo[]>;
  * Live values are exposed by dedicated getters (e.g. {@link getZoom}).
  */
 export declare function getCapabilities(cameraId?: string): Promise<CameraCapabilities>;
+/** Turns the torch (continuous light) on or off (mobile). */
+export declare function setTorch(on: boolean): Promise<void>;
+/** Sets the focus point in normalized coordinates (0..1, top-left origin) (mobile). */
+export declare function setFocusPoint(x: number, y: number): Promise<void>;
+/** Sets the focus mode (mobile). */
+export declare function setFocusMode(mode: FocusMode): Promise<void>;
+/** Sets the exposure compensation in EV (mobile). */
+export declare function setExposureCompensation(ev: number): Promise<void>;
+/** Sets the exposure mode (mobile). */
+export declare function setExposureMode(mode: ExposureMode): Promise<void>;
+/** Sets the white balance mode (with an optional Kelvin temperature when `locked`) (mobile). */
+export declare function setWhiteBalance(options: WhiteBalanceOptions): Promise<void>;
 /** Starts video recording (with audio). */
 export declare function startRecording(options?: StartRecordingOptions): Promise<void>;
 /** Stops video recording and returns the recorded media. */

package/dist-js/index.js

@@ -17,6 +17,7 @@ function isMobile() {
 let activeStream = null;
 let activeVideo = null;
 let mediaRecorder = null;
+let recordingAudioStream = null;
 let recordedChunks = [];
 let recordedBytes = 0;
 let recordingStartedAt = 0;
@@ -25,10 +26,28 @@ let progressTimer = null;
 const RECORDING_PROGRESS_INTERVAL_MS = 250;
 /** Ask MediaRecorder for data chunks at least this often so size is known live. */
 const RECORDING_TIMESLICE_MS = 1000;
+/** Picks an explicit recording mime type supported by this browser, if any. */
+function pickDesktopRecordingMimeType() {
+    if (typeof MediaRecorder === 'undefined' || typeof MediaRecorder.isTypeSupported !== 'function') {
+        return undefined;
+    }
+    const candidates = [
+        'video/webm;codecs=vp9,opus',
+        'video/webm;codecs=vp8,opus',
+        'video/webm',
+        'video/mp4'
+    ];
+    return candidates.find((type) => MediaRecorder.isTypeSupported(type));
+}
 function buildRecordingProgress(duration, bytes) {
-    const progress = { duration, bytesRecorded: bytes };
-    if (duration > 0) {
-        progress.bitrate = Math.round((bytes * 8) / duration);
+    // Omit the size-derived fields until a real chunk has arrived, matching the
+    // mobile backends (do not report a misleading 0).
+    const progress = { duration };
+    if (bytes > 0) {
+        progress.bytesRecorded = bytes;
+        if (duration > 0) {
+            progress.bitrate = Math.round((bytes * 8) / duration);
+        }
     }
     return progress;
 }
@@ -47,12 +66,14 @@ function stopProgressTimer() {
 async function ensureDesktopStream(options) {
     if (activeStream)
         return activeStream;
-    const constraints = {
-        video: {
-            facingMode: options?.camera === 'front' ? 'user' : 'environment'
-        },
-        audio: false
-    };
+    const videoConstraints = {};
+    if (options?.cameraId) {
+        videoConstraints.deviceId = { exact: options.cameraId };
+    }
+    else {
+        videoConstraints.facingMode = options?.camera === 'front' ? 'user' : 'environment';
+    }
+    const constraints = { video: videoConstraints, audio: false };
     const stream = await navigator.mediaDevices.getUserMedia(constraints);
     activeStream = stream;
     const video = document.createElement('video');
@@ -69,6 +90,8 @@ function teardownDesktopStream() {
         mediaRecorder.stop();
     }
     mediaRecorder = null;
+    recordingAudioStream?.getTracks().forEach((t) => t.stop());
+    recordingAudioStream = null;
     recordedChunks = [];
     recordedBytes = 0;
     if (activeStream) {
@@ -77,12 +100,55 @@ function teardownDesktopStream() {
     activeStream = null;
     activeVideo = null;
 }
-function captureDesktopFrame() {
+/** Parses an aspect ratio like '4:3' into a number (4/3), or null. */
+function parseAspectRatio(value) {
+    const [w, h] = value.split(':').map((n) => Number(n));
+    if (!w || !h)
+        return null;
+    return w / h;
+}
+/** Target capture height (px) for a video quality preset (desktop best-effort). */
+function qualityHeight(quality) {
+    switch (quality) {
+        case 'sd':
+            return 480;
+        case 'hd':
+            return 720;
+        case 'fhd':
+            return 1080;
+        case 'uhd':
+            return 2160;
+    }
+}
+/** MIME type for a photo format on desktop, or null when unsupported. */
+function desktopPhotoMime(format) {
+    switch (format) {
+        case 'jpeg':
+            return 'image/jpeg';
+        case 'png':
+            return 'image/png';
+        default:
+            return null;
+    }
+}
+function captureDesktopFrame(options) {
     if (!activeVideo) {
         throw new Error('Camera preview is not active. Call startPreview() first.');
     }
-    const width = activeVideo.videoWidth;
-    const height = activeVideo.videoHeight;
+    const format = options?.format ?? 'jpeg';
+    const mime = desktopPhotoMime(format);
+    if (!mime) {
+        throw new Error(`${format} is not supported on desktop.`);
+    }
+    const sourceWidth = activeVideo.videoWidth;
+    const sourceHeight = activeVideo.videoHeight;
+    let width = options?.resolution?.width ?? sourceWidth;
+    let height = options?.resolution?.height ?? sourceHeight;
+    if (!options?.resolution && options?.aspectRatio) {
+        const ratio = parseAspectRatio(options.aspectRatio);
+        if (ratio)
+            height = Math.round(width / ratio);
+    }
     const canvas = document.createElement('canvas');
     canvas.width = width;
     canvas.height = height;
@@ -91,13 +157,13 @@ function captureDesktopFrame() {
         throw new Error('Failed to create canvas context for capture.');
     }
     ctx.drawImage(activeVideo, 0, 0, width, height);
-    const dataUrl = canvas.toDataURL('image/jpeg');
+    const dataUrl = canvas.toDataURL(mime, options?.quality);
     return {
         dataUrl,
         width,
         height,
         orientation: 1,
-        format: 'jpeg',
+        format,
         thumbnail: dataUrl
     };
 }
@@ -151,7 +217,7 @@ async function capture(options) {
     if (isMobile()) {
         return await invoke('plugin:camera-kessdev|capture', { ...options });
     }
-    return captureDesktopFrame();
+    return captureDesktopFrame(options);
 }
 // ---------------------------------------------------------------------------
 // Camera controls
@@ -272,6 +338,57 @@ async function getCapabilities(cameraId) {
     return desktopCapabilities(cameraId);
 }
 // ---------------------------------------------------------------------------
+// Fine controls (torch, focus, exposure, white balance)
+// ---------------------------------------------------------------------------
+/** Turns the torch (continuous light) on or off (mobile). */
+async function setTorch(on) {
+    if (isMobile()) {
+        await invoke('plugin:camera-kessdev|set_torch', { on });
+        return;
+    }
+    throw new Error('setTorch is not supported on desktop.');
+}
+/** Sets the focus point in normalized coordinates (0..1, top-left origin) (mobile). */
+async function setFocusPoint(x, y) {
+    if (isMobile()) {
+        await invoke('plugin:camera-kessdev|set_focus_point', { x, y });
+        return;
+    }
+    throw new Error('setFocusPoint is not supported on desktop.');
+}
+/** Sets the focus mode (mobile). */
+async function setFocusMode(mode) {
+    if (isMobile()) {
+        await invoke('plugin:camera-kessdev|set_focus_mode', { mode });
+        return;
+    }
+    throw new Error('setFocusMode is not supported on desktop.');
+}
+/** Sets the exposure compensation in EV (mobile). */
+async function setExposureCompensation(ev) {
+    if (isMobile()) {
+        await invoke('plugin:camera-kessdev|set_exposure_compensation', { ev });
+        return;
+    }
+    throw new Error('setExposureCompensation is not supported on desktop.');
+}
+/** Sets the exposure mode (mobile). */
+async function setExposureMode(mode) {
+    if (isMobile()) {
+        await invoke('plugin:camera-kessdev|set_exposure_mode', { mode });
+        return;
+    }
+    throw new Error('setExposureMode is not supported on desktop.');
+}
+/** Sets the white balance mode (with an optional Kelvin temperature when `locked`) (mobile). */
+async function setWhiteBalance(options) {
+    if (isMobile()) {
+        await invoke('plugin:camera-kessdev|set_white_balance', { ...options });
+        return;
+    }
+    throw new Error('setWhiteBalance is not supported on desktop.');
+}
+// ---------------------------------------------------------------------------
 // Video recording
 // ---------------------------------------------------------------------------
 /** Starts video recording (with audio). */
@@ -280,22 +397,44 @@ async function startRecording(options) {
         await invoke('plugin:camera-kessdev|start_recording', { ...options });
         return;
     }
-    if (activeStream) {
-        activeStream.getTracks().forEach((t) => t.stop());
-        activeStream = null;
-        activeVideo = null;
+    // Reuse the active preview video track when possible so the preview is not
+    // invalidated (which would freeze the app's <video> element).
+    let videoTrack = activeStream?.getVideoTracks()[0];
+    if (!videoTrack) {
+        const videoConstraints = {};
+        if (options?.quality)
+            videoConstraints.height = { ideal: qualityHeight(options.quality) };
+        if (options?.fps)
+            videoConstraints.frameRate = { ideal: options.fps };
+        const videoStream = await navigator.mediaDevices.getUserMedia({
+            video: videoConstraints,
+            audio: false
+        });
+        activeStream = videoStream;
+        videoTrack = videoStream.getVideoTracks()[0];
+    }
+    if (!videoTrack) {
+        throw new Error('No video track available for recording.');
     }
-    const stream = await navigator.mediaDevices.getUserMedia({ video: true, audio: true });
-    activeStream = stream;
-    const video = document.createElement('video');
-    video.muted = true;
-    video.playsInline = true;
-    video.srcObject = stream;
-    await video.play();
-    activeVideo = video;
+    if (!activeVideo) {
+        const video = document.createElement('video');
+        video.muted = true;
+        video.playsInline = true;
+        video.srcObject = activeStream;
+        await video.play();
+        activeVideo = video;
+    }
+    recordingAudioStream = await navigator.mediaDevices.getUserMedia({ audio: true });
+    const recordStream = new MediaStream([videoTrack, ...recordingAudioStream.getAudioTracks()]);
     recordedChunks = [];
     recordedBytes = 0;
-    mediaRecorder = new MediaRecorder(stream);
+    const recorderOptions = {};
+    if (options?.bitrate)
+        recorderOptions.videoBitsPerSecond = options.bitrate;
+    const mimeType = pickDesktopRecordingMimeType();
+    if (mimeType)
+        recorderOptions.mimeType = mimeType;
+    mediaRecorder = new MediaRecorder(recordStream, recorderOptions);
     mediaRecorder.ondataavailable = (event) => {
         if (event.data.size > 0) {
             recordedChunks.push(event.data);
@@ -330,9 +469,12 @@ async function stopRecording(options) {
     stopProgressTimer();
     return await new Promise((resolve, reject) => {
         mediaRecorder.onstop = () => {
-            const type = mediaRecorder.mimeType || 'video/webm';
+            const mimeType = mediaRecorder.mimeType || 'video/webm';
+            const type = mimeType.split(';')[0];
             const blob = new Blob(recordedChunks, { type });
             const url = URL.createObjectURL(blob);
+            recordingAudioStream?.getTracks().forEach((t) => t.stop());
+            recordingAudioStream = null;
             recordedChunks = [];
             recordedBytes = 0;
             mediaRecorder = null;
@@ -421,4 +563,4 @@ async function openAppSettings() {
     throw new Error('openAppSettings is not supported on desktop.');
 }
 
-export { capture, checkPermissions, flipCamera, getAvailableCameras, getCapabilities, getPreviewStream, getZoom, openAppSettings, requestPermissions, saveToGallery, setFlash, setZoom, startPreview, startRecording, stopPreview, stopRecording };
+export { capture, checkPermissions, flipCamera, getAvailableCameras, getCapabilities, getPreviewStream, getZoom, openAppSettings, requestPermissions, saveToGallery, setExposureCompensation, setExposureMode, setFlash, setFocusMode, setFocusPoint, setTorch, setWhiteBalance, setZoom, startPreview, startRecording, stopPreview, stopRecording };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tauri-plugin-camera-kessdev",
-  "version": "0.2.0-beta.0",
+  "version": "0.2.0-beta.2",
   "author": "kess",
   "description": "Camera plugin for Tauri v2: photo capture, video recording and preview on Android, iOS and desktop.",
   "license": "MIT",