capacitor-plugin-camera-forked 3.0.8 → 3.0.10

package/android/src/main/java/com/tonyxlh/capacitor/camera/CameraPreviewPlugin.java

@@ -26,6 +26,7 @@ import androidx.camera.core.Camera;
 import androidx.camera.core.CameraSelector;
 import androidx.camera.core.CameraState;
 import androidx.camera.core.FocusMeteringAction;
+import androidx.camera.core.FocusMeteringResult;
 import androidx.camera.core.ImageAnalysis;
 import androidx.camera.core.ImageCapture;
 import androidx.camera.core.ImageCaptureException;
@@ -46,6 +47,7 @@ import androidx.camera.video.MediaStoreOutputOptions;
 import androidx.camera.video.VideoRecordEvent;
 import androidx.camera.view.PreviewView;
 import androidx.core.app.ActivityCompat;
+import androidx.core.content.ContextCompat;
 import androidx.core.util.Consumer;
 import androidx.lifecycle.LifecycleOwner;
 
@@ -69,17 +71,17 @@ import java.io.FileNotFoundException;
 import java.io.IOException;
 import java.io.InputStream;
 import java.util.Date;
+import java.util.List;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.concurrent.TimeUnit;
 
 @CapacitorPlugin(
-        name = "CameraPreview",
-        permissions = {
-                @Permission(strings = {Manifest.permission.CAMERA}, alias = CameraPreviewPlugin.CAMERA),
-                @Permission(strings = {Manifest.permission.RECORD_AUDIO}, alias = CameraPreviewPlugin.MICROPHONE),
-        }
+  name = "CameraPreview",
+  permissions = {
+    @Permission(strings = {Manifest.permission.CAMERA}, alias = CameraPreviewPlugin.CAMERA),
+  }
 )
 public class CameraPreviewPlugin extends Plugin {
     // Permission alias constants
@@ -111,56 +113,60 @@ public class CameraPreviewPlugin extends Plugin {
     @PluginMethod
     public void initialize(PluginCall call) {
         getActivity().runOnUiThread(new Runnable() {
-            @RequiresApi(api = Build.VERSION_CODES.P)
-            public void run() {
-                previewView = new PreviewView(getContext());
-                previewView.setScaleType(PreviewView.ScaleType.FIT_CENTER);
-                FrameLayout.LayoutParams cameraPreviewParams = new FrameLayout.LayoutParams(
-                        FrameLayout.LayoutParams.MATCH_PARENT,
-                        FrameLayout.LayoutParams.MATCH_PARENT
-                );
-                ((ViewGroup) bridge.getWebView().getParent()).addView(previewView, cameraPreviewParams);
-                bridge.getWebView().bringToFront();
-
-                exec = Executors.newSingleThreadExecutor();
-                cameraProviderFuture = ProcessCameraProvider.getInstance(getContext());
-                cameraProviderFuture.addListener(() -> {
-                    try {
-                        cameraProvider = cameraProviderFuture.get();
-                        cameraSelector = new CameraSelector.Builder()
-                                .requireLensFacing(CameraSelector.LENS_FACING_BACK).build();
-                        setupUseCases(false);
-                        call.resolve();
-                    } catch (ExecutionException | InterruptedException e) {
-                        e.printStackTrace();
-                        call.reject(e.getMessage());
-                    }
-                }, getContext().getMainExecutor());
-
-
+        @RequiresApi(api = Build.VERSION_CODES.P)
+        public void run() {
+            previewView = new PreviewView(getContext());
+            previewView.setScaleType(PreviewView.ScaleType.FIT_CENTER);
+            FrameLayout.LayoutParams cameraPreviewParams = new FrameLayout.LayoutParams(
+            FrameLayout.LayoutParams.MATCH_PARENT,
+            FrameLayout.LayoutParams.MATCH_PARENT
+            );
+            ((ViewGroup) bridge.getWebView().getParent()).addView(previewView, cameraPreviewParams);
+            bridge.getWebView().bringToFront();
+
+            exec = Executors.newSingleThreadExecutor();
+            cameraProviderFuture = ProcessCameraProvider.getInstance(getContext());
+            cameraProviderFuture.addListener(() -> {
+            try {
+                cameraProvider = cameraProviderFuture.get();
+                cameraSelector = new CameraSelector.Builder()
+                .requireLensFacing(CameraSelector.LENS_FACING_BACK).build();
+                // Auto-optimize for photo capture on initialization
+                setupUseCases(false); // Always use photo-optimized mode
+                Log.d("Camera", "Initialized with photo capture optimization");
+                call.resolve();
+            } catch (ExecutionException | InterruptedException e) {
+                e.printStackTrace();
+                call.reject(e.getMessage());
             }
+            }, ContextCompat.getMainExecutor(getContext()));
+        }
         });
     }
 
     private void setupUseCases(boolean enableVideo) {
-        //set up the resolution for the preview and image analysis.
-        int orientation = getContext().getResources().getConfiguration().orientation;
-        Size resolution;
-        if (orientation == Configuration.ORIENTATION_PORTRAIT) {
-            resolution = new Size(desiredHeight, desiredWidth);
-        } else {
-            resolution = new Size(desiredWidth, desiredHeight);
-        }
+        // Auto-detect maximum resolution for better zoom quality
+        Size resolution = getOptimalResolution();
 
+        // Enhanced Preview setup for better quality
         Preview.Builder previewBuilder = new Preview.Builder();
+        if (resolution != null) {
         previewBuilder.setTargetResolution(resolution);
+        Log.d("Camera", "Using optimal resolution: " + resolution.getWidth() + "x" + resolution.getHeight());
+        } else {
+        // Fallback: let CameraX choose the best resolution automatically
+        Log.d("Camera", "Using CameraX auto-resolution selection");
+        }
         preview = previewBuilder.build();
         preview.setSurfaceProvider(previewView.getSurfaceProvider());
 
+        // Enhanced ImageAnalysis setup
         ImageAnalysis.Builder imageAnalysisBuilder = new ImageAnalysis.Builder();
-
-        imageAnalysisBuilder.setTargetResolution(resolution)
-                .setBackpressureStrategy(ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST);
+        if (resolution != null) {
+        imageAnalysisBuilder.setTargetResolution(resolution);
+        }
+        imageAnalysisBuilder.setBackpressureStrategy(ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST)
+        .setImageQueueDepth(1); // Optimize for latest frame
 
         imageAnalysis = imageAnalysisBuilder.build();
 
@@ -208,10 +214,20 @@ public class CameraPreviewPlugin extends Plugin {
             }
         });
 
-        imageCapture =
-                new ImageCapture.Builder()
-                        .setTargetAspectRatio(AspectRatio.RATIO_16_9)
-                        .build();
+        // Enhanced ImageCapture setup for optimal photo quality with max resolution
+        ImageCapture.Builder imageCaptureBuilder = new ImageCapture.Builder();
+        if (resolution != null) {
+        imageCaptureBuilder.setTargetResolution(resolution);
+        }
+        imageCaptureBuilder.setCaptureMode(ImageCapture.CAPTURE_MODE_MAXIMIZE_QUALITY) // Prioritize quality over speed
+        .setJpegQuality(95); // High JPEG quality (0-100, default is around 85)
+
+        // Add image stabilization if available (API 28+)
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
+        imageCaptureBuilder.setCaptureMode(ImageCapture.CAPTURE_MODE_MAXIMIZE_QUALITY);
+        }
+
+        imageCapture = imageCaptureBuilder.build();
 
         if (enableVideo) {
             Quality quality = Quality.HD;
@@ -234,6 +250,53 @@ public class CameraPreviewPlugin extends Plugin {
         }
     }
 
+    /**
+     * Get the optimal (maximum) resolution supported by the device for better zoom quality
+     * Uses high-quality resolution options with CameraX auto-selection fallback
+     */
+    private Size getOptimalResolution() {
+        try {
+        // Use high-quality resolution options for better zoom quality
+        // These are commonly supported resolutions across Android devices
+        int orientation = getContext().getResources().getConfiguration().orientation;
+        
+        // High-quality resolution options (in order of preference)
+        Size[] preferredResolutions;
+        
+        if (orientation == Configuration.ORIENTATION_PORTRAIT) {
+            preferredResolutions = new Size[]{
+            new Size(3024, 4032), // 12MP portrait
+            new Size(2160, 3840), // 4K portrait  
+            new Size(2448, 3264), // 8MP portrait
+            new Size(1920, 2560), // 5MP portrait
+            new Size(1440, 1920), // 3MP portrait
+            new Size(1080, 1920), // Full HD portrait
+            };
+        } else {
+            preferredResolutions = new Size[]{
+            new Size(4032, 3024), // 12MP landscape
+            new Size(3840, 2160), // 4K landscape
+            new Size(3264, 2448), // 8MP landscape  
+            new Size(2560, 1920), // 5MP landscape
+            new Size(1920, 1440), // 3MP landscape
+            new Size(1920, 1080), // Full HD landscape
+            };
+        }
+        
+        // Return the first (highest quality) option - CameraX will adapt if not supported
+        Size optimalResolution = preferredResolutions[0];
+        Log.d("Camera", "Selected optimal resolution: " + optimalResolution.getWidth() + "x" + optimalResolution.getHeight());
+        return optimalResolution;
+        
+        } catch (Exception e) {
+        Log.e("Camera", "Error selecting optimal resolution: " + e.getMessage());
+        }
+        
+        // Fallback: return null to let CameraX auto-select
+        Log.d("Camera", "Using CameraX auto-resolution selection as fallback");
+        return null;
+    }
+
     @PluginMethod
     public void startCamera(PluginCall call) {
         getActivity().runOnUiThread(new Runnable() {
@@ -322,36 +385,162 @@ public class CameraPreviewPlugin extends Plugin {
 
     @PluginMethod
     public void setFocus(PluginCall call) {
-      if (call.hasOption("x") && call.hasOption("y")) {
+        if (!call.hasOption("x") || !call.hasOption("y")) {
+        call.reject("Invalid focus coordinates - x and y are required");
+        return;
+        }
+
         Float x = call.getFloat("x");
         Float y = call.getFloat("y");
 
+        // Validate coordinate ranges (should be 0-1 for normalized coordinates)
+        if (x < 0.0f || x > 1.0f || y < 0.0f || y > 1.0f) {
+        call.reject("Focus coordinates must be normalized values between 0.0 and 1.0");
+        return;
+        }
+
         if (previewView == null || camera == null) {
           call.reject("Camera preview is not initialized");
           return;
         }
 
-        try {
-          // Convert normalized coordinates to absolute pixel coordinates
-          float absoluteX = x * previewView.getWidth();
-          float absoluteY = y * previewView.getHeight();
+        getActivity().runOnUiThread(new Runnable() {
+        @Override
+        public void run() {
+            try {
+            // Use PreviewView's built-in MeteringPointFactory for proper coordinate transformation
+            MeteringPointFactory factory = previewView.getMeteringPointFactory();
 
-          MeteringPointFactory factory = new SurfaceOrientedMeteringPointFactory(previewView.getWidth(), previewView.getHeight());
-          MeteringPoint point = factory.createPoint(absoluteX, absoluteY);
+            // Convert normalized coordinates to preview coordinates
+            float previewX = x * previewView.getWidth();
+            float previewY = y * previewView.getHeight();
 
-          FocusMeteringAction.Builder builder = new FocusMeteringAction.Builder(point, FocusMeteringAction.FLAG_AF);
-          builder.setAutoCancelDuration(5, TimeUnit.SECONDS);
-          FocusMeteringAction action = builder.build();
-          camera.getCameraControl().startFocusAndMetering(action);
+            MeteringPoint focusPoint = factory.createPoint(previewX, previewY);
 
-          call.resolve();
-        } catch (Exception e) {
-          call.reject("Error setting focus: " + e.getMessage());
+            // Get configurable options
+            boolean includeExposure = Boolean.TRUE.equals(call.getBoolean("includeExposure", true));
+            Integer autoCancelDurationParam = call.getInt("autoCancelDurationSeconds");
+            int autoCancelDuration = autoCancelDurationParam != null ? autoCancelDurationParam : 3;
+
+            // Build the focus and metering action
+            FocusMeteringAction.Builder builder = new FocusMeteringAction.Builder(focusPoint);
+
+            // Set auto-focus flags
+            if (includeExposure) {
+                // Use both AF and AE flags for the same point
+                builder = new FocusMeteringAction.Builder(focusPoint, FocusMeteringAction.FLAG_AF | FocusMeteringAction.FLAG_AE);
+            } else {
+                // Use only AF flag
+                builder = new FocusMeteringAction.Builder(focusPoint, FocusMeteringAction.FLAG_AF);
+            }
+
+            // Set auto-cancel duration
+            builder.setAutoCancelDuration(autoCancelDuration, TimeUnit.SECONDS);
+
+            FocusMeteringAction action = builder.build();
+
+            // Start focus and metering with result callback
+            ListenableFuture<FocusMeteringResult> future = camera.getCameraControl().startFocusAndMetering(action);
+
+            // Add callback to handle the result
+            future.addListener(new Runnable() {
+                @Override
+                public void run() {
+                try {
+                    FocusMeteringResult result = future.get();
+                    JSObject response = new JSObject();
+                    response.put("success", true);
+                    response.put("autoFocusSuccessful", result.isFocusSuccessful());
+
+                    if (includeExposure) {
+                    // Note: CameraX FocusMeteringResult doesn't provide separate exposure success status
+                    // We'll indicate that exposure was attempted along with focus
+                    response.put("autoExposureSuccessful", result.isFocusSuccessful());
+                    }
+
+                    response.put("x", x);
+                    response.put("y", y);
+
+                    call.resolve(response);
+                } catch (Exception e) {
+                    Log.e("Camera", "Focus operation failed", e);
+                    call.reject("Focus operation failed: " + e.getMessage());
+                }
+                }
+            }, ContextCompat.getMainExecutor(getContext()));
+
+            } catch (Exception e) {
+            Log.e("Camera", "Error setting focus", e);
+            call.reject("Error setting focus: " + e.getMessage());
+            }
+        }
+        });
+    }
+
+    @PluginMethod
+    public void setAutoFocusMode(PluginCall call) {
+        if (camera == null) {
+        call.reject("Camera not initialized");
+        return;
         }
 
-      } else {
-        call.reject("Invalid focus coordinates");
-      }
+        getActivity().runOnUiThread(new Runnable() {
+        @Override
+        public void run() {
+            try {
+            String mode = call.getString("mode", "auto");
+
+            switch (mode.toLowerCase()) {
+                case "auto":
+                // Default auto-focus behavior (continuous)
+                // CameraX handles this automatically
+                break;
+                case "manual":
+                // For manual focus, we would need to disable auto-focus
+                // This is more complex and would require camera2 interop
+                Log.w("Camera", "Manual focus mode not fully supported in CameraX");
+                break;
+                case "continuous":
+                // This is the default behavior in CameraX
+                break;
+                default:
+                call.reject("Unsupported focus mode: " + mode);
+                return;
+            }
+
+            JSObject result = new JSObject();
+            result.put("success", true);
+            result.put("mode", mode);
+            call.resolve(result);
+            } catch (Exception e) {
+            call.reject("Error setting auto focus mode: " + e.getMessage());
+            }
+        }
+        });
+    }
+
+    @PluginMethod
+    public void resetFocus(PluginCall call) {
+        if (camera == null) {
+        call.reject("Camera not initialized");
+        return;
+        }
+
+        getActivity().runOnUiThread(new Runnable() {
+        @Override
+        public void run() {
+            try {
+            // Cancel any ongoing focus operations
+            camera.getCameraControl().cancelFocusAndMetering();
+
+            JSObject result = new JSObject();
+            result.put("success", true);
+            call.resolve(result);
+            } catch (Exception e) {
+            call.reject("Error resetting focus: " + e.getMessage());
+            }
+        }
+        });
     }
 
     @PluginMethod

package/ios/Plugin/CameraPreviewPlugin.swift

@@ -28,6 +28,9 @@ public class CameraPreviewPlugin: CAPPlugin, AVCaptureVideoDataOutputSampleBuffe
     var lastValidOrientation = "portrait"
     var focusView: UIView?
     var isFocusAnimating = false
+    var focusCompletionTimer: Timer?
+    var lastFocusTime: Date = Date()
+    private let focusThrottleInterval: TimeInterval = 0.5
     @objc func initialize(_ call: CAPPluginCall) {
         // Initialize a camera view for previewing video.
         DispatchQueue.main.sync {
@@ -152,6 +155,10 @@ public class CameraPreviewPlugin: CAPPlugin, AVCaptureVideoDataOutputSampleBuffe
             // If the input can be added, add it to the session.
             if self.captureSession.canAddInput(videoInput) {
                 self.captureSession.addInput(videoInput)
+                
+                // Configure camera device for optimal focus performance
+                try self.configureCameraForOptimalFocus(device: videoDevice)
+                
                 self.previewView.videoPreviewLayer.session = self.captureSession
                 self.previewView.videoPreviewLayer.videoGravity = AVLayerVideoGravity.resizeAspectFill
                 
@@ -169,7 +176,12 @@ public class CameraPreviewPlugin: CAPPlugin, AVCaptureVideoDataOutputSampleBuffe
                 
                 self.photoOutput = AVCapturePhotoOutput()
                 self.photoOutput.isHighResolutionCaptureEnabled = true
-                //self.photoOutput.
+                
+                // Configure photo output for better focus
+                if #available(iOS 13.0, *) {
+                    self.photoOutput.maxPhotoQualityPrioritization = .quality
+                }
+                
                 if self.captureSession.canAddOutput(self.photoOutput) {
                     self.captureSession.addOutput(photoOutput)
                 }
@@ -195,13 +207,100 @@ public class CameraPreviewPlugin: CAPPlugin, AVCaptureVideoDataOutputSampleBuffe
             print(error)
         }
     }
+    
+    private func configureCameraForOptimalFocus(device: AVCaptureDevice) throws {
+        try device.lockForConfiguration()
+        
+        // Set optimal focus mode for continuous operation
+        if device.isFocusModeSupported(.continuousAutoFocus) {
+            device.focusMode = .continuousAutoFocus
+        }
+        
+        // Set optimal exposure mode
+        if device.isExposureModeSupported(.continuousAutoExposure) {
+            device.exposureMode = .continuousAutoExposure
+        }
+        
+        // Enable subject area change monitoring for responsive focus
+        device.isSubjectAreaChangeMonitoringEnabled = true
+        
+        // Configure white balance for better color accuracy
+        if device.isWhiteBalanceModeSupported(.continuousAutoWhiteBalance) {
+            device.whiteBalanceMode = .continuousAutoWhiteBalance
+        }
+        
+        // Set focus range restriction if supported (helps with faster focus)
+        if device.isAutoFocusRangeRestrictionSupported {
+            device.autoFocusRangeRestriction = .none // Allow full range for versatility
+        }
+        
+        // Enable smooth auto focus if available (iOS 7+)
+        if device.isSmoothAutoFocusSupported {
+            device.isSmoothAutoFocusEnabled = true
+        }
+        
+        device.unlockForConfiguration()
+    }
+    
     func takePhotoWithAVFoundation(){
         //self.captureSession.sessionPreset = AVCaptureSession.Preset.hd4K3840x2160
         let photoSettings: AVCapturePhotoSettings
-        photoSettings = AVCapturePhotoSettings()
+        
+        // Use HEIF format if available for better quality
+        if #available(iOS 11.0, *), self.photoOutput.availablePhotoCodecTypes.contains(.hevc) {
+            photoSettings = AVCapturePhotoSettings(format: [AVVideoCodecKey: AVVideoCodecType.hevc])
+        } else {
+            photoSettings = AVCapturePhotoSettings()
+        }
+        
         photoSettings.isHighResolutionPhotoEnabled = true
         
-        self.photoOutput.capturePhoto(with: photoSettings, delegate: self)
+        // Enable auto-focus before capture for better focus accuracy
+        if #available(iOS 11.0, *) {
+            photoSettings.photoQualityPrioritization = .quality
+        }
+        
+        // Enable auto-focus and auto-exposure for optimal capture
+        if #available(iOS 14.1, *) {
+            photoSettings.isAutoContentAwareDistortionCorrectionEnabled = true
+        }
+        
+        // Trigger focus before capture if the device supports it
+        let device = self.videoInput.device
+        if device.isFocusModeSupported(.autoFocus) {
+            do {
+                try device.lockForConfiguration()
+                
+                // Temporarily switch to autoFocus for the photo capture
+                let previousFocusMode = device.focusMode
+                device.focusMode = .autoFocus
+                
+                device.unlockForConfiguration()
+                
+                // Wait a brief moment for focus to settle, then capture
+                DispatchQueue.main.asyncAfter(deadline: .now() + 0.1) {
+                    self.photoOutput.capturePhoto(with: photoSettings, delegate: self)
+                    
+                    // Restore previous focus mode after a short delay
+                    DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {
+                        do {
+                            try device.lockForConfiguration()
+                            device.focusMode = previousFocusMode
+                            device.unlockForConfiguration()
+                        } catch {
+                            print("Could not restore focus mode: \(error)")
+                        }
+                    }
+                }
+            } catch {
+                // If focus configuration fails, capture anyway
+                print("Could not configure focus for capture: \(error)")
+                self.photoOutput.capturePhoto(with: photoSettings, delegate: self)
+            }
+        } else {
+            // Capture immediately if auto focus isn't supported
+            self.photoOutput.capturePhoto(with: photoSettings, delegate: self)
+        }
     }
     
     public func photoOutput(_ output: AVCapturePhotoOutput, didFinishProcessingPhoto photo: AVCapturePhoto, error: Error?) {
@@ -545,6 +644,12 @@ public class CameraPreviewPlugin: CAPPlugin, AVCaptureVideoDataOutputSampleBuffe
         if let x = call.getFloat("x"), let y = call.getFloat("y"),
            x >= 0.0 && x <= 1.0, y >= 0.0 && y <= 1.0 {
             let point = CGPoint(x: CGFloat(x), y: CGFloat(y))
+            
+            // Check if focus is currently animating and reset if stuck
+            if isFocusAnimating {
+                resetFocusIfStuck()
+            }
+            
             focusWithPoint(point: point)
             
             // Calculate the point in the preview layer's coordinate space
@@ -557,6 +662,35 @@ public class CameraPreviewPlugin: CAPPlugin, AVCaptureVideoDataOutputSampleBuffe
         }
     }
     
+    private func resetFocusIfStuck() {
+        // Remove any existing focus indicator
+        focusView?.removeFromSuperview()
+        focusCompletionTimer?.invalidate()
+        isFocusAnimating = false
+        
+        // Reset focus to continuous mode
+        let device = self.videoInput.device
+        do {
+            try device.lockForConfiguration()
+            if device.isFocusModeSupported(.continuousAutoFocus) {
+                device.focusMode = .continuousAutoFocus
+            }
+            device.unlockForConfiguration()
+        } catch {
+            print("Could not reset focus: \(error)")
+        }
+    }
+    
+    @objc func resetFocus(_ call: CAPPluginCall) {
+        resetFocusIfStuck()
+        
+        // Reset to center focus
+        let centerPoint = CGPoint(x: 0.5, y: 0.5)
+        focusWithPoint(point: centerPoint)
+        
+        call.resolve()
+    }
+    
     @objc func handleTapToFocus(_ gesture: UITapGestureRecognizer) {
         let location = gesture.location(in: self.previewView)
         let convertedPoint = self.previewView.videoPreviewLayer.captureDevicePointConverted(fromLayerPoint: location)
@@ -567,55 +701,114 @@ public class CameraPreviewPlugin: CAPPlugin, AVCaptureVideoDataOutputSampleBuffe
     
     func focusWithPoint(point: CGPoint) {
         let device = self.videoInput.device
+        
+        let now = Date()
+        if now.timeIntervalSince(lastFocusTime) < focusThrottleInterval {
+            return
+        }
+        lastFocusTime = now
+        
         do {
             try device.lockForConfiguration()
             
+            focusCompletionTimer?.invalidate()
+            
             if device.isFocusPointOfInterestSupported {
                 device.focusPointOfInterest = point
-                device.focusMode = .autoFocus
+                
+                if device.isFocusModeSupported(.continuousAutoFocus) {
+                    device.focusMode = .continuousAutoFocus
+                } else if device.isFocusModeSupported(.autoFocus) {
+                    device.focusMode = .autoFocus
+                } else {
+                    device.focusMode = .locked
+                }
+                
+                if device.focusMode == .autoFocus {
+                    NotificationCenter.default.addObserver(
+                        self,
+                        selector: #selector(subjectAreaDidChange),
+                        name: .AVCaptureDeviceSubjectAreaDidChange,
+                        object: device
+                    )
+                }
             }
             
             if device.isExposurePointOfInterestSupported {
                 device.exposurePointOfInterest = point
-                device.exposureMode = .continuousAutoExposure
+                
+                if device.isExposureModeSupported(.continuousAutoExposure) {
+                    device.exposureMode = .continuousAutoExposure
+                } else if device.isExposureModeSupported(.autoExpose) {
+                    device.exposureMode = .autoExpose
+                }
             }
             
+            device.isSubjectAreaChangeMonitoringEnabled = true
+            
             device.unlockForConfiguration()
             
+            focusCompletionTimer = Timer.scheduledTimer(withTimeInterval: 2.0, repeats: false) { [weak self] _ in
+                DispatchQueue.main.async {
+                    self?.hideFocusIndicatorWithCompletion()
+                }
+            }
+            
         } catch {
             print("Could not focus: \(error.localizedDescription)")
         }
     }
     
+    @objc private func subjectAreaDidChange(notification: NSNotification) {
+        DispatchQueue.main.async { [weak self] in
+            self?.hideFocusIndicatorWithCompletion()
+        }
+        
+        NotificationCenter.default.removeObserver(self, name: .AVCaptureDeviceSubjectAreaDidChange, object: notification.object)
+    }
+    
+    private func hideFocusIndicatorWithCompletion() {
+        guard let focusView = self.focusView else { return }
+        
+        UIView.animate(withDuration: 0.2, animations: {
+            focusView.alpha = 0.0
+            focusView.transform = CGAffineTransform(scaleX: 0.8, y: 0.8)
+        }) { _ in
+            focusView.removeFromSuperview()
+            focusView.transform = CGAffineTransform.identity
+            self.isFocusAnimating = false
+        }
+    }
+    
     func showFocusView(at point: CGPoint) {
         if isFocusAnimating {
             self.focusView?.removeFromSuperview()
+            focusCompletionTimer?.invalidate()
         }
         
-        // Create focus view if needed
+        // Create focus view if needed - but make it invisible
         if self.focusView == nil {
-            self.focusView = UIView(frame: CGRect(x: 0, y: 0, width: 75, height: 75))
-            self.focusView?.layer.borderColor = UIColor.yellow.cgColor
-            self.focusView?.layer.borderWidth = 1.0
+            self.focusView = UIView(frame: CGRect(x: 0, y: 0, width: 80, height: 80))
+            // Make the focus view completely transparent
+            self.focusView?.layer.borderColor = UIColor.clear.cgColor
+            self.focusView?.layer.borderWidth = 0.0
+            self.focusView?.layer.cornerRadius = 40
             self.focusView?.backgroundColor = .clear
+            self.focusView?.alpha = 0.0
+            
+            // Remove the inner circle to make it completely invisible
+            // No inner circle added
         }
         
         self.focusView?.center = point
-        self.focusView?.alpha = 0.0
+        self.focusView?.alpha = 0.0  // Keep invisible
+        self.focusView?.transform = CGAffineTransform.identity
         self.previewView.addSubview(self.focusView!)
         
         self.isFocusAnimating = true
         
-        UIView.animate(withDuration: 0.3, delay: 0.0, options: .curveEaseInOut, animations: {
-            self.focusView?.alpha = 1.0
-        }, completion: { _ in
-            UIView.animate(withDuration: 0.3, delay: 0.5, options: .curveEaseInOut, animations: {
-                self.focusView?.alpha = 0.0
-            }, completion: { _ in
-                self.focusView?.removeFromSuperview()
-                self.isFocusAnimating = false
-            })
-        })
+        // Skip the animation since the view is invisible
+        // Focus functionality still works, just no visual feedback
     }
     
     @objc func requestCameraPermission(_ call: CAPPluginCall) {
@@ -718,4 +911,9 @@ public class CameraPreviewPlugin: CAPPlugin, AVCaptureVideoDataOutputSampleBuffe
         takePhotoWithAVFoundation()
     }
     
+    deinit {
+        NotificationCenter.default.removeObserver(self)
+        focusCompletionTimer?.invalidate()
+    }
+    
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "capacitor-plugin-camera-forked",
-  "version": "3.0.8",
+  "version": "3.0.10",
   "description": "A capacitor camera plugin - A custom Capacitor camera plugin with additional features.",
   "main": "dist/plugin.cjs.js",
   "module": "dist/esm/index.js",
@@ -13,7 +13,7 @@
     "ios/Plugin/",
     "CapacitorPluginCameraForked.podspec"
   ],
-  "author": "Lihang Xu + Addons",
+  "author": "Lihang Xu + Modified",
   "license": "MIT",
   "repository": {
     "type": "git",