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

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).
 
@@ -161,6 +170,44 @@ const video = await stopRecording()
 // video: { path, duration } (mobile) | { duration, blob, url } (desktop)
 ```
 
+### 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
@@ -314,8 +361,9 @@ destination from the generated Xcode project (`src-tauri/gen/apple`).
 | `flipCamera()` | ✓ | ✗ (throws) |
 | `setFlash(mode)` | ✓ | ✗ (throws) |
 | `setZoom(factor)` | ✓ | ✗ (throws) |
-| `startRecording()` | ✓ `VideoCapture` / `AVCaptureMovieFileOutput` | ✓ `MediaRecorder` |
+| `startRecording(options?)` | ✓ `VideoCapture` / `AVCaptureMovieFileOutput` | ✓ `MediaRecorder` |
 | `stopRecording()` | ✓ | ✓ |
+| `RecordingProgress` telemetry (`onProgress` channel) | ✓ | ✓ |
 | `saveToGallery(path)` | ✓ | ✗ (throws) |
 | `checkPermissions()` | ✓ | ✓ |
 | `requestPermissions()` | ✓ | ✓ |

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());
     }
@@ -158,9 +185,9 @@ async function setZoom(factor) {
 // 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,13 +204,28 @@ 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() {
@@ -194,12 +236,14 @@ async function stopRecording() {
         throw new Error('Recording is not active. Call startRecording() first.');
     }
     const duration = (performance.now() - recordingStartedAt) / 1000;
+    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 });
         };

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';
@@ -35,6 +35,25 @@ export interface Video {
     /** Object URL for the recorded video (desktop). */
     url?: string;
 }
+/**
+ * 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>;
+}
 /**
  * Starts the camera preview.
  *
@@ -67,7 +86,7 @@ export declare function setFlash(mode: FlashMode): Promise<void>;
 /** Sets the camera zoom factor (mobile). */
 export declare function setZoom(factor: number): Promise<void>;
 /** 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>;
 /**

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());
     }
@@ -157,9 +184,9 @@ async function setZoom(factor) {
 // 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,13 +203,28 @@ 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() {
@@ -193,12 +235,14 @@ async function stopRecording() {
         throw new Error('Recording is not active. Call startRecording() first.');
     }
     const duration = (performance.now() - recordingStartedAt) / 1000;
+    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 });
         };

package/package.json

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