capacitor-camera-multicapture 0.12.2

package/android/src/main/java/dev/hemang/cameramulticapture/ExifWrapper.java

@@ -0,0 +1,108 @@
+package dev.hemang.cameramulticapture;
+
+import androidx.exifinterface.media.ExifInterface;
+import android.util.Log;
+
+import java.io.IOException;
+
+/**
+ * Adapted from Capacitor Camera Plugin
+ * Source: https://github.com/ionic-team/capacitor-plugins/blob/main/camera/android/src/main/java/com/capacitorjs/plugins/camera/ExifWrapper.java
+ * Copyright 2020-present Ionic (https://ionic.io)
+ * Licensed under MIT License
+ */
+public class ExifWrapper {
+    private static final String TAG = "ExifWrapper";
+    private final ExifInterface exif;
+    
+    private final String[] attributes = new String[] {
+        ExifInterface.TAG_APERTURE_VALUE,
+        ExifInterface.TAG_ARTIST,
+        ExifInterface.TAG_DATETIME,
+        ExifInterface.TAG_DATETIME_DIGITIZED,
+        ExifInterface.TAG_DATETIME_ORIGINAL,
+        ExifInterface.TAG_EXPOSURE_TIME,
+        ExifInterface.TAG_FLASH,
+        ExifInterface.TAG_FOCAL_LENGTH,
+        ExifInterface.TAG_GPS_ALTITUDE,
+        ExifInterface.TAG_GPS_ALTITUDE_REF,
+        ExifInterface.TAG_GPS_DATESTAMP,
+        ExifInterface.TAG_GPS_LATITUDE,
+        ExifInterface.TAG_GPS_LATITUDE_REF,
+        ExifInterface.TAG_GPS_LONGITUDE,
+        ExifInterface.TAG_GPS_LONGITUDE_REF,
+        ExifInterface.TAG_GPS_PROCESSING_METHOD,
+        ExifInterface.TAG_GPS_TIMESTAMP,
+        ExifInterface.TAG_IMAGE_LENGTH,
+        ExifInterface.TAG_IMAGE_WIDTH,
+        ExifInterface.TAG_ISO_SPEED,
+        ExifInterface.TAG_MAKE,
+        ExifInterface.TAG_MODEL,
+        ExifInterface.TAG_ORIENTATION,
+        ExifInterface.TAG_SUBSEC_TIME,
+        ExifInterface.TAG_SUBSEC_TIME_DIGITIZED,
+        ExifInterface.TAG_SUBSEC_TIME_ORIGINAL,
+        ExifInterface.TAG_WHITE_BALANCE
+    };
+    
+    public ExifWrapper(ExifInterface exif) {
+        this.exif = exif;
+    }
+    
+    public ExifWrapper(String filePath) throws IOException {
+        this.exif = new ExifInterface(filePath);
+    }
+    
+    /**
+     * Copy EXIF data from this wrapper to a destination file
+     * @param destFile Path to destination file
+     */
+    public void copyExif(String destFile) {
+        if (exif == null) {
+            Log.w(TAG, "Source EXIF is null, cannot copy");
+            return;
+        }
+        
+        try {
+            ExifInterface destExif = new ExifInterface(destFile);
+            for (String attribute : attributes) {
+                String value = exif.getAttribute(attribute);
+                if (value != null) {
+                    destExif.setAttribute(attribute, value);
+                }
+            }
+            destExif.saveAttributes();
+            Log.d(TAG, "EXIF data copied successfully to " + destFile);
+        } catch (IOException e) {
+            Log.e(TAG, "Failed to copy EXIF data: " + e.getMessage(), e);
+        }
+    }
+    
+    /**
+     * Reset orientation to normal (1) after physical rotation
+     */
+    public void resetOrientation() {
+        if (exif != null) {
+            try {
+                exif.setAttribute(ExifInterface.TAG_ORIENTATION, 
+                    String.valueOf(ExifInterface.ORIENTATION_NORMAL));
+                exif.saveAttributes();
+                Log.d(TAG, "EXIF orientation reset to NORMAL");
+            } catch (IOException e) {
+                Log.e(TAG, "Failed to reset orientation: " + e.getMessage(), e);
+            }
+        }
+    }
+    
+    /**
+     * Get the current orientation value
+     * @return EXIF orientation value
+     */
+    public int getOrientation() {
+        if (exif == null) {
+            return ExifInterface.ORIENTATION_NORMAL;
+        }
+        return exif.getAttributeInt(ExifInterface.TAG_ORIENTATION, ExifInterface.ORIENTATION_NORMAL);
+    }
+}
+

package/android/src/main/java/dev/hemang/cameramulticapture/GenericUploadWorker.java

@@ -0,0 +1,173 @@
+package dev.hemang.cameramulticapture;
+
+import android.content.Context;
+import android.net.Uri;
+import android.util.Log;
+import androidx.annotation.NonNull;
+import androidx.work.Data;
+import androidx.work.Worker;
+import androidx.work.WorkerParameters;
+import com.getcapacitor.JSObject;
+import org.json.JSONObject;
+import java.io.File;
+import java.io.IOException;
+import java.util.Iterator;
+import java.util.concurrent.TimeUnit;
+import okhttp3.*;
+
+public class GenericUploadWorker extends Worker {
+    private static final String TAG = "GenericUploadWorker";
+    private static final MediaType MEDIA_TYPE_JPEG = MediaType.parse("image/jpeg");
+    
+    private static class UploadResult {
+        boolean success;
+        String errorMessage;
+        
+        UploadResult(boolean success, String errorMessage) {
+            this.success = success;
+            this.errorMessage = errorMessage;
+        }
+    }
+    
+    public GenericUploadWorker(@NonNull Context context, @NonNull WorkerParameters params) {
+        super(context, params);
+    }
+    
+    @NonNull
+    @Override
+    public Result doWork() {
+        try {
+            String jobId = getInputData().getString("jobId");
+            String imageUri = getInputData().getString("imageUri");
+            String uploadEndpoint = getInputData().getString("uploadEndpoint");
+            String headersJson = getInputData().getString("headers");
+            String formDataJson = getInputData().getString("formData");
+            String method = getInputData().getString("method");
+            String fileName = getInputData().getString("fileName");
+            boolean deleteAfterUpload = getInputData().getBoolean("deleteAfterUpload", true);
+            
+            Log.d(TAG, "Starting upload job: " + jobId);
+            
+            UploadResult result = performHttpUpload(imageUri, uploadEndpoint, headersJson, formDataJson, method, fileName);
+            
+            if (result.success) {
+                Log.d(TAG, "Upload completed successfully: " + jobId);
+                
+                if (deleteAfterUpload) {
+                    try {
+                        File imageFile = new File(Uri.parse(imageUri).getPath());
+                        if (imageFile.exists() && imageFile.delete()) {
+                            Log.d(TAG, "✅ Cleaned up file after successful upload: " + imageUri);
+                        }
+                    } catch (Exception e) {
+                        Log.w(TAG, "Failed to clean up file: " + e.getMessage());
+                    }
+                }
+                
+                return Result.success();
+            } else {
+                Log.e(TAG, "Upload failed: " + jobId + " - " + result.errorMessage);
+                Data errorData = new Data.Builder()
+                    .putString("error", result.errorMessage != null ? result.errorMessage : "Upload failed")
+                    .build();
+                return Result.failure(errorData);
+            }
+            
+        } catch (Exception e) {
+            Log.e(TAG, "Upload error: " + e.getMessage(), e);
+            Data errorData = new Data.Builder()
+                .putString("error", e.getMessage())
+                .build();
+            return Result.retry();
+        }
+    }
+    
+    private UploadResult performHttpUpload(String imageUri, String endpoint, String headersJson, 
+                                    String formDataJson, String method, String fileName) {
+        try {
+            OkHttpClient client = new OkHttpClient.Builder()
+                .connectTimeout(45, TimeUnit.SECONDS)
+                .writeTimeout(120, TimeUnit.SECONDS)
+                .readTimeout(90, TimeUnit.SECONDS)
+                .retryOnConnectionFailure(true)
+                .connectionPool(new okhttp3.ConnectionPool(10, 5, TimeUnit.MINUTES))
+                .build();
+            
+            File imageFile = new File(Uri.parse(imageUri).getPath());
+            if (!imageFile.exists()) {
+                Log.e(TAG, "Image file not found: " + imageUri);
+                return new UploadResult(false, "Image file not found: " + imageUri);
+            }
+            
+            JSONObject headers = new JSONObject(headersJson);
+            JSONObject formData = new JSONObject(formDataJson);
+            
+            Request.Builder requestBuilder = new Request.Builder().url(endpoint);
+            
+            Iterator<String> headerKeys = headers.keys();
+            while (headerKeys.hasNext()) {
+                String key = headerKeys.next();
+                String value = headers.getString(key);
+                requestBuilder.addHeader(key, value);
+            }
+            
+            RequestBody requestBody;
+            if ("PUT".equalsIgnoreCase(method)) {
+                requestBody = RequestBody.create(MEDIA_TYPE_JPEG, imageFile);
+            } else {
+                // For POST requests, use multipart form
+                MultipartBody.Builder multipartBuilder = new MultipartBody.Builder()
+                    .setType(MultipartBody.FORM);
+                
+                Iterator<String> formKeys = formData.keys();
+                while (formKeys.hasNext()) {
+                    String key = formKeys.next();
+                    String value = formData.getString(key);
+                    multipartBuilder.addFormDataPart(key, value);
+                }
+                
+                String finalFileName = (fileName != null && !fileName.isEmpty()) ? 
+                    fileName : "photo_" + System.currentTimeMillis() + ".jpg";
+                multipartBuilder.addFormDataPart("file", finalFileName,
+                    RequestBody.create(MEDIA_TYPE_JPEG, imageFile));
+                
+                requestBody = multipartBuilder.build();
+            }
+            
+            if ("PUT".equalsIgnoreCase(method)) {
+                requestBuilder.put(requestBody);
+            } else {
+                requestBuilder.post(requestBody);
+            }
+            
+            Request request = requestBuilder.build();
+            try (Response response = client.newCall(request).execute()) {
+                boolean success = response.isSuccessful();
+                Log.d(TAG, "Upload response: " + response.code() + " - " + response.message());
+                
+                if (!success) {
+                    String errorBody = response.body() != null ? response.body().string() : "No error details";
+                    Log.e(TAG, "Upload failed with response: " + response.code() + " - " + errorBody);
+                    return new UploadResult(false, "HTTP " + response.code() + ": " + response.message() + " - " + errorBody);
+                }
+                
+                return new UploadResult(true, null);
+            }
+            
+        } catch (java.net.ConnectException e) {
+            String errorMsg = "Connection failed to Azure Blob Storage. This usually happens when uploading multiple files simultaneously. Try uploading fewer files at once.";
+            Log.e(TAG, errorMsg + " Details: " + e.getMessage(), e);
+            return new UploadResult(false, errorMsg);
+            
+        } catch (java.net.SocketTimeoutException e) {
+            String errorMsg = "Upload timeout. The file may be too large or network is slow.";
+            Log.e(TAG, errorMsg + " Details: " + e.getMessage(), e);
+            return new UploadResult(false, errorMsg);
+            
+        } catch (Exception e) {
+            String errorMsg = "Upload failed: " + e.getClass().getSimpleName() + " - " + e.getMessage();
+            Log.e(TAG, "HTTP upload error: " + errorMsg, e);
+            return new UploadResult(false, errorMsg);
+        }
+    }
+}

package/android/src/main/java/dev/hemang/cameramulticapture/ImageUtils.java

@@ -0,0 +1,215 @@
+package dev.hemang.cameramulticapture;
+
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.graphics.Matrix;
+import android.net.Uri;
+import android.util.Log;
+import androidx.exifinterface.media.ExifInterface;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+
+/**
+ * Image orientation correction utilities
+ * Adapted from Capacitor Camera Plugin
+ * Source: https://github.com/ionic-team/capacitor-plugins/blob/main/camera/android/src/main/java/com/capacitorjs/plugins/camera/ImageUtils.java
+ * Copyright 2020-present Ionic (https://ionic.io)
+ * Licensed under MIT License
+ */
+public class ImageUtils {
+    private static final String TAG = "ImageUtils";
+    
+    /**
+     * Correct the orientation of an image file by reading EXIF, physically rotating, and resetting EXIF
+     * @param imageFile The image file to correct
+     * @return true if correction was successful or not needed, false if failed
+     */
+    public static boolean correctImageOrientation(File imageFile) {
+        if (imageFile == null || !imageFile.exists()) {
+            Log.e(TAG, "Image file does not exist");
+            return false;
+        }
+        
+        try {
+            ExifWrapper exifWrapper = new ExifWrapper(imageFile.getAbsolutePath());
+            int orientation = exifWrapper.getOrientation();
+            
+            if (orientation == ExifInterface.ORIENTATION_NORMAL || 
+                orientation == ExifInterface.ORIENTATION_UNDEFINED) {
+                return true;
+            }
+            
+            Bitmap bitmap = BitmapFactory.decodeFile(imageFile.getAbsolutePath());
+            if (bitmap == null) {
+                Log.e(TAG, "Failed to decode image file");
+                return false;
+            }
+            
+            Bitmap rotatedBitmap = rotateBitmapByExif(bitmap, orientation);
+            
+            if (rotatedBitmap != bitmap) {
+                FileOutputStream out = new FileOutputStream(imageFile);
+                rotatedBitmap.compress(Bitmap.CompressFormat.JPEG, 95, out);
+                out.flush();
+                out.close();
+                
+                bitmap.recycle();
+                rotatedBitmap.recycle();
+                
+                ExifWrapper newExifWrapper = new ExifWrapper(imageFile.getAbsolutePath());
+                newExifWrapper.resetOrientation();
+                
+                return true;
+            } else {
+                bitmap.recycle();
+                exifWrapper.resetOrientation();
+                return true;
+            }
+            
+        } catch (Exception e) {
+            Log.e(TAG, "Error correcting image orientation: " + e.getMessage(), e);
+            return false;
+        }
+    }
+    
+    /**
+     * Rotate bitmap according to EXIF orientation
+     * @param bitmap Source bitmap
+     * @param exifOrientation EXIF orientation value
+     * @return Rotated bitmap, or same bitmap if no rotation needed
+     */
+    private static Bitmap rotateBitmapByExif(Bitmap bitmap, int exifOrientation) {
+        Matrix matrix = new Matrix();
+        
+        switch (exifOrientation) {
+            case ExifInterface.ORIENTATION_ROTATE_90:
+                matrix.postRotate(90);
+                break;
+            case ExifInterface.ORIENTATION_ROTATE_180:
+                matrix.postRotate(180);
+                break;
+            case ExifInterface.ORIENTATION_ROTATE_270:
+                matrix.postRotate(270);
+                break;
+            case ExifInterface.ORIENTATION_FLIP_HORIZONTAL:
+                matrix.setScale(-1, 1);
+                break;
+            case ExifInterface.ORIENTATION_FLIP_VERTICAL:
+                matrix.setScale(1, -1);
+                break;
+            case ExifInterface.ORIENTATION_TRANSPOSE:
+                matrix.postRotate(90);
+                matrix.postScale(-1, 1);
+                break;
+            case ExifInterface.ORIENTATION_TRANSVERSE:
+                matrix.postRotate(270);
+                matrix.postScale(-1, 1);
+                break;
+            case ExifInterface.ORIENTATION_NORMAL:
+            case ExifInterface.ORIENTATION_UNDEFINED:
+            default:
+                return bitmap;
+        }
+        
+        try {
+            Bitmap rotatedBitmap = Bitmap.createBitmap(
+                bitmap, 0, 0, bitmap.getWidth(), bitmap.getHeight(), matrix, true
+            );
+            return rotatedBitmap;
+        } catch (OutOfMemoryError e) {
+            Log.e(TAG, "Out of memory rotating bitmap", e);
+            return bitmap;
+        }
+    }
+    
+    /**
+     * Generate a thumbnail from an already orientation-corrected image file
+     * @param imageFile Source image file (must already have corrected orientation)
+     * @param thumbnailSize Target thumbnail size (will be square)
+     * @return Base64 data URI of thumbnail, or null if failed
+     */
+    public static String generateThumbnail(File imageFile, int thumbnailSize) {
+        if (imageFile == null || !imageFile.exists()) {
+            Log.e(TAG, "Image file does not exist for thumbnail generation");
+            return null;
+        }
+        
+        try {
+            BitmapFactory.Options options = new BitmapFactory.Options();
+            options.inSampleSize = calculateSampleSize(imageFile, thumbnailSize * 2);
+            
+            Bitmap originalBitmap = BitmapFactory.decodeFile(imageFile.getAbsolutePath(), options);
+            if (originalBitmap == null) {
+                Log.e(TAG, "Failed to decode image file for thumbnail");
+                return null;
+            }
+            
+            Bitmap thumbnail = createSquareThumbnail(originalBitmap, thumbnailSize);
+            originalBitmap.recycle();
+            
+            if (thumbnail == null) {
+                Log.e(TAG, "Failed to generate thumbnail");
+                return null;
+            }
+            
+            String base64Thumbnail = ThumbnailGenerator.bitmapToBase64(thumbnail, 85);
+            thumbnail.recycle();
+            
+            return base64Thumbnail;
+            
+        } catch (Exception e) {
+            Log.e(TAG, "Error generating thumbnail: " + e.getMessage(), e);
+            return null;
+        }
+    }
+    
+    /**
+     * Create a square thumbnail by center-cropping
+     * @param source Source bitmap
+     * @param size Target size
+     * @return Square thumbnail bitmap
+     */
+    private static Bitmap createSquareThumbnail(Bitmap source, int size) {
+        int sourceWidth = source.getWidth();
+        int sourceHeight = source.getHeight();
+        
+        int cropSize = Math.min(sourceWidth, sourceHeight);
+        int x = (sourceWidth - cropSize) / 2;
+        int y = (sourceHeight - cropSize) / 2;
+        
+        Bitmap croppedBitmap = Bitmap.createBitmap(source, x, y, cropSize, cropSize);
+        Bitmap scaledBitmap = Bitmap.createScaledBitmap(croppedBitmap, size, size, true);
+        
+        if (croppedBitmap != scaledBitmap) {
+            croppedBitmap.recycle();
+        }
+        
+        return scaledBitmap;
+    }
+    
+    /**
+     * Calculate sample size for efficient loading
+     * @param imageFile Image file
+     * @param targetSize Target size
+     * @return Sample size for BitmapFactory
+     */
+    private static int calculateSampleSize(File imageFile, int targetSize) {
+        BitmapFactory.Options options = new BitmapFactory.Options();
+        options.inJustDecodeBounds = true;
+        BitmapFactory.decodeFile(imageFile.getAbsolutePath(), options);
+        
+        int sampleSize = 1;
+        int maxDimension = Math.max(options.outWidth, options.outHeight);
+        
+        while (maxDimension / sampleSize > targetSize) {
+            sampleSize *= 2;
+        }
+        
+        return sampleSize;
+    }
+}
+

package/android/src/main/java/dev/hemang/cameramulticapture/PluginVersion.java

@@ -0,0 +1,6 @@
+// Auto-generated from package.json — do not edit. Run npm run build to update.
+package dev.hemang.cameramulticapture;
+
+public final class PluginVersion {
+    public static final String VERSION = "0.12.2";
+}

package/android/src/main/java/dev/hemang/cameramulticapture/ThumbnailGenerator.java

@@ -0,0 +1,48 @@
+package dev.hemang.cameramulticapture;
+
+import android.graphics.Bitmap;
+import android.util.Base64;
+import android.util.Log;
+
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+
+public class ThumbnailGenerator {
+    
+    private static final String TAG = "ThumbnailGenerator";
+    private static final int DEFAULT_THUMBNAIL_SIZE = 200;
+    
+    /**
+     * Generate a thumbnail from an already orientation-corrected image file
+     * @param imageFile Image file (must already have corrected orientation)
+     * @param thumbnailSize Target thumbnail size
+     * @return Base64 data URI of thumbnail
+     */
+    public static String generateThumbnail(File imageFile, int thumbnailSize) {
+        return ImageUtils.generateThumbnail(imageFile, thumbnailSize);
+    }
+    
+    /**
+     * Generate a thumbnail with default size
+     * @param imageFile Image file
+     * @return Base64 data URI of thumbnail
+     */
+    public static String generateThumbnail(File imageFile) {
+        return generateThumbnail(imageFile, DEFAULT_THUMBNAIL_SIZE);
+    }
+    
+    /**
+     * Convert bitmap to Base64 data URI
+     * @param bitmap Source bitmap
+     * @param quality JPEG quality (0-100)
+     * @return Base64 data URI string
+     */
+    public static String bitmapToBase64(Bitmap bitmap, int quality) {
+        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
+        bitmap.compress(Bitmap.CompressFormat.JPEG, quality, outputStream);
+        byte[] bytes = outputStream.toByteArray();
+        
+        String base64 = Base64.encodeToString(bytes, Base64.NO_WRAP);
+        return "data:image/jpeg;base64," + base64;
+    }
+}

package/dist/esm/controllers/camera-controller.d.ts

@@ -0,0 +1,127 @@
+import { TorchState } from '../definitions';
+import type { CameraImageData, CameraMultiCapturePlugin, CameraVideoData } from '../definitions';
+import type { CameraOverlayUIOptions } from '../types/ui-types';
+/**
+ * Interface for camera rectangle dimensions
+ */
+export interface CameraRect {
+    width: number;
+    height: number;
+    x: number;
+    y: number;
+}
+/**
+ * Manages camera operations
+ */
+export declare class CameraController {
+    private plugin;
+    private options;
+    private flashMode;
+    private flashAutoModeEnabled;
+    private torchState;
+    private isRecording;
+    private currentZoom;
+    private preRecordingState;
+    private availableCameras;
+    constructor(plugin: CameraMultiCapturePlugin, options: CameraOverlayUIOptions);
+    /**
+     * Initializes the camera
+     */
+    initialize(containerElement: HTMLElement, quality: number): Promise<void>;
+    /**
+     * Captures an image
+     */
+    captureImage(): Promise<CameraImageData | undefined>;
+    startVideoRecording(): Promise<void>;
+    stopVideoRecording(): Promise<CameraVideoData | undefined>;
+    private restorePreRecordingState;
+    /**
+     * Returns whether video recording is currently active.
+     */
+    getRecordingState(): boolean;
+    /**
+     * Sets the zoom level
+     */
+    setZoom(level: number): Promise<void>;
+    /**
+     * Gets the current zoom level (tracked after setZoom calls)
+     */
+    getCurrentZoom(): number;
+    /**
+     * Gets available cameras information
+     */
+    getAvailableCameras(): Promise<{
+        hasUltrawide: boolean;
+        hasWide: boolean;
+        hasTelephoto: boolean;
+        ultrawideZoomFactor?: number;
+        wideZoomFactor: number;
+        telephotoZoomFactor?: number;
+    }>;
+    /**
+     * Switches to a physical camera based on zoom factor
+     * This will switch to the appropriate lens (ultrawide, wide, telephoto)
+     */
+    switchToPhysicalCamera(zoomFactor: number): Promise<void>;
+    /**
+     * Gets available zoom levels for the current camera
+     */
+    getAvailableZoomLevels(): Promise<{
+        minZoom: number;
+        maxZoom: number;
+        presetLevels: number[];
+    }>;
+    /**
+     * Switches between front and back camera
+     */
+    switchCamera(): Promise<void>;
+    /**
+     * Stops the camera
+     */
+    stop(): Promise<void>;
+    /**
+     * Sets the flash mode
+     */
+    setFlash(mode: 'on' | 'off' | 'auto'): Promise<void>;
+    /**
+     * Gets the current flash mode
+     */
+    getFlashMode(): 'on' | 'off' | 'auto';
+    /**
+     * Toggles flash mode between off, on, and optionally auto
+     */
+    toggleFlash(): Promise<'on' | 'off' | 'auto'>;
+    /**
+     * Gets whether auto mode is enabled
+     */
+    isFlashAutoModeEnabled(): boolean;
+    /**
+     * Sets the torch (flashlight) state.
+     */
+    setTorch(state: TorchState): Promise<void>;
+    /**
+     * Gets the current torch state.
+     */
+    getTorch(): Promise<TorchState>;
+    /**
+     * Toggles the torch state and returns the new value.
+     */
+    toggleTorch(): Promise<TorchState>;
+    /**
+     * Updates the camera preview rectangle dimensions
+     * Call this method when the container size changes (e.g., orientation change)
+     */
+    refresh(): Promise<void>;
+    /**
+     * Gets smart zoom levels that include physical camera switches
+     * Returns an array of zoom levels and whether each is a physical camera
+     */
+    getSmartZoomLevels(): Promise<{
+        level: number;
+        isPhysicalCamera: boolean;
+    }[]>;
+    /**
+     * Performs smart zoom - switches physical cameras when appropriate
+     */
+    performSmartZoom(targetZoom: number): Promise<void>;
+}