tauri-plugin-camera-kessdev 0.1.1-beta.4 → 0.2.0-beta.0

package/README.md

@@ -128,10 +128,10 @@ import {
   stopRecording,
   flipCamera,
   setFlash,
-  isFlashAvailable,
   setZoom,
   getZoom,
-  getZoomRange,
+  getAvailableCameras,
+  getCapabilities,
   saveToGallery,
   checkPermissions,
   requestPermissions,
@@ -233,14 +233,38 @@ 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)
+// Live state (mobile):
+const zoom = await getZoom() // number
 ```
 
-On desktop `getZoom()` and `getZoomRange()` reject with a descriptive error
-(consistent with `setZoom`), while `isFlashAvailable()` resolves to `false`.
+On desktop `getZoom()` rejects with a descriptive error (consistent with
+`setZoom`).
+
+### Camera introspection
+
+Use `getAvailableCameras()` to list the cameras (physical/logical lenses) and
+`getCapabilities()` to know what a camera *can* do, before trying:
+
+```ts
+const cameras = await getAvailableCameras()
+// [{ id: '0', facing: 'back', lens: 'wide' }, { id: '1', facing: 'front' }, ...]
+
+// 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 }
+```
+
+The plugin follows one rule to avoid ambiguity:
+
+- **What the hardware can do** -> `getCapabilities()` (declarative).
+- **What a value is right now** -> a dedicated live getter (e.g. `getZoom()`).
+
+Both work without an active preview on mobile. On desktop `getAvailableCameras()`
+works cold (labels may stay empty until camera permission has been granted once),
+while the hardware capabilities `zoomRange`, `hasTorch` and `focusModes` are
+omitted until a preview/recording stream is active; `hasFlash` is always `false`
+and `supportsPause` is `true`.
 
 ### Gallery
 
@@ -391,10 +415,10 @@ 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) |
 | `getZoom()` | ✓ | ✗ (throws) |
-| `getZoomRange()` | ✓ | ✗ (throws) |
+| `getAvailableCameras()` | ✓ | ✓ |
+| `getCapabilities(cameraId?)` | ✓ | ✓ (partial) |
 | `startRecording(options?)` | ✓ `VideoCapture` / `AVCaptureMovieFileOutput` | ✓ `MediaRecorder` |
 | `stopRecording(options?)` | ✓ | ✓ |
 | `RecordingProgress` telemetry (`onProgress` channel) | ✓ | ✓ |

package/dist-js/index.cjs

@@ -188,23 +188,89 @@ async function getZoom() {
     }
     throw new Error('getZoom is not supported on desktop.');
 }
-/** Gets the supported zoom range of the active camera (mobile). */
-async function getZoomRange() {
+// ---------------------------------------------------------------------------
+// Introspection (available cameras + declarative capabilities)
+// ---------------------------------------------------------------------------
+/** Best-effort facing detection from a device label (desktop). */
+function facingFromLabel(label) {
+    const value = label.toLowerCase();
+    if (value.includes('front') || value.includes('user'))
+        return 'front';
+    if (value.includes('back') || value.includes('rear') || value.includes('environment'))
+        return 'back';
+    return undefined;
+}
+/** Enumerates video input devices on desktop via `enumerateDevices()`. */
+async function enumerateDesktopCameras() {
+    const devices = await navigator.mediaDevices.enumerateDevices();
+    return devices
+        .filter((device) => device.kind === 'videoinput')
+        .map((device) => {
+        const info = { id: device.deviceId };
+        const facing = facingFromLabel(device.label);
+        if (facing)
+            info.facing = facing;
+        if (device.label)
+            info.label = device.label;
+        return info;
+    });
+}
+/**
+ * Declarative capabilities on desktop. Hardware fields (`zoomRange`, `hasTorch`,
+ * `focusModes`) are only known while a preview/recording stream is active; they
+ * are omitted otherwise.
+ */
+function desktopCapabilities(cameraId) {
+    const caps = {
+        hasFlash: false,
+        hasTorch: false,
+        supportsFocus: false,
+        supportsPause: true,
+        photoFormats: ['jpeg', 'png', 'webp']
+    };
+    if (cameraId)
+        caps.cameraId = cameraId;
+    const track = activeStream?.getVideoTracks?.()[0];
+    const trackCaps = track?.getCapabilities?.();
+    if (trackCaps) {
+        if (trackCaps.zoom) {
+            caps.zoomRange = { min: trackCaps.zoom.min, max: trackCaps.zoom.max };
+        }
+        if (typeof trackCaps.torch === 'boolean') {
+            caps.hasTorch = trackCaps.torch;
+        }
+        if (trackCaps.focusMode && trackCaps.focusMode.length > 0) {
+            caps.supportsFocus = true;
+            caps.focusModes = trackCaps.focusMode;
+        }
+    }
+    return caps;
+}
+/**
+ * Lists the cameras (physical or logical lenses) available on the device.
+ *
+ * Works without an active preview on every platform. On desktop the labels may
+ * be empty until camera permission has been granted at least once.
+ */
+async function getAvailableCameras() {
     if (isMobile()) {
-        return await core.invoke('plugin:camera-kessdev|get_zoom_range');
+        return await core.invoke('plugin:camera-kessdev|get_available_cameras');
     }
-    throw new Error('getZoomRange is not supported on desktop.');
+    return enumerateDesktopCameras();
 }
 /**
- * Returns whether the active camera has a flash unit.
+ * Returns the declarative capabilities of a camera.
  *
- * On desktop this always resolves to `false` (no flash control).
+ * Without `cameraId` it describes the active camera, or the default (back)
+ * camera when no preview is active. On mobile it works without an active
+ * preview; on desktop hardware fields are omitted until a stream is active.
+ * Live values are exposed by dedicated getters (e.g. {@link getZoom}).
  */
-async function isFlashAvailable() {
+async function getCapabilities(cameraId) {
     if (isMobile()) {
-        return await core.invoke('plugin:camera-kessdev|is_flash_available');
+        return await core.invoke('plugin:camera-kessdev|get_capabilities', { cameraId });
     }
-    return false;
+    return desktopCapabilities(cameraId);
 }
 // ---------------------------------------------------------------------------
 // Video recording
@@ -363,10 +429,10 @@ Object.defineProperty(exports, "convertFileSrc", {
 exports.capture = capture;
 exports.checkPermissions = checkPermissions;
 exports.flipCamera = flipCamera;
+exports.getAvailableCameras = getAvailableCameras;
+exports.getCapabilities = getCapabilities;
 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

@@ -37,11 +37,46 @@ export interface Video {
     /** Optional base64-encoded thumbnail, when requested via `stopRecording`. */
     thumbnail?: string;
 }
-/** Supported zoom range of the active camera. */
+/** Supported zoom range of a camera (declarative, without the live value). */
 export interface ZoomRange {
     min: number;
     max: number;
-    current: number;
+}
+/** Orientation of a camera. */
+export type CameraFacing = 'front' | 'back' | 'external';
+/**
+ * Best-effort hint of which lens a camera maps to. Platforms that cannot
+ * determine it (notably desktop) omit the field.
+ */
+export type CameraLens = 'wide' | 'ultraWide' | 'telephoto' | (string & {});
+/** A camera (physical or logical lens) available on the device. */
+export interface CameraInfo {
+    /** Native, session-stable identifier (usable to reference this camera). */
+    id: string;
+    /** Orientation, when the platform can determine it. */
+    facing?: CameraFacing;
+    /** Best-effort lens hint, when the platform can determine it. */
+    lens?: CameraLens;
+    /** Human-readable label, when available. */
+    label?: string;
+}
+/**
+ * Declarative capabilities of a camera: what the hardware/platform *can* do.
+ *
+ * Optional fields are omitted when the platform cannot determine them. Live
+ * values (e.g. the current zoom factor) are exposed by dedicated getters such
+ * as {@link getZoom}, never here.
+ */
+export interface CameraCapabilities {
+    /** Identifier of the camera these capabilities describe, when known. */
+    cameraId?: string;
+    hasFlash: boolean;
+    hasTorch: boolean;
+    zoomRange?: ZoomRange;
+    supportsFocus: boolean;
+    focusModes?: string[];
+    photoFormats?: string[];
+    supportsPause: boolean;
 }
 /**
  * Live telemetry emitted while a video recording is in progress.
@@ -103,14 +138,22 @@ export declare function setFlash(mode: FlashMode): Promise<void>;
 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.
+ * Lists the cameras (physical or logical lenses) available on the device.
+ *
+ * Works without an active preview on every platform. On desktop the labels may
+ * be empty until camera permission has been granted at least once.
+ */
+export declare function getAvailableCameras(): Promise<CameraInfo[]>;
+/**
+ * Returns the declarative capabilities of a camera.
  *
- * On desktop this always resolves to `false` (no flash control).
+ * Without `cameraId` it describes the active camera, or the default (back)
+ * camera when no preview is active. On mobile it works without an active
+ * preview; on desktop hardware fields are omitted until a stream is active.
+ * Live values are exposed by dedicated getters (e.g. {@link getZoom}).
  */
-export declare function isFlashAvailable(): Promise<boolean>;
+export declare function getCapabilities(cameraId?: string): Promise<CameraCapabilities>;
 /** 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

@@ -187,23 +187,89 @@ async function getZoom() {
     }
     throw new Error('getZoom is not supported on desktop.');
 }
-/** Gets the supported zoom range of the active camera (mobile). */
-async function getZoomRange() {
+// ---------------------------------------------------------------------------
+// Introspection (available cameras + declarative capabilities)
+// ---------------------------------------------------------------------------
+/** Best-effort facing detection from a device label (desktop). */
+function facingFromLabel(label) {
+    const value = label.toLowerCase();
+    if (value.includes('front') || value.includes('user'))
+        return 'front';
+    if (value.includes('back') || value.includes('rear') || value.includes('environment'))
+        return 'back';
+    return undefined;
+}
+/** Enumerates video input devices on desktop via `enumerateDevices()`. */
+async function enumerateDesktopCameras() {
+    const devices = await navigator.mediaDevices.enumerateDevices();
+    return devices
+        .filter((device) => device.kind === 'videoinput')
+        .map((device) => {
+        const info = { id: device.deviceId };
+        const facing = facingFromLabel(device.label);
+        if (facing)
+            info.facing = facing;
+        if (device.label)
+            info.label = device.label;
+        return info;
+    });
+}
+/**
+ * Declarative capabilities on desktop. Hardware fields (`zoomRange`, `hasTorch`,
+ * `focusModes`) are only known while a preview/recording stream is active; they
+ * are omitted otherwise.
+ */
+function desktopCapabilities(cameraId) {
+    const caps = {
+        hasFlash: false,
+        hasTorch: false,
+        supportsFocus: false,
+        supportsPause: true,
+        photoFormats: ['jpeg', 'png', 'webp']
+    };
+    if (cameraId)
+        caps.cameraId = cameraId;
+    const track = activeStream?.getVideoTracks?.()[0];
+    const trackCaps = track?.getCapabilities?.();
+    if (trackCaps) {
+        if (trackCaps.zoom) {
+            caps.zoomRange = { min: trackCaps.zoom.min, max: trackCaps.zoom.max };
+        }
+        if (typeof trackCaps.torch === 'boolean') {
+            caps.hasTorch = trackCaps.torch;
+        }
+        if (trackCaps.focusMode && trackCaps.focusMode.length > 0) {
+            caps.supportsFocus = true;
+            caps.focusModes = trackCaps.focusMode;
+        }
+    }
+    return caps;
+}
+/**
+ * Lists the cameras (physical or logical lenses) available on the device.
+ *
+ * Works without an active preview on every platform. On desktop the labels may
+ * be empty until camera permission has been granted at least once.
+ */
+async function getAvailableCameras() {
     if (isMobile()) {
-        return await invoke('plugin:camera-kessdev|get_zoom_range');
+        return await invoke('plugin:camera-kessdev|get_available_cameras');
     }
-    throw new Error('getZoomRange is not supported on desktop.');
+    return enumerateDesktopCameras();
 }
 /**
- * Returns whether the active camera has a flash unit.
+ * Returns the declarative capabilities of a camera.
  *
- * On desktop this always resolves to `false` (no flash control).
+ * Without `cameraId` it describes the active camera, or the default (back)
+ * camera when no preview is active. On mobile it works without an active
+ * preview; on desktop hardware fields are omitted until a stream is active.
+ * Live values are exposed by dedicated getters (e.g. {@link getZoom}).
  */
-async function isFlashAvailable() {
+async function getCapabilities(cameraId) {
     if (isMobile()) {
-        return await invoke('plugin:camera-kessdev|is_flash_available');
+        return await invoke('plugin:camera-kessdev|get_capabilities', { cameraId });
     }
-    return false;
+    return desktopCapabilities(cameraId);
 }
 // ---------------------------------------------------------------------------
 // Video recording
@@ -355,4 +421,4 @@ async function openAppSettings() {
     throw new Error('openAppSettings is not supported on desktop.');
 }
 
-export { capture, checkPermissions, flipCamera, getPreviewStream, getZoom, getZoomRange, isFlashAvailable, openAppSettings, requestPermissions, saveToGallery, setFlash, setZoom, startPreview, startRecording, stopPreview, stopRecording };
+export { capture, checkPermissions, flipCamera, getAvailableCameras, getCapabilities, getPreviewStream, getZoom, 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.4",
+  "version": "0.2.0-beta.0",
   "author": "kess",
   "description": "Camera plugin for Tauri v2: photo capture, video recording and preview on Android, iOS and desktop.",
   "license": "MIT",