tauri-plugin-camera-kessdev 0.1.1-beta.0

package/README.md

@@ -0,0 +1,314 @@
+# Tauri Plugin Camera
+
+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
+photo gallery, and camera permission management.
+
+| Platform | Supported |
+|----------|-----------|
+| Android  | ✓         |
+| iOS      | ✓         |
+| macOS    | ✓ (via `getUserMedia`) |
+| Windows  | ✓ (via `getUserMedia`) |
+| Linux    | ✓ (via `getUserMedia`) |
+
+> On desktop the camera is driven by the webview through `navigator.mediaDevices.getUserMedia`
+> plus `<video>`/`<canvas>`. On mobile it uses a native preview (CameraX on Android,
+> AVFoundation on iOS) for full control and quality.
+
+## Install
+
+Add the Rust crate to `src-tauri/Cargo.toml`:
+
+```toml
+[dependencies]
+tauri-plugin-camera-kessdev = "0.1.0"
+# or from a git/path source:
+# tauri-plugin-camera-kessdev = { path = "../tauri-plugin-camera" }
+```
+
+Add the JavaScript bindings:
+
+```bash
+npm add tauri-plugin-camera-kessdev
+# pnpm add tauri-plugin-camera-kessdev
+# yarn add tauri-plugin-camera-kessdev
+```
+
+## Register
+
+In `src-tauri/src/lib.rs`:
+
+```rust
+pub fn run() {
+    tauri::Builder::default()
+        .plugin(tauri_plugin_camera_kessdev::init())
+        .run(tauri::generate_context!())
+        .expect("error while running tauri application");
+}
+```
+
+## Permissions
+
+### Capabilities (Tauri v2)
+
+Add the default permission set to `src-tauri/capabilities/default.json`:
+
+```json
+{
+  "permissions": [
+    "core:default",
+    "camera: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>`.
+
+### Android
+
+The plugin's `AndroidManifest.xml` declares `android.permission.CAMERA` and
+`android.permission.RECORD_AUDIO` (for video audio). The Kotlin plugin registers them
+through the `@TauriPlugin` annotation, so `checkPermissions` / `requestPermissions` work
+out of the box. No further manifest edits are required.
+
+### iOS
+
+Add the following usage descriptions to the app `Info.plist`
+(`src-tauri/Info.plist`):
+
+```xml
+<key>NSCameraUsageDescription</key>
+<string>This app uses the camera to capture photos and videos.</string>
+<key>NSMicrophoneUsageDescription</key>
+<string>This app uses the microphone to record audio in videos.</string>
+<key>NSPhotoLibraryAddUsageDescription</key>
+<string>This app saves captured photos to your photo library.</string>
+```
+
+`NSMicrophoneUsageDescription` is only required if you use video recording,
+`NSPhotoLibraryAddUsageDescription` only if you use `saveToGallery`.
+
+### Desktop
+
+Desktop uses the browser's `getUserMedia`. On macOS, `WKWebView` additionally requires
+`NSCameraUsageDescription` and `NSMicrophoneUsageDescription` in the `Info.plist` (the
+same keys above).
+
+## Usage
+
+```ts
+import {
+  startPreview,
+  stopPreview,
+  capture,
+  startRecording,
+  stopRecording,
+  flipCamera,
+  setFlash,
+  setZoom,
+  saveToGallery,
+  checkPermissions,
+  requestPermissions,
+  getPreviewStream,
+  convertFileSrc
+} from 'tauri-plugin-camera-kessdev'
+```
+
+### Preview
+
+```ts
+// windowed: true keeps the webview transparent so your UI renders over the camera.
+await startPreview({ camera: 'back', windowed: true })
+
+// Desktop: attach the stream to a <video> element.
+const stream = await getPreviewStream()
+if (stream) videoEl.srcObject = stream
+
+await stopPreview()
+```
+
+### Photo capture
+
+```ts
+const photo = await capture({ flash: 'auto' })
+// photo: { path, width, height, orientation, format, thumbnail? } (mobile)
+//        { dataUrl, width, height, orientation, format }       (desktop)
+
+// Mobile: display the captured file.
+imageEl.src = convertFileSrc(photo.path)
+```
+
+### Video recording (with audio)
+
+```ts
+await startRecording()
+// ... user records ...
+const video = await stopRecording()
+// video: { path, duration } (mobile) | { duration, blob, url } (desktop)
+```
+
+### Camera controls
+
+```ts
+await flipCamera()
+await setFlash('on') // 'on' | 'off' | 'auto'
+await setZoom(2.0)
+```
+
+### Gallery
+
+```ts
+await saveToGallery(photo.path) // mobile only
+```
+
+### Permissions
+
+```ts
+const state = await checkPermissions()   // 'granted' | 'denied' | 'prompt'
+await requestPermissions()
+```
+
+## Image return pattern
+
+- **Mobile** writes the capture to a temporary file in native code and returns its path.
+  Use `convertFileSrc(path)` to display it, read it with the
+  [`fs`](https://v2.tauri.app/plugin/file-system/) plugin, or upload it with
+  `fetch`/the [`http`](https://v2.tauri.app/plugin/http-client/) plugin.
+- **Desktop** returns a base64 data URL and a `Blob` (no native file system write).
+
+This keeps large image payloads out of the JSON IPC bridge (mobile) while staying
+idiomatic on the web (desktop).
+
+## Testing
+
+The plugin ships unit tests for every layer. They are **pure logic** tests — no camera
+hardware, emulator or device is required.
+
+| Layer   | Test file                                  | Command        | Run from            | Requires                          |
+|---------|--------------------------------------------|----------------|---------------------|-----------------------------------|
+| 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                     |
+
+### Prerequisites
+
+**Rust**
+
+- [Rust](https://rustup.rs) (stable toolchain).
+- Optional — to verify the crate compiles for mobile:
+  ```bash
+  rustup target add aarch64-linux-android
+  ```
+
+**JavaScript**
+
+- [Node.js](https://nodejs.org) 18+ and npm (or pnpm/yarn).
+
+**Android (Kotlin)**
+
+- JDK 17 or newer.
+- Android SDK with `platforms/android-36` and `build-tools`.
+- Gradle (or the generated project's wrapper).
+
+**iOS (Swift)**
+
+- macOS with Xcode. iOS tests cannot run on Linux or Windows.
+
+### Rust
+
+```bash
+cd tauri-plugin-camera
+cargo test
+```
+
+Covers model (de)serialization and the error types. To also verify the crate
+compiles against the Android target:
+
+```bash
+cargo check --target aarch64-linux-android
+```
+
+### JavaScript
+
+```bash
+cd tauri-plugin-camera
+npm install
+npm test
+```
+
+`npm test` runs Vitest; the tests cover the API signatures and the mobile/desktop
+dispatch. To validate types and generate the bindings:
+
+```bash
+npm run build
+```
+
+### Android (Kotlin)
+
+The JUnit tests cover flash-mode mapping, zoom clamping and camera direction.
+
+Running them requires the full Tauri Android pipeline. The plugin's `android/`
+module is a Gradle library built as part of the generated app project, and the
+Gradle config (`tauri.settings.gradle`) is only generated during a Tauri Android
+build — not by `tauri android init` (that only lays down the base project). The
+sequence is:
+
+```bash
+cd tauri-plugin-camera/examples/tauri-app
+npm install
+npm run tauri android init
+npm run tauri android build     # generates tauri.settings.gradle and compiles
+cd src-tauri/gen/android
+./gradlew test
+```
+
+Requires JDK 17+, Android SDK + NDK, and `platforms/android-36` — or set
+`compileSdk = 35` in `android/build.gradle.kts` if your SDK only goes up to 35.
+`tauri android build` builds a release APK (needs a signing key); `tauri android dev`
+builds a debug APK but requires a connected device/emulator. Either one generates
+`tauri.settings.gradle`, after which `./gradlew test` works.
+
+### iOS (Swift)
+
+The XCTest tests cover decoding of the command options. Testing requires **full
+Xcode** — Command Line Tools is not enough, because the plugin imports UIKit,
+AVFoundation and Photos, which need the iOS SDK and the Simulator.
+
+The plugin is iOS-only, so it cannot be built with `swift test` (that targets
+macOS, where UIKit is unavailable, and the `Tauri` package referenced by
+`ios/Package.swift` is only created by the Tauri iOS setup). Validate the Swift
+code by building the iOS app:
+
+```bash
+cd tauri-plugin-camera/examples/tauri-app
+npm install
+npm run tauri ios init
+npm run tauri ios build       # compiles the Swift plugin for iOS
+```
+
+To run the XCTest suite itself, use `xcodebuild test` against an iOS Simulator
+destination from the generated Xcode project (`src-tauri/gen/apple`).
+
+## Full API
+
+| Function | Mobile | Desktop |
+|----------|--------|---------|
+| `startPreview(options?)` | ✓ native preview | ✓ `getUserMedia` |
+| `stopPreview()` | ✓ | ✓ |
+| `capture(options?)` | ✓ `ImageCapture` / `AVCapturePhotoOutput` | ✓ canvas |
+| `flipCamera()` | ✓ | ✗ (throws) |
+| `setFlash(mode)` | ✓ | ✗ (throws) |
+| `setZoom(factor)` | ✓ | ✗ (throws) |
+| `startRecording()` | ✓ `VideoCapture` / `AVCaptureMovieFileOutput` | ✓ `MediaRecorder` |
+| `stopRecording()` | ✓ | ✓ |
+| `saveToGallery(path)` | ✓ | ✗ (throws) |
+| `checkPermissions()` | ✓ | ✓ |
+| `requestPermissions()` | ✓ | ✓ |
+| `openAppSettings()` | ✓ | ✗ (throws) |
+| `getPreviewStream()` | `null` | `MediaStream` |

package/dist-js/index.cjs

@@ -0,0 +1,280 @@
+'use strict';
+
+var core = require('@tauri-apps/api/core');
+
+/**
+ * Detects whether the current runtime is a Tauri mobile webview (Android/iOS).
+ * Desktop runtimes fall through to the getUserMedia-based backend.
+ */
+function isMobile() {
+    if (typeof navigator === 'undefined')
+        return false;
+    const ua = navigator.userAgent;
+    return /android/i.test(ua) || /iphone|ipad|ipod/i.test(ua);
+}
+// ---------------------------------------------------------------------------
+// Desktop backend state (getUserMedia + canvas + MediaRecorder)
+// ---------------------------------------------------------------------------
+let activeStream = null;
+let activeVideo = null;
+let mediaRecorder = null;
+let recordedChunks = [];
+let recordingStartedAt = 0;
+async function ensureDesktopStream(options) {
+    if (activeStream)
+        return activeStream;
+    const constraints = {
+        video: {
+            facingMode: options?.camera === 'front' ? 'user' : 'environment'
+        },
+        audio: false
+    };
+    const stream = await navigator.mediaDevices.getUserMedia(constraints);
+    activeStream = stream;
+    const video = document.createElement('video');
+    video.muted = true;
+    video.playsInline = true;
+    video.srcObject = stream;
+    await video.play();
+    activeVideo = video;
+    return stream;
+}
+function teardownDesktopStream() {
+    if (mediaRecorder && mediaRecorder.state !== 'inactive') {
+        mediaRecorder.stop();
+    }
+    mediaRecorder = null;
+    recordedChunks = [];
+    if (activeStream) {
+        activeStream.getTracks().forEach((t) => t.stop());
+    }
+    activeStream = null;
+    activeVideo = null;
+}
+function captureDesktopFrame() {
+    if (!activeVideo) {
+        throw new Error('Camera preview is not active. Call startPreview() first.');
+    }
+    const width = activeVideo.videoWidth;
+    const height = activeVideo.videoHeight;
+    const canvas = document.createElement('canvas');
+    canvas.width = width;
+    canvas.height = height;
+    const ctx = canvas.getContext('2d');
+    if (!ctx) {
+        throw new Error('Failed to create canvas context for capture.');
+    }
+    ctx.drawImage(activeVideo, 0, 0, width, height);
+    const dataUrl = canvas.toDataURL('image/jpeg');
+    return {
+        dataUrl,
+        width,
+        height,
+        orientation: 1,
+        format: 'jpeg',
+        thumbnail: dataUrl
+    };
+}
+// ---------------------------------------------------------------------------
+// Preview
+// ---------------------------------------------------------------------------
+/**
+ * Starts the camera preview.
+ *
+ * On mobile this starts a native preview over the webview; pass `windowed: true`
+ * to keep the webview transparent so your UI renders on top of the camera.
+ * On desktop this acquires the camera via `getUserMedia` and stores the stream
+ * for `capture()` / `startRecording()`. Use `getPreviewStream()` to attach the
+ * desktop stream to a `<video>` element.
+ */
+async function startPreview(options) {
+    if (isMobile()) {
+        await core.invoke('plugin:camera-kessdev|start_preview', { ...options });
+        return;
+    }
+    await ensureDesktopStream(options);
+}
+/** Stops the camera preview and releases the camera. */
+async function stopPreview() {
+    if (isMobile()) {
+        await core.invoke('plugin:camera-kessdev|stop_preview');
+        return;
+    }
+    teardownDesktopStream();
+}
+/**
+ * Returns the active desktop preview stream so the application can render it in
+ * a `<video>` element. Returns `null` on mobile (the native preview is used).
+ */
+async function getPreviewStream() {
+    if (isMobile())
+        return null;
+    return activeStream;
+}
+// ---------------------------------------------------------------------------
+// Photo capture
+// ---------------------------------------------------------------------------
+/**
+ * Captures a photo.
+ *
+ * On mobile returns the temporary file path (plus an optional base64
+ * thumbnail). Use `convertFileSrc(photo.path)` to display it. On desktop
+ * returns a base64 data URL and a Blob.
+ */
+async function capture(options) {
+    if (isMobile()) {
+        return await core.invoke('plugin:camera-kessdev|capture', { ...options });
+    }
+    return captureDesktopFrame();
+}
+// ---------------------------------------------------------------------------
+// Camera controls
+// ---------------------------------------------------------------------------
+/** Switches between front and back camera (mobile). */
+async function flipCamera() {
+    if (isMobile()) {
+        await core.invoke('plugin:camera-kessdev|flip_camera');
+        return;
+    }
+    throw new Error('flipCamera is not supported on desktop. Restart the preview with a different camera direction.');
+}
+/** Sets the flash mode (mobile). */
+async function setFlash(mode) {
+    if (isMobile()) {
+        await core.invoke('plugin:camera-kessdev|set_flash', { mode });
+        return;
+    }
+    throw new Error('setFlash is not supported on desktop.');
+}
+/** Sets the camera zoom factor (mobile). */
+async function setZoom(factor) {
+    if (isMobile()) {
+        await core.invoke('plugin:camera-kessdev|set_zoom', { factor });
+        return;
+    }
+    throw new Error('setZoom is not supported on desktop.');
+}
+// ---------------------------------------------------------------------------
+// Video recording
+// ---------------------------------------------------------------------------
+/** Starts video recording (with audio). */
+async function startRecording() {
+    if (isMobile()) {
+        await core.invoke('plugin:camera-kessdev|start_recording');
+        return;
+    }
+    if (activeStream) {
+        activeStream.getTracks().forEach((t) => t.stop());
+        activeStream = null;
+        activeVideo = null;
+    }
+    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;
+    recordedChunks = [];
+    mediaRecorder = new MediaRecorder(stream);
+    mediaRecorder.ondataavailable = (event) => {
+        if (event.data.size > 0)
+            recordedChunks.push(event.data);
+    };
+    recordingStartedAt = performance.now();
+    mediaRecorder.start();
+}
+/** Stops video recording and returns the recorded media. */
+async function stopRecording() {
+    if (isMobile()) {
+        return await core.invoke('plugin:camera-kessdev|stop_recording');
+    }
+    if (!mediaRecorder) {
+        throw new Error('Recording is not active. Call startRecording() first.');
+    }
+    const duration = (performance.now() - recordingStartedAt) / 1000;
+    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 = [];
+            mediaRecorder = null;
+            resolve({ duration, blob, url });
+        };
+        mediaRecorder.onerror = () => reject(new Error('Video recording failed.'));
+        mediaRecorder.stop();
+    });
+}
+// ---------------------------------------------------------------------------
+// Gallery
+// ---------------------------------------------------------------------------
+/**
+ * Saves a captured image to the device photo gallery (mobile).
+ *
+ * @param path Absolute path to the image file.
+ */
+async function saveToGallery(path) {
+    if (isMobile()) {
+        await core.invoke('plugin:camera-kessdev|save_to_gallery', { path });
+        return;
+    }
+    throw new Error('saveToGallery is not supported on desktop.');
+}
+// ---------------------------------------------------------------------------
+// Permissions
+// ---------------------------------------------------------------------------
+/** Gets the current camera permission state. */
+async function checkPermissions() {
+    if (isMobile()) {
+        return await core.checkPermissions('camera-kessdev').then((r) => r.camera);
+    }
+    try {
+        const status = await navigator.permissions.query({ name: 'camera' });
+        return status.state;
+    }
+    catch {
+        return 'prompt';
+    }
+}
+/** Requests camera permission. */
+async function requestPermissions() {
+    if (isMobile()) {
+        return await core.requestPermissions('camera-kessdev').then((r) => r.camera);
+    }
+    try {
+        const stream = await navigator.mediaDevices.getUserMedia({ video: true });
+        stream.getTracks().forEach((t) => t.stop());
+        return 'granted';
+    }
+    catch {
+        return 'denied';
+    }
+}
+/** Opens the application settings screen (mobile). */
+async function openAppSettings() {
+    if (isMobile()) {
+        await core.invoke('plugin:camera-kessdev|open_app_settings');
+        return;
+    }
+    throw new Error('openAppSettings is not supported on desktop.');
+}
+
+Object.defineProperty(exports, "convertFileSrc", {
+    enumerable: true,
+    get: function () { return core.convertFileSrc; }
+});
+exports.capture = capture;
+exports.checkPermissions = checkPermissions;
+exports.flipCamera = flipCamera;
+exports.getPreviewStream = getPreviewStream;
+exports.openAppSettings = openAppSettings;
+exports.requestPermissions = requestPermissions;
+exports.saveToGallery = saveToGallery;
+exports.setFlash = setFlash;
+exports.setZoom = setZoom;
+exports.startPreview = startPreview;
+exports.startRecording = startRecording;
+exports.stopPreview = stopPreview;
+exports.stopRecording = stopRecording;

package/dist-js/index.d.ts

@@ -0,0 +1,84 @@
+import { convertFileSrc } from '@tauri-apps/api/core';
+import type { PermissionState } from '@tauri-apps/api/core';
+export type { PermissionState } from '@tauri-apps/api/core';
+export { convertFileSrc };
+export type CameraDirection = 'front' | 'back';
+export type FlashMode = 'on' | 'off' | 'auto';
+export interface StartPreviewOptions {
+    camera?: CameraDirection;
+    windowed?: boolean;
+}
+export interface CaptureOptions {
+    flash?: FlashMode;
+}
+export interface Photo {
+    /** Absolute path to the captured image (mobile). */
+    path?: string;
+    /** Base64 data URL of the captured image (desktop). */
+    dataUrl?: string;
+    /** Raw image blob (desktop). */
+    blob?: Blob;
+    width: number;
+    height: number;
+    /** EXIF orientation value. */
+    orientation: number;
+    format: string;
+    /** Optional base64-encoded thumbnail (mobile). */
+    thumbnail?: string;
+}
+export interface Video {
+    /** Absolute path to the recorded video (mobile). */
+    path?: string;
+    duration: number;
+    /** Raw video blob (desktop). */
+    blob?: Blob;
+    /** Object URL for the recorded video (desktop). */
+    url?: string;
+}
+/**
+ * Starts the camera preview.
+ *
+ * On mobile this starts a native preview over the webview; pass `windowed: true`
+ * to keep the webview transparent so your UI renders on top of the camera.
+ * On desktop this acquires the camera via `getUserMedia` and stores the stream
+ * for `capture()` / `startRecording()`. Use `getPreviewStream()` to attach the
+ * desktop stream to a `<video>` element.
+ */
+export declare function startPreview(options?: StartPreviewOptions): Promise<void>;
+/** Stops the camera preview and releases the camera. */
+export declare function stopPreview(): Promise<void>;
+/**
+ * Returns the active desktop preview stream so the application can render it in
+ * a `<video>` element. Returns `null` on mobile (the native preview is used).
+ */
+export declare function getPreviewStream(): Promise<MediaStream | null>;
+/**
+ * Captures a photo.
+ *
+ * On mobile returns the temporary file path (plus an optional base64
+ * thumbnail). Use `convertFileSrc(photo.path)` to display it. On desktop
+ * returns a base64 data URL and a Blob.
+ */
+export declare function capture(options?: CaptureOptions): Promise<Photo>;
+/** Switches between front and back camera (mobile). */
+export declare function flipCamera(): Promise<void>;
+/** Sets the flash mode (mobile). */
+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>;
+/** Stops video recording and returns the recorded media. */
+export declare function stopRecording(): Promise<Video>;
+/**
+ * Saves a captured image to the device photo gallery (mobile).
+ *
+ * @param path Absolute path to the image file.
+ */
+export declare function saveToGallery(path: string): Promise<void>;
+/** Gets the current camera permission state. */
+export declare function checkPermissions(): Promise<PermissionState>;
+/** Requests camera permission. */
+export declare function requestPermissions(): Promise<PermissionState>;
+/** Opens the application settings screen (mobile). */
+export declare function openAppSettings(): Promise<void>;

package/dist-js/index.js

@@ -0,0 +1,263 @@
+import { invoke, checkPermissions as checkPermissions$1, requestPermissions as requestPermissions$1 } from '@tauri-apps/api/core';
+export { convertFileSrc } from '@tauri-apps/api/core';
+
+/**
+ * Detects whether the current runtime is a Tauri mobile webview (Android/iOS).
+ * Desktop runtimes fall through to the getUserMedia-based backend.
+ */
+function isMobile() {
+    if (typeof navigator === 'undefined')
+        return false;
+    const ua = navigator.userAgent;
+    return /android/i.test(ua) || /iphone|ipad|ipod/i.test(ua);
+}
+// ---------------------------------------------------------------------------
+// Desktop backend state (getUserMedia + canvas + MediaRecorder)
+// ---------------------------------------------------------------------------
+let activeStream = null;
+let activeVideo = null;
+let mediaRecorder = null;
+let recordedChunks = [];
+let recordingStartedAt = 0;
+async function ensureDesktopStream(options) {
+    if (activeStream)
+        return activeStream;
+    const constraints = {
+        video: {
+            facingMode: options?.camera === 'front' ? 'user' : 'environment'
+        },
+        audio: false
+    };
+    const stream = await navigator.mediaDevices.getUserMedia(constraints);
+    activeStream = stream;
+    const video = document.createElement('video');
+    video.muted = true;
+    video.playsInline = true;
+    video.srcObject = stream;
+    await video.play();
+    activeVideo = video;
+    return stream;
+}
+function teardownDesktopStream() {
+    if (mediaRecorder && mediaRecorder.state !== 'inactive') {
+        mediaRecorder.stop();
+    }
+    mediaRecorder = null;
+    recordedChunks = [];
+    if (activeStream) {
+        activeStream.getTracks().forEach((t) => t.stop());
+    }
+    activeStream = null;
+    activeVideo = null;
+}
+function captureDesktopFrame() {
+    if (!activeVideo) {
+        throw new Error('Camera preview is not active. Call startPreview() first.');
+    }
+    const width = activeVideo.videoWidth;
+    const height = activeVideo.videoHeight;
+    const canvas = document.createElement('canvas');
+    canvas.width = width;
+    canvas.height = height;
+    const ctx = canvas.getContext('2d');
+    if (!ctx) {
+        throw new Error('Failed to create canvas context for capture.');
+    }
+    ctx.drawImage(activeVideo, 0, 0, width, height);
+    const dataUrl = canvas.toDataURL('image/jpeg');
+    return {
+        dataUrl,
+        width,
+        height,
+        orientation: 1,
+        format: 'jpeg',
+        thumbnail: dataUrl
+    };
+}
+// ---------------------------------------------------------------------------
+// Preview
+// ---------------------------------------------------------------------------
+/**
+ * Starts the camera preview.
+ *
+ * On mobile this starts a native preview over the webview; pass `windowed: true`
+ * to keep the webview transparent so your UI renders on top of the camera.
+ * On desktop this acquires the camera via `getUserMedia` and stores the stream
+ * for `capture()` / `startRecording()`. Use `getPreviewStream()` to attach the
+ * desktop stream to a `<video>` element.
+ */
+async function startPreview(options) {
+    if (isMobile()) {
+        await invoke('plugin:camera-kessdev|start_preview', { ...options });
+        return;
+    }
+    await ensureDesktopStream(options);
+}
+/** Stops the camera preview and releases the camera. */
+async function stopPreview() {
+    if (isMobile()) {
+        await invoke('plugin:camera-kessdev|stop_preview');
+        return;
+    }
+    teardownDesktopStream();
+}
+/**
+ * Returns the active desktop preview stream so the application can render it in
+ * a `<video>` element. Returns `null` on mobile (the native preview is used).
+ */
+async function getPreviewStream() {
+    if (isMobile())
+        return null;
+    return activeStream;
+}
+// ---------------------------------------------------------------------------
+// Photo capture
+// ---------------------------------------------------------------------------
+/**
+ * Captures a photo.
+ *
+ * On mobile returns the temporary file path (plus an optional base64
+ * thumbnail). Use `convertFileSrc(photo.path)` to display it. On desktop
+ * returns a base64 data URL and a Blob.
+ */
+async function capture(options) {
+    if (isMobile()) {
+        return await invoke('plugin:camera-kessdev|capture', { ...options });
+    }
+    return captureDesktopFrame();
+}
+// ---------------------------------------------------------------------------
+// Camera controls
+// ---------------------------------------------------------------------------
+/** Switches between front and back camera (mobile). */
+async function flipCamera() {
+    if (isMobile()) {
+        await invoke('plugin:camera-kessdev|flip_camera');
+        return;
+    }
+    throw new Error('flipCamera is not supported on desktop. Restart the preview with a different camera direction.');
+}
+/** Sets the flash mode (mobile). */
+async function setFlash(mode) {
+    if (isMobile()) {
+        await invoke('plugin:camera-kessdev|set_flash', { mode });
+        return;
+    }
+    throw new Error('setFlash is not supported on desktop.');
+}
+/** Sets the camera zoom factor (mobile). */
+async function setZoom(factor) {
+    if (isMobile()) {
+        await invoke('plugin:camera-kessdev|set_zoom', { factor });
+        return;
+    }
+    throw new Error('setZoom is not supported on desktop.');
+}
+// ---------------------------------------------------------------------------
+// Video recording
+// ---------------------------------------------------------------------------
+/** Starts video recording (with audio). */
+async function startRecording() {
+    if (isMobile()) {
+        await invoke('plugin:camera-kessdev|start_recording');
+        return;
+    }
+    if (activeStream) {
+        activeStream.getTracks().forEach((t) => t.stop());
+        activeStream = null;
+        activeVideo = null;
+    }
+    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;
+    recordedChunks = [];
+    mediaRecorder = new MediaRecorder(stream);
+    mediaRecorder.ondataavailable = (event) => {
+        if (event.data.size > 0)
+            recordedChunks.push(event.data);
+    };
+    recordingStartedAt = performance.now();
+    mediaRecorder.start();
+}
+/** Stops video recording and returns the recorded media. */
+async function stopRecording() {
+    if (isMobile()) {
+        return await invoke('plugin:camera-kessdev|stop_recording');
+    }
+    if (!mediaRecorder) {
+        throw new Error('Recording is not active. Call startRecording() first.');
+    }
+    const duration = (performance.now() - recordingStartedAt) / 1000;
+    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 = [];
+            mediaRecorder = null;
+            resolve({ duration, blob, url });
+        };
+        mediaRecorder.onerror = () => reject(new Error('Video recording failed.'));
+        mediaRecorder.stop();
+    });
+}
+// ---------------------------------------------------------------------------
+// Gallery
+// ---------------------------------------------------------------------------
+/**
+ * Saves a captured image to the device photo gallery (mobile).
+ *
+ * @param path Absolute path to the image file.
+ */
+async function saveToGallery(path) {
+    if (isMobile()) {
+        await invoke('plugin:camera-kessdev|save_to_gallery', { path });
+        return;
+    }
+    throw new Error('saveToGallery is not supported on desktop.');
+}
+// ---------------------------------------------------------------------------
+// Permissions
+// ---------------------------------------------------------------------------
+/** Gets the current camera permission state. */
+async function checkPermissions() {
+    if (isMobile()) {
+        return await checkPermissions$1('camera-kessdev').then((r) => r.camera);
+    }
+    try {
+        const status = await navigator.permissions.query({ name: 'camera' });
+        return status.state;
+    }
+    catch {
+        return 'prompt';
+    }
+}
+/** Requests camera permission. */
+async function requestPermissions() {
+    if (isMobile()) {
+        return await requestPermissions$1('camera-kessdev').then((r) => r.camera);
+    }
+    try {
+        const stream = await navigator.mediaDevices.getUserMedia({ video: true });
+        stream.getTracks().forEach((t) => t.stop());
+        return 'granted';
+    }
+    catch {
+        return 'denied';
+    }
+}
+/** Opens the application settings screen (mobile). */
+async function openAppSettings() {
+    if (isMobile()) {
+        await invoke('plugin:camera-kessdev|open_app_settings');
+        return;
+    }
+    throw new Error('openAppSettings is not supported on desktop.');
+}
+
+export { capture, checkPermissions, flipCamera, getPreviewStream, openAppSettings, requestPermissions, saveToGallery, setFlash, setZoom, startPreview, startRecording, stopPreview, stopRecording };

package/dist-js/index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "tauri-plugin-camera-kessdev",
+  "version": "0.1.1-beta.0",
+  "author": "kess",
+  "description": "Camera plugin for Tauri v2: photo capture, video recording and preview on Android, iOS and desktop.",
+  "license": "MIT",
+  "repository": "https://github.com/kessdev/tauri-plugin-camera",
+  "keywords": [
+    "tauri",
+    "tauri-plugin",
+    "camera",
+    "rust",
+    "android",
+    "ios"
+  ],
+  "type": "module",
+  "types": "./dist-js/index.d.ts",
+  "main": "./dist-js/index.cjs",
+  "module": "./dist-js/index.js",
+  "exports": {
+    "types": "./dist-js/index.d.ts",
+    "import": "./dist-js/index.js",
+    "require": "./dist-js/index.cjs"
+  },
+  "files": [
+    "dist-js",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "rollup -c",
+    "test": "vitest run",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@tauri-apps/api": "^2.0.0"
+  },
+  "devDependencies": {
+    "@rollup/plugin-typescript": "^12.0.0",
+    "rollup": "^4.9.6",
+    "typescript": "^5.5.0",
+    "tslib": "^2.6.2",
+    "vitest": "^2.1.0",
+    "covector": "^0.13.2"
+  }
+}