tauri-plugin-camera-kessdev 0.1.1-beta.2 → 0.1.1-beta.4

package/README.md

@@ -17,6 +17,8 @@ photo gallery, and camera permission management.
 > plus `<video>`/`<canvas>`. On mobile it uses a native preview (CameraX on Android,
 > AVFoundation on iOS) for full control and quality.
 
+> **Development note (AI assistance).** This plugin is being developed with the assistance of AI tools. AI may have generated parts of the code, tests and documentation. Every change is reviewed and verified by maintainers (automated tests and CI) before release, but we disclose this for transparency. Please report any issue you find.
+
 ## Install
 
 Add the Rust crate to `src-tauri/Cargo.toml`:
@@ -105,6 +107,13 @@ and the real gate is the operating system:
   "Let desktop apps access your camera".
 - **Linux**: the desktop portal (e.g. `xdg-desktop-portal`) governs camera access.
 
+> **Maintenance note:** the Windows handler uses the raw `webview2-com` API, whose
+> version must match the one `wry` links against through `tauri`. When bumping
+> `tauri`/`wry`, bump the `[target.'cfg(target_os = "windows")'.dependencies]`
+> `webview2-com` version in `Cargo.toml` to the same minor line as wry; otherwise
+> the build fails with an `E0277` trait-bound error. The `verify-windows` CI job
+> guards this.
+
 On **macOS**, `WKWebView` additionally requires `NSCameraUsageDescription` and
 `NSMicrophoneUsageDescription` in the `Info.plist` (the same keys above).
 
@@ -119,7 +128,10 @@ import {
   stopRecording,
   flipCamera,
   setFlash,
+  isFlashAvailable,
   setZoom,
+  getZoom,
+  getZoomRange,
   saveToGallery,
   checkPermissions,
   requestPermissions,
@@ -159,22 +171,88 @@ await startRecording()
 // ... user records ...
 const video = await stopRecording()
 // video: { path, duration } (mobile) | { duration, blob, url } (desktop)
+
+// Optionally request a base64 JPEG thumbnail of the recording:
+const withThumbnail = await stopRecording({ thumbnail: true })
+// withThumbnail.thumbnail: string | undefined
+```
+
+### Video thumbnail
+
+Pass `{ thumbnail: true }` to `stopRecording()` to include a base64-encoded JPEG
+poster frame in the `Video` result. It is opt-in because it costs a frame decode
+and encode. When it cannot be generated the field is omitted (the recording still
+succeeds).
+
+- **Android**: extracted with `MediaMetadataRetriever` on the recording executor.
+- **iOS**: extracted with `AVAssetImageGenerator` at ~0.1 s (avoids a black first frame).
+- **Desktop**: captured from the live preview stream at stop time.
+
+### Recording progress (telemetry)
+
+Pass an `onProgress` channel to `startRecording()` to receive live telemetry while
+the recording is in progress. The channel is optional: omit it and recording
+behaves exactly as before.
+
+```ts
+import { Channel } from '@tauri-apps/api/core'
+import { startRecording, stopRecording, type RecordingProgress } from 'tauri-plugin-camera-kessdev'
+
+const progress = new Channel<RecordingProgress>()
+progress.onmessage = (p) => {
+  // p: { duration, bytesRecorded?, bitrate? }
+  console.log(`${p.duration.toFixed(1)}s`, p.bytesRecorded, 'bytes')
+}
+
+await startRecording({ onProgress: progress })
+// ... user records ...
+const video = await stopRecording()
 ```
 
+`RecordingProgress` fields:
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `duration` | `number` | Elapsed recording time in seconds. Always present. |
+| `bytesRecorded` | `number?` | Bytes written so far, when the platform reports it. |
+| `bitrate` | `number?` | Average bitrate in bits per second, when derivable. |
+
+Platform notes:
+
+- **Android**: telemetry is derived from CameraX `VideoRecordEvent.Status`, emitted at roughly 1 Hz natively. `bytesRecorded` is accurate.
+- **iOS**: telemetry is sampled from `AVCaptureMovieFileOutput` every 500 ms. `bytesRecorded` is omitted until `recordedFileSize` becomes available, so early messages may only carry `duration`.
+- **Desktop**: `duration` is computed from `performance.now()` and `bytesRecorded` from `MediaRecorder` data chunks. Because `MediaRecorder` only emits a chunk every 1000 ms, `bytesRecorded` can lag by up to one second.
+
+Messages are throttled to about 4 per second and stop as soon as the recording
+ends. Telemetry is never emitted after `stopRecording()` resolves.
+
 ### Camera controls
 
 ```ts
 await flipCamera()
 await setFlash('on') // 'on' | 'off' | 'auto'
 await setZoom(2.0)
+
+// Query the active camera (mobile). Desktop has no zoom/flash control:
+const zoom = await getZoom()                       // number
+const range = await getZoomRange()                 // { min, max, current }
+const hasFlash = await isFlashAvailable()          // boolean (false on desktop)
 ```
 
+On desktop `getZoom()` and `getZoomRange()` reject with a descriptive error
+(consistent with `setZoom`), while `isFlashAvailable()` resolves to `false`.
+
 ### Gallery
 
 ```ts
-await saveToGallery(photo.path) // mobile only
+await saveToGallery(photo.path)                 // image
+await saveToGallery(video.path)                 // video
+await saveToGallery(media.path, { type: 'video' }) // forced type override
 ```
 
+Mobile only. The media type is inferred from the file extension (mp4, mov, m4v,
+webm, 3gp, mkv are treated as video); pass `{ type }` to force it.
+
 ### Permissions
 
 ```ts
@@ -313,10 +391,15 @@ destination from the generated Xcode project (`src-tauri/gen/apple`).
 | `capture(options?)` | ✓ `ImageCapture` / `AVCapturePhotoOutput` | ✓ canvas |
 | `flipCamera()` | ✓ | ✗ (throws) |
 | `setFlash(mode)` | ✓ | ✗ (throws) |
+| `isFlashAvailable()` | ✓ | `false` |
 | `setZoom(factor)` | ✓ | ✗ (throws) |
-| `startRecording()` | ✓ `VideoCapture` / `AVCaptureMovieFileOutput` | ✓ `MediaRecorder` |
-| `stopRecording()` | ✓ | ✓ |
-| `saveToGallery(path)` | ✓ | ✗ (throws) |
+| `getZoom()` | ✓ | ✗ (throws) |
+| `getZoomRange()` | ✓ | ✗ (throws) |
+| `startRecording(options?)` | ✓ `VideoCapture` / `AVCaptureMovieFileOutput` | ✓ `MediaRecorder` |
+| `stopRecording(options?)` | ✓ | ✓ |
+| `RecordingProgress` telemetry (`onProgress` channel) | ✓ | ✓ |
+| `Video.thumbnail` (`stopRecording({ thumbnail: true })`) | ✓ | ✓ |
+| `saveToGallery(path, options?)` | ✓ image & video | ✗ (throws) |
 | `checkPermissions()` | ✓ | ✓ |
 | `requestPermissions()` | ✓ | ✓ |
 | `openAppSettings()` | ✓ | ✗ (throws) |

package/dist-js/index.cjs

@@ -19,7 +19,32 @@ let activeStream = null;
 let activeVideo = null;
 let mediaRecorder = null;
 let recordedChunks = [];
+let recordedBytes = 0;
 let recordingStartedAt = 0;
+let progressTimer = null;
+/** Minimum interval between desktop progress messages (~4 Hz). */
+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;
+function buildRecordingProgress(duration, bytes) {
+    const progress = { duration, bytesRecorded: bytes };
+    if (duration > 0) {
+        progress.bitrate = Math.round((bytes * 8) / duration);
+    }
+    return progress;
+}
+function progressesAreEqual(a, b) {
+    return (a != null &&
+        a.duration === b.duration &&
+        a.bytesRecorded === b.bytesRecorded &&
+        a.bitrate === b.bitrate);
+}
+function stopProgressTimer() {
+    if (progressTimer !== null) {
+        clearInterval(progressTimer);
+        progressTimer = null;
+    }
+}
 async function ensureDesktopStream(options) {
     if (activeStream)
         return activeStream;
@@ -40,11 +65,13 @@ async function ensureDesktopStream(options) {
     return stream;
 }
 function teardownDesktopStream() {
+    stopProgressTimer();
     if (mediaRecorder && mediaRecorder.state !== 'inactive') {
         mediaRecorder.stop();
     }
     mediaRecorder = null;
     recordedChunks = [];
+    recordedBytes = 0;
     if (activeStream) {
         activeStream.getTracks().forEach((t) => t.stop());
     }
@@ -154,13 +181,38 @@ async function setZoom(factor) {
     }
     throw new Error('setZoom is not supported on desktop.');
 }
+/** Gets the current camera zoom factor (mobile). */
+async function getZoom() {
+    if (isMobile()) {
+        return await core.invoke('plugin:camera-kessdev|get_zoom');
+    }
+    throw new Error('getZoom is not supported on desktop.');
+}
+/** Gets the supported zoom range of the active camera (mobile). */
+async function getZoomRange() {
+    if (isMobile()) {
+        return await core.invoke('plugin:camera-kessdev|get_zoom_range');
+    }
+    throw new Error('getZoomRange is not supported on desktop.');
+}
+/**
+ * Returns whether the active camera has a flash unit.
+ *
+ * On desktop this always resolves to `false` (no flash control).
+ */
+async function isFlashAvailable() {
+    if (isMobile()) {
+        return await core.invoke('plugin:camera-kessdev|is_flash_available');
+    }
+    return false;
+}
 // ---------------------------------------------------------------------------
 // Video recording
 // ---------------------------------------------------------------------------
 /** Starts video recording (with audio). */
-async function startRecording() {
+async function startRecording(options) {
     if (isMobile()) {
-        await core.invoke('plugin:camera-kessdev|start_recording');
+        await core.invoke('plugin:camera-kessdev|start_recording', { ...options });
         return;
     }
     if (activeStream) {
@@ -177,47 +229,90 @@ async function startRecording() {
     await video.play();
     activeVideo = video;
     recordedChunks = [];
+    recordedBytes = 0;
     mediaRecorder = new MediaRecorder(stream);
     mediaRecorder.ondataavailable = (event) => {
-        if (event.data.size > 0)
+        if (event.data.size > 0) {
             recordedChunks.push(event.data);
+            recordedBytes += event.data.size;
+        }
     };
     recordingStartedAt = performance.now();
-    mediaRecorder.start();
+    mediaRecorder.start(RECORDING_TIMESLICE_MS);
+    const onProgress = options?.onProgress;
+    if (onProgress) {
+        stopProgressTimer();
+        let last = null;
+        progressTimer = setInterval(() => {
+            const progress = buildRecordingProgress((performance.now() - recordingStartedAt) / 1000, recordedBytes);
+            if (!progressesAreEqual(last, progress)) {
+                last = progress;
+                onProgress.onmessage(progress);
+            }
+        }, RECORDING_PROGRESS_INTERVAL_MS);
+    }
 }
 /** Stops video recording and returns the recorded media. */
-async function stopRecording() {
+async function stopRecording(options) {
     if (isMobile()) {
-        return await core.invoke('plugin:camera-kessdev|stop_recording');
+        return await core.invoke('plugin:camera-kessdev|stop_recording', { ...options });
     }
     if (!mediaRecorder) {
         throw new Error('Recording is not active. Call startRecording() first.');
     }
     const duration = (performance.now() - recordingStartedAt) / 1000;
+    const thumbnail = options?.thumbnail ? captureDesktopThumbnail() : undefined;
+    stopProgressTimer();
     return await new Promise((resolve, reject) => {
         mediaRecorder.onstop = () => {
             const type = mediaRecorder.mimeType || 'video/webm';
             const blob = new Blob(recordedChunks, { type });
             const url = URL.createObjectURL(blob);
             recordedChunks = [];
+            recordedBytes = 0;
             mediaRecorder = null;
-            resolve({ duration, blob, url });
+            const result = { duration, blob, url };
+            if (thumbnail)
+                result.thumbnail = thumbnail;
+            resolve(result);
         };
         mediaRecorder.onerror = () => reject(new Error('Video recording failed.'));
         mediaRecorder.stop();
     });
 }
+/** Captures the current desktop preview frame as a base64 JPEG thumbnail. */
+function captureDesktopThumbnail() {
+    if (!activeVideo || !activeVideo.videoWidth || !activeVideo.videoHeight) {
+        return undefined;
+    }
+    try {
+        const canvas = document.createElement('canvas');
+        canvas.width = activeVideo.videoWidth;
+        canvas.height = activeVideo.videoHeight;
+        const ctx = canvas.getContext('2d');
+        if (!ctx)
+            return undefined;
+        ctx.drawImage(activeVideo, 0, 0, canvas.width, canvas.height);
+        return canvas.toDataURL('image/jpeg');
+    }
+    catch {
+        return undefined;
+    }
+}
 // ---------------------------------------------------------------------------
 // Gallery
 // ---------------------------------------------------------------------------
 /**
- * Saves a captured image to the device photo gallery (mobile).
+ * Saves a captured photo or video to the device gallery (mobile).
+ *
+ * The media type is inferred from the file extension; pass `options.type` to
+ * force it. On desktop this is not supported.
  *
- * @param path Absolute path to the image file.
+ * @param path Absolute path to the media file.
  */
-async function saveToGallery(path) {
+async function saveToGallery(path, options) {
     if (isMobile()) {
-        await core.invoke('plugin:camera-kessdev|save_to_gallery', { path });
+        await core.invoke('plugin:camera-kessdev|save_to_gallery', { path, ...options });
         return;
     }
     throw new Error('saveToGallery is not supported on desktop.');
@@ -269,6 +364,9 @@ exports.capture = capture;
 exports.checkPermissions = checkPermissions;
 exports.flipCamera = flipCamera;
 exports.getPreviewStream = getPreviewStream;
+exports.getZoom = getZoom;
+exports.getZoomRange = getZoomRange;
+exports.isFlashAvailable = isFlashAvailable;
 exports.openAppSettings = openAppSettings;
 exports.requestPermissions = requestPermissions;
 exports.saveToGallery = saveToGallery;

package/dist-js/index.d.ts

@@ -1,5 +1,5 @@
 import { convertFileSrc } from '@tauri-apps/api/core';
-import type { PermissionState } from '@tauri-apps/api/core';
+import type { Channel, PermissionState } from '@tauri-apps/api/core';
 export type { PermissionState } from '@tauri-apps/api/core';
 export { convertFileSrc };
 export type CameraDirection = 'front' | 'back';
@@ -34,6 +34,41 @@ export interface Video {
     blob?: Blob;
     /** Object URL for the recorded video (desktop). */
     url?: string;
+    /** Optional base64-encoded thumbnail, when requested via `stopRecording`. */
+    thumbnail?: string;
+}
+/** Supported zoom range of the active camera. */
+export interface ZoomRange {
+    min: number;
+    max: number;
+    current: number;
+}
+/**
+ * Live telemetry emitted while a video recording is in progress.
+ *
+ * Delivered through the optional `onProgress` channel passed to
+ * `startRecording()`. The `bytesRecorded` and `bitrate` fields are omitted
+ * when the platform cannot determine them at that moment.
+ */
+export interface RecordingProgress {
+    /** Elapsed recording time in seconds. */
+    duration: number;
+    /** Bytes written to the output so far. */
+    bytesRecorded?: number;
+    /** Average bitrate in bits per second, derived from `bytesRecorded`. */
+    bitrate?: number;
+}
+export interface StartRecordingOptions {
+    /** Receives live recording telemetry while the recording is active. */
+    onProgress?: Channel<RecordingProgress>;
+}
+export interface StopRecordingOptions {
+    /** When true, the result includes a base64-encoded `thumbnail`. */
+    thumbnail?: boolean;
+}
+export interface SaveToGalleryOptions {
+    /** Force the media type instead of inferring it from the file. */
+    type?: 'image' | 'video';
 }
 /**
  * Starts the camera preview.
@@ -66,16 +101,29 @@ export declare function flipCamera(): Promise<void>;
 export declare function setFlash(mode: FlashMode): Promise<void>;
 /** Sets the camera zoom factor (mobile). */
 export declare function setZoom(factor: number): Promise<void>;
+/** Gets the current camera zoom factor (mobile). */
+export declare function getZoom(): Promise<number>;
+/** Gets the supported zoom range of the active camera (mobile). */
+export declare function getZoomRange(): Promise<ZoomRange>;
+/**
+ * Returns whether the active camera has a flash unit.
+ *
+ * On desktop this always resolves to `false` (no flash control).
+ */
+export declare function isFlashAvailable(): Promise<boolean>;
 /** Starts video recording (with audio). */
-export declare function startRecording(): Promise<void>;
+export declare function startRecording(options?: StartRecordingOptions): Promise<void>;
 /** Stops video recording and returns the recorded media. */
-export declare function stopRecording(): Promise<Video>;
+export declare function stopRecording(options?: StopRecordingOptions): Promise<Video>;
 /**
- * Saves a captured image to the device photo gallery (mobile).
+ * Saves a captured photo or video to the device gallery (mobile).
+ *
+ * The media type is inferred from the file extension; pass `options.type` to
+ * force it. On desktop this is not supported.
  *
- * @param path Absolute path to the image file.
+ * @param path Absolute path to the media file.
  */
-export declare function saveToGallery(path: string): Promise<void>;
+export declare function saveToGallery(path: string, options?: SaveToGalleryOptions): Promise<void>;
 /** Gets the current camera permission state. */
 export declare function checkPermissions(): Promise<PermissionState>;
 /** Requests camera permission. */

package/dist-js/index.js

@@ -18,7 +18,32 @@ let activeStream = null;
 let activeVideo = null;
 let mediaRecorder = null;
 let recordedChunks = [];
+let recordedBytes = 0;
 let recordingStartedAt = 0;
+let progressTimer = null;
+/** Minimum interval between desktop progress messages (~4 Hz). */
+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;
+function buildRecordingProgress(duration, bytes) {
+    const progress = { duration, bytesRecorded: bytes };
+    if (duration > 0) {
+        progress.bitrate = Math.round((bytes * 8) / duration);
+    }
+    return progress;
+}
+function progressesAreEqual(a, b) {
+    return (a != null &&
+        a.duration === b.duration &&
+        a.bytesRecorded === b.bytesRecorded &&
+        a.bitrate === b.bitrate);
+}
+function stopProgressTimer() {
+    if (progressTimer !== null) {
+        clearInterval(progressTimer);
+        progressTimer = null;
+    }
+}
 async function ensureDesktopStream(options) {
     if (activeStream)
         return activeStream;
@@ -39,11 +64,13 @@ async function ensureDesktopStream(options) {
     return stream;
 }
 function teardownDesktopStream() {
+    stopProgressTimer();
     if (mediaRecorder && mediaRecorder.state !== 'inactive') {
         mediaRecorder.stop();
     }
     mediaRecorder = null;
     recordedChunks = [];
+    recordedBytes = 0;
     if (activeStream) {
         activeStream.getTracks().forEach((t) => t.stop());
     }
@@ -153,13 +180,38 @@ async function setZoom(factor) {
     }
     throw new Error('setZoom is not supported on desktop.');
 }
+/** Gets the current camera zoom factor (mobile). */
+async function getZoom() {
+    if (isMobile()) {
+        return await invoke('plugin:camera-kessdev|get_zoom');
+    }
+    throw new Error('getZoom is not supported on desktop.');
+}
+/** Gets the supported zoom range of the active camera (mobile). */
+async function getZoomRange() {
+    if (isMobile()) {
+        return await invoke('plugin:camera-kessdev|get_zoom_range');
+    }
+    throw new Error('getZoomRange is not supported on desktop.');
+}
+/**
+ * Returns whether the active camera has a flash unit.
+ *
+ * On desktop this always resolves to `false` (no flash control).
+ */
+async function isFlashAvailable() {
+    if (isMobile()) {
+        return await invoke('plugin:camera-kessdev|is_flash_available');
+    }
+    return false;
+}
 // ---------------------------------------------------------------------------
 // Video recording
 // ---------------------------------------------------------------------------
 /** Starts video recording (with audio). */
-async function startRecording() {
+async function startRecording(options) {
     if (isMobile()) {
-        await invoke('plugin:camera-kessdev|start_recording');
+        await invoke('plugin:camera-kessdev|start_recording', { ...options });
         return;
     }
     if (activeStream) {
@@ -176,47 +228,90 @@ async function startRecording() {
     await video.play();
     activeVideo = video;
     recordedChunks = [];
+    recordedBytes = 0;
     mediaRecorder = new MediaRecorder(stream);
     mediaRecorder.ondataavailable = (event) => {
-        if (event.data.size > 0)
+        if (event.data.size > 0) {
             recordedChunks.push(event.data);
+            recordedBytes += event.data.size;
+        }
     };
     recordingStartedAt = performance.now();
-    mediaRecorder.start();
+    mediaRecorder.start(RECORDING_TIMESLICE_MS);
+    const onProgress = options?.onProgress;
+    if (onProgress) {
+        stopProgressTimer();
+        let last = null;
+        progressTimer = setInterval(() => {
+            const progress = buildRecordingProgress((performance.now() - recordingStartedAt) / 1000, recordedBytes);
+            if (!progressesAreEqual(last, progress)) {
+                last = progress;
+                onProgress.onmessage(progress);
+            }
+        }, RECORDING_PROGRESS_INTERVAL_MS);
+    }
 }
 /** Stops video recording and returns the recorded media. */
-async function stopRecording() {
+async function stopRecording(options) {
     if (isMobile()) {
-        return await invoke('plugin:camera-kessdev|stop_recording');
+        return await invoke('plugin:camera-kessdev|stop_recording', { ...options });
     }
     if (!mediaRecorder) {
         throw new Error('Recording is not active. Call startRecording() first.');
     }
     const duration = (performance.now() - recordingStartedAt) / 1000;
+    const thumbnail = options?.thumbnail ? captureDesktopThumbnail() : undefined;
+    stopProgressTimer();
     return await new Promise((resolve, reject) => {
         mediaRecorder.onstop = () => {
             const type = mediaRecorder.mimeType || 'video/webm';
             const blob = new Blob(recordedChunks, { type });
             const url = URL.createObjectURL(blob);
             recordedChunks = [];
+            recordedBytes = 0;
             mediaRecorder = null;
-            resolve({ duration, blob, url });
+            const result = { duration, blob, url };
+            if (thumbnail)
+                result.thumbnail = thumbnail;
+            resolve(result);
         };
         mediaRecorder.onerror = () => reject(new Error('Video recording failed.'));
         mediaRecorder.stop();
     });
 }
+/** Captures the current desktop preview frame as a base64 JPEG thumbnail. */
+function captureDesktopThumbnail() {
+    if (!activeVideo || !activeVideo.videoWidth || !activeVideo.videoHeight) {
+        return undefined;
+    }
+    try {
+        const canvas = document.createElement('canvas');
+        canvas.width = activeVideo.videoWidth;
+        canvas.height = activeVideo.videoHeight;
+        const ctx = canvas.getContext('2d');
+        if (!ctx)
+            return undefined;
+        ctx.drawImage(activeVideo, 0, 0, canvas.width, canvas.height);
+        return canvas.toDataURL('image/jpeg');
+    }
+    catch {
+        return undefined;
+    }
+}
 // ---------------------------------------------------------------------------
 // Gallery
 // ---------------------------------------------------------------------------
 /**
- * Saves a captured image to the device photo gallery (mobile).
+ * Saves a captured photo or video to the device gallery (mobile).
+ *
+ * The media type is inferred from the file extension; pass `options.type` to
+ * force it. On desktop this is not supported.
  *
- * @param path Absolute path to the image file.
+ * @param path Absolute path to the media file.
  */
-async function saveToGallery(path) {
+async function saveToGallery(path, options) {
     if (isMobile()) {
-        await invoke('plugin:camera-kessdev|save_to_gallery', { path });
+        await invoke('plugin:camera-kessdev|save_to_gallery', { path, ...options });
         return;
     }
     throw new Error('saveToGallery is not supported on desktop.');
@@ -260,4 +355,4 @@ async function openAppSettings() {
     throw new Error('openAppSettings is not supported on desktop.');
 }
 
-export { capture, checkPermissions, flipCamera, getPreviewStream, openAppSettings, requestPermissions, saveToGallery, setFlash, setZoom, startPreview, startRecording, stopPreview, stopRecording };
+export { capture, checkPermissions, flipCamera, getPreviewStream, getZoom, getZoomRange, isFlashAvailable, openAppSettings, requestPermissions, saveToGallery, setFlash, setZoom, startPreview, startRecording, stopPreview, stopRecording };

package/package.json

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