camera view face detection #282
Conversation
📝 WalkthroughWalkthroughThis pull request adds comprehensive real-time face detection and tracking capabilities to a Capacitor camera preview plugin across Android (via ML Kit), iOS (via Vision framework), and web (stub) platforms. Includes TypeScript type definitions, service integration, and a full example UI component for face detection visualization. Changes
Sequence Diagram(s)sequenceDiagram
actor User
participant Plugin as Camera Plugin
participant Detector as Face Detector<br/>(ML Kit/Vision)
participant Listener as Event Listener
participant App as App Component
User->>Plugin: enableFaceDetection(options)
activate Plugin
Plugin->>Detector: Initialize detector with options
deactivate Plugin
loop Continuous Frame Processing
Detector->>Detector: Capture frame from camera
Detector->>Detector: Analyze for faces
alt Faces Detected
Detector->>Detector: Extract bounds, landmarks,<br/>angles, probabilities
Detector->>Listener: onFacesDetected(faces, metadata)
Listener->>App: Propagate event
App->>App: Update UI overlay &<br/>render faces
else Detection Error
Detector->>Listener: onFaceDetectionError(message)
Listener->>App: Propagate error
end
end
User->>Plugin: disableFaceDetection()
activate Plugin
Plugin->>Detector: Teardown detector &<br/>release resources
deactivate Plugin
Estimated Code Review Effort🎯 4 (Complex) | ⏱️ ~75 minutes The changes span multiple platforms with heterogeneous implementations (Android ML Kit integration with frame-skipping logic, iOS Vision framework with custom FaceTracker state management and probability estimation), introduce significant new logic density across 8+ public type definitions, expand 3 core classes across platforms, and include a full-featured Angular component with canvas rendering and event handling. Requires careful validation of platform-specific behavior, state management correctness, and API surface consistency. Possibly Related PRs
Poem
Pre-merge checks and finishing touches❌ Failed checks (1 warning, 1 inconclusive)
✅ Passed checks (1 passed)
✨ Finishing touches
Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out. Comment |
|
Review the following changes in direct dependencies. Learn more about Socket for GitHub.
|
|
Warning Review the following alerts detected in dependencies. According to your organization's Security Policy, it is recommended to resolve "Warn" alerts. Learn more about Socket for GitHub.
|
![coderabbitai[bot]](https://avatars.githubusercontent.com/in/347564?s=60&v=4){kind=small}
There was a problem hiding this comment.
Actionable comments posted: 17
Fix all issues with AI Agents 🤖
In @android/src/main/java/app/capgo/capacitor/camera/preview/CameraPreview.java:
- Around line 2042-2049: The current else branch returns a JSObject claiming all
capabilities are true when cameraXView is null; instead, either return
supported:false with all capability flags false or reject the call to match
other methods—update the null-handling in CameraPreview (where cameraXView is
checked and the code currently builds JSObject and calls call.resolve) to either
build a JSObject with ret.put("supported", false) and set
landmarks/contours/classification/tracking to false, then call
call.resolve(ret), or replace that resolve with call.reject("Camera is not
running") to signal the camera isn't initialized; ensure you modify the branch
that currently ends with call.resolve(ret) so it no longer reports capabilities
as true when cameraXView is null.
In @android/src/main/java/app/capgo/capacitor/camera/preview/CameraXView.java:
- Around line 3622-3625: The ImageAnalysis executor is leaked because a new
Executors.newSingleThreadExecutor() is created for faceDetectionAnalysis without
being stored or shutdown; modify the class to add a field (e.g.,
faceDetectionExecutor), assign Executors.newSingleThreadExecutor() in the
enableFaceDetection sequence and pass that executor to
faceDetectionAnalysis.setAnalyzer(..., faceDetectionAnalyzer), and then in
disableFaceDetection shut down the executor (faceDetectionExecutor.shutdownNow()
or shutdown() and null it) and clear references to faceDetectionAnalysis and
faceDetectionAnalyzer to avoid thread leaks.
In
@android/src/main/java/app/capgo/capacitor/camera/preview/FaceDetectionAnalyzer.java:
- Around line 32-33: Replace the non-thread-safe fields in
FaceDetectionAnalyzer: change frameCounter to an AtomicInteger and isProcessing
to an AtomicBoolean, then update all accesses to use atomic operations (e.g.,
frameCounter.incrementAndGet()/get() and isProcessing.compareAndSet(false,
true)/set(false)) inside the camera callback and processing logic so checks and
updates are atomic and avoid race conditions across camera callback threads.
- Around line 63-70: Update the FaceDetectionAnalyzer constructor to accept an
int detectionInterval parameter (e.g., change
FaceDetectionAnalyzer(FaceDetectorOptions options, FaceDetectionListener
listener) to FaceDetectionAnalyzer(FaceDetectorOptions options,
FaceDetectionListener listener, int detectionInterval)), assign the passed
detectionInterval to this.detectionInterval, and remove the call to
optionsToJson(options) inside the constructor; also remove or ignore the
placeholder optionsToJson() usage for configuring detectionInterval. Then update
the instantiation site(s) (e.g., where CameraXView creates new
FaceDetectionAnalyzer) to pass the user-provided detectionInterval extracted
from options instead of relying on the placeholder method. Ensure no other code
depends on optionsToJson() for detectionInterval.
In @ios/Sources/CapgoCameraPreviewPlugin/CameraController.swift:
- Around line 2847-2855: The capabilities map in getFaceDetectionCapabilities
currently claims "contours": true but handleFaceDetectionRequest does not
populate contour data; either implement contour extraction and add a "contours"
field to each face dictionary in handleFaceDetectionRequest (extract and format
contour points from available landmarks or Vision face contours) or change
getFaceDetectionCapabilities to return "contours": false to reflect current
behavior; update the symbol getFaceDetectionCapabilities and/or
handleFaceDetectionRequest accordingly so the declared capabilities match the
actual face result shape.
- Around line 2686-2708: The face detection code extracts imageWidth and
imageHeight but never passes them to the result handler, so
handleFaceDetectionRequest is using hardcoded 1920x1080; update the async block
that performs requestHandler.perform([request]) to pass the actual dimensions to
handleFaceDetectionRequest (or attach them to the VNRequest via request.results
or request.preferBackgroundProcessing attachments) so handleFaceDetectionRequest
receives imageWidth and imageHeight instead of relying on hardcoded values;
reference the faceDetectionRequest, VNImageRequestHandler, and
handleFaceDetectionRequest symbols when making the change.
- Around line 180-181: Remove the unused VNSequenceRequestHandler instance:
delete the private var sequenceRequestHandler property and remove any
assignments/uses of VNSequenceRequestHandler in enableFaceDetection and
disableFaceDetection; leave processFaceDetection as-is (it uses
VNImageRequestHandler) unless you intentionally want to switch to
VNSequenceRequestHandler—in that case replace VNImageRequestHandler with
sequenceRequestHandler usage inside processFaceDetection and ensure
sequenceRequestHandler is properly initialized in enableFaceDetection and
cleared in disableFaceDetection.
- Around line 10-88: FaceTracker is not thread-safe: trackedFaces and nextID are
mutated/read from background and main threads; protect all accesses with a lock.
Add a private serial DispatchQueue (e.g., syncQueue) or NSLock property on
FaceTracker and wrap any read/write operations that touch trackedFaces or nextID
— including assignTrackingIDs, reset, and findMatchingFace (or call
findMatchingFace only while holding the lock) — using syncQueue.sync (or
lock/unlock) so mutation and matching are serialized and data races are
eliminated. Ensure assignTrackingIDs returns assignedIDs after the synchronized
block.
- Around line 2863-2891: In estimateSmileProbability(from:) replace the
hardcoded index accesses on outerLips with contour-based detection: treat
outerLips as an unordered contour, compute the leftCorner as the point with
minimum x and rightCorner as maximum x, compute mouthTop and mouthBottom as the
points with minimum and maximum y (or compute the centroid and choose the
nearest points above/below it for robustness), then use those computed points to
derive mouthWidth and mouthHeight and the ratio; keep the existing
ratio-to-probability logic and guards (mouthHeight > 0) but remove any reliance
on fixed indices like outerLips[0], [6], [3], [9].
In @ios/Sources/CapgoCameraPreviewPlugin/Plugin.swift:
- Around line 2245-2249: The current check uses value != 0.0 to detect a missing
parameter and therefore incorrectly rejects the valid exposure 0.0; instead,
retrieve the parameter as an optional (use the variant of call.getFloat that
returns nil when absent or check call.has("value")), guard let value = ... to
detect truly missing input, then compute an adjustedValue if needed and use
adjustedValue in the subsequent logic (replace references to the old value
variable with adjustedValue); update the guard to only reject when the parameter
is actually absent, not when it equals 0.0.
- Around line 10-17: The CAPPluginCall.reject extension is overriding the native
method and incorrectly calls resolve(), breaking error semantics; remove this
extension (or rename and/or conditionally compile it for Capacitor 7) and ensure
all places call the built-in CAPPluginCall.reject(_:code:error:) or reject(_: )
directly (e.g., call.reject("message")), so errors properly reject the JS
promise rather than resolving with an error object; if you must support
Capacitor 7, add an explicit compatibility shim guarded by a compile-time check
and expose a differently named helper instead of shadowing CAPPluginCall.reject.
In @ios/Tests/CameraPreviewPluginTests/CameraPreviewPluginTests.swift:
- Around line 9-10: Replace the placeholder XCTAssertTrue(true) in
CameraPreviewPluginTests with real unit tests that exercise the CameraPreview
plugin lifecycle and new face-detection APIs: instantiate the plugin
(CameraPreviewPlugin) and test initialization/start/stop behavior, call
enableFaceDetection and disableFaceDetection and assert expected state changes
or callbacks, call getFaceDetectionCapabilities and assert returned capability
fields, validate the shape and types of a face-tracking payload returned by the
plugin (e.g., face IDs, boundingBox, landmarks), and add tests that pass invalid
configurations to enableFaceDetection to assert proper error handling; implement
these as individual XCTest methods inside CameraPreviewPluginTests using
mocks/stubs for any camera or detector dependencies and assert expected
events/errors.
In @README.md:
- Around line 225-226: The README contains broken references to
FACE_DETECTION_EXAMPLE.md and FACE_DETECTION_DEMO_GUIDE.md; either create those
two markdown files with the appropriate example and demo guide content (ensuring
filenames exactly match FACE_DETECTION_EXAMPLE.md and
FACE_DETECTION_DEMO_GUIDE.md and include headings, usage steps, and any required
code snippets), or remove/update the two lines in README.md that reference
**Basic face detection** and **Interactive demo** so they no longer link to
non-existent files (or replace them with links to existing docs); ensure the
README no longer points to missing resources.
- Around line 996-1014: The "Since: 8.1.0" annotation in the
addListener('onFacesDetected', ...) docs is incorrect; update the Since field to
the actual version this feature was introduced (e.g., 8.0.5) or remove the Since
line if this is being added for the next unreleased version, ensuring the change
is applied to the addListener('onFacesDetected', listenerFunc) section so the
documentation matches the package/CHANGELOG history.
In @src/web.ts:
- Around line 1254-1260: The enableFaceDetection method currently types its
parameter as any; change the signature async enableFaceDetection(_options?:
any): Promise<void> to use the FaceDetectionOptions type (async
enableFaceDetection(_options?: FaceDetectionOptions): Promise<void>), import
FaceDetectionOptions from './definitions' at the top of the file, and keep or
adjust the existing void _options; line so the unused-parameter pattern remains
valid after the type change.
Caution
Some comments are outside the diff and can’t be posted inline due to platform limitations.
⚠️ Outside diff range comments (1)
ios/Sources/CapgoCameraPreviewPlugin/Plugin.swift (1)
2125-2131: Bug: Valid focus coordinate (0, 0) incorrectly rejected.The condition
xCoord != 0.0 && yCoord != 0.0rejects when either coordinate is zero. However,(0, 0)represents the top-left corner and is a valid normalized focus point.🔎 Proposed fix
- let xCoord = call.getFloat("x", 0.0) - let yCoord = call.getFloat("y", 0.0) - guard xCoord != 0.0 && yCoord != 0.0 else { + guard let xCoord = call.getFloat("x"), + let yCoord = call.getFloat("y") else { call.reject("x and y parameters are required") return }
🧹 Nitpick comments (11)
package.json (1)
69-71: Add*.jsonto the Prettier script glob pattern to enable packagejson plugin.You've added
prettier-plugin-packagejsonto formatpackage.json, but Line 46's glob pattern"**/*.{css,html,ts,js,java}"doesn't include.jsonfiles, so the plugin won't apply when runningnpm run prettierornpm run fmt.🔎 Proposed fix to include JSON files
- "prettier": "prettier-pretty-check \"**/*.{css,html,ts,js,java}\" --plugin=prettier-plugin-java", + "prettier": "prettier-pretty-check \"**/*.{css,html,ts,js,java,json}\" --plugin=prettier-plugin-java",example-app/src/app/pages/face-detection/face-detection.page.html (2)
19-27: Consider adding ARIA label for better accessibility.The Start/Stop detection button could benefit from an explicit ARIA label to clarify its purpose for screen reader users.
🔎 Suggested enhancement
<ion-button expand="block" [color]="isDetecting() ? 'danger' : 'success'" (click)="toggleDetection()" size="large" + [attr.aria-label]="isDetecting() ? 'Stop face detection' : 'Start face detection'" > <ion-icon [icon]="isDetecting() ? stop : play" slot="start"></ion-icon> {{ isDetecting() ? 'Stop Detection' : 'Start Detection' }} </ion-button>
152-192: Consider extracting inline styles to CSS classes.The inline
style="margin-left: 10px"on lines 152, 155, 158, 185, 187, 189, 191 could be replaced with a CSS class for better maintainability.🔎 Suggested refactor
In the SCSS file:
.indented { margin-left: 10px; }Then in the template:
<p class="indented">Yaw: {{ face.angles.yaw.toFixed(1) }}°</p> <p class="indented">Pitch: {{ face.angles.pitch.toFixed(1) }}°</p> <p class="indented">Roll: {{ face.angles.roll.toFixed(1) }}°</p>example-app/src/app/core/capacitor-camera-preview.service.ts (1)
377-409: Consider more specific return type for onFacesDetected.The
onFacesDetectedmethod returnsPromise<any>. Based on the Capacitor pattern ofaddListenerreturning aPluginListenerHandle, the return type could be more specific.🔎 Suggested improvement
+import { PluginListenerHandle } from '@capacitor/core'; /** * Listen to face detection events * @param callback Callback function to be called when faces are detected */ - async onFacesDetected(callback: (event: FaceDetectionEvent) => void): Promise<any> { + async onFacesDetected(callback: (event: FaceDetectionEvent) => void): Promise<PluginListenerHandle> { return this.#cameraView.addListener('onFacesDetected', callback); }ios/Sources/CapgoCameraPreviewPlugin/Plugin.swift (2)
261-264: Deprecated API:UIApplication.shared.windowsis deprecated in iOS 15+.Use
UIWindowScene-based approach for forward compatibility.🔎 Proposed fix
- guard let viewController = UIApplication.shared.windows.first(where: { $0.isKeyWindow })?.rootViewController else { + guard let windowScene = UIApplication.shared.connectedScenes.first(where: { $0.activationState == .foregroundActive }) as? UIWindowScene, + let viewController = windowScene.windows.first(where: { $0.isKeyWindow })?.rootViewController else { completion?() return }
770-777: Redundant nil checks with non-optional defaults.
call.getString("aspectRatio", "")returns a non-optionalString, so checking!= nilis always true. These checks don't detect whether the parameter was explicitly provided.🔎 Clarification
If the intent is to detect whether the parameter was explicitly passed (vs using default), consider using
call.options["aspectRatio"] != nilorcall.hasOption("aspectRatio")if available in Capacitor's API.example-app/src/app/pages/face-detection/face-detection.page.ts (3)
85-87: Type the listener properly instead of usingany.The listener should be typed as
PluginListenerHandlefrom Capacitor for better type safety.🔎 Proposed fix
+import { PluginListenerHandle } from '@capacitor/core'; ... - private faceDetectionListener: any; + private faceDetectionListener: PluginListenerHandle | null = null;
196-197: Unused variablesscaleXandscaleY.These scale factors are calculated but never used. The face bounds are already normalized (0-1), so direct multiplication by canvas dimensions (lines 201-204) is correct. Remove the unused variables.
🔎 Proposed fix
- const scaleX = this.canvas.width / event.frameWidth; - const scaleY = this.canvas.height / event.frameHeight; - for (const face of event.faces) {
169-185: Animation loop clears canvas but draws nothing.
drawOverlaysets up an animation loop that only clears/resizes the canvas. The actual face drawing happens indrawFaces, called from the event handler. This creates an unnecessary animation loop that wastes CPU cycles. Consider removing the loop or integrating the draw logic.🔎 Explanation
The current flow:
drawOverlayruns continuously viarequestAnimationFramedrawFacesis called on each face detection eventSince faces are only drawn when events arrive, the continuous loop adds no value. Either:
- Remove the loop and just initialize the canvas once, or
- Move face drawing into the loop and store faces in a signal that the loop reads
ios/Sources/CapgoCameraPreviewPlugin/CameraController.swift (2)
57-58: Redundant nil initialization.Optionals in Swift are
nilby default; the explicit= nilis unnecessary.Proposed fix
- private func findMatchingFace(bounds: CGRect) -> Int? { - var bestMatch: (index: Int, overlap: CGFloat)? = nil + private func findMatchingFace(bounds: CGRect) -> Int? { + var bestMatch: (index: Int, overlap: CGFloat)?
2632-2642: Dead code: Both branches of theenableLandmarksconditional create identical requests.The
if enableLandmarksandelsebranches both createVNDetectFaceLandmarksRequest. Additionally,enableClassificationis read but not used to configure anything.Proposed fix: Simplify the request creation
- let enableLandmarks = options["enableLandmarks"] as? Bool ?? false - let enableClassification = options["enableClassification"] as? Bool ?? false - - // Create face detection request - if enableLandmarks { - faceDetectionRequest = VNDetectFaceLandmarksRequest(completionHandler: handleFaceDetectionRequest) - } else { - // Use landmarks request even when landmarks not explicitly requested - // as VNDetectFaceRectanglesRequest is a different type - faceDetectionRequest = VNDetectFaceLandmarksRequest(completionHandler: handleFaceDetectionRequest) - } + // Always use landmarks request for full feature support + faceDetectionRequest = VNDetectFaceLandmarksRequest(completionHandler: handleFaceDetectionRequest)
📜 Review details
Configuration used: defaults
Review profile: CHILL
Plan: Pro
⛔ Files ignored due to path filters (1)
bun.lockis excluded by!**/*.lock
📒 Files selected for processing (20)
README.mdandroid/build.gradleandroid/src/main/java/app/capgo/capacitor/camera/preview/CameraPreview.javaandroid/src/main/java/app/capgo/capacitor/camera/preview/CameraXView.javaandroid/src/main/java/app/capgo/capacitor/camera/preview/FaceDetectionAnalyzer.javaexample-app/src/app/app.routes.tsexample-app/src/app/components/tabs/tabs.component.htmlexample-app/src/app/core/capacitor-camera-preview.service.tsexample-app/src/app/pages/face-detection/face-detection.page.htmlexample-app/src/app/pages/face-detection/face-detection.page.scssexample-app/src/app/pages/face-detection/face-detection.page.tsios/Sources/CapgoCameraPreviewPlugin/CameraController.swiftios/Sources/CapgoCameraPreviewPlugin/Plugin.swiftios/Tests/CameraPreviewPluginTests/CameraPreviewPluginTests.swiftios/capacitor-cordova-ios-plugins/CordovaPluginsResources.podspecios/capacitor-cordova-ios-plugins/resources/.gitkeepios/capacitor-cordova-ios-plugins/sources/.gitkeeppackage.jsonsrc/definitions.tssrc/web.ts
🧰 Additional context used
🧠 Learnings (1)
📚 Learning: 2025-08-29T15:37:50.891Z
Learnt from: Dalanir
Repo: Cap-go/capacitor-camera-preview PR: 217
File: ios/Sources/CapgoCameraPreviewPlugin/CameraController.swift:1242-1246
Timestamp: 2025-08-29T15:37:50.891Z
Learning: In the iOS CameraController.swift handleTap method, the team wants to maintain the current behavior that forces exposureMode to .autoExpose and resets exposureTargetBias to 0.0 when tapping to focus, even though it overrides the user's current exposure mode setting.
Applied to files:
README.mdios/Sources/CapgoCameraPreviewPlugin/Plugin.swiftios/Sources/CapgoCameraPreviewPlugin/CameraController.swift
🧬 Code graph analysis (4)
example-app/src/app/core/capacitor-camera-preview.service.ts (1)
src/definitions.ts (3)
FaceDetectionOptions(477-514)FaceDetectionCapabilities(519-530)FaceDetectionEvent(463-472)
android/src/main/java/app/capgo/capacitor/camera/preview/FaceDetectionAnalyzer.java (1)
example-app/src/app/core/capacitor-camera-preview.service.ts (1)
onFacesDetected(407-409)
example-app/src/app/pages/face-detection/face-detection.page.ts (4)
src/definitions.ts (3)
DetectedFace(443-458)FaceDetectionCapabilities(519-530)FaceDetectionEvent(463-472)example-app/src/app/core/capacitor-camera-preview.service.ts (1)
isRunning(77-79)ios/Sources/CapgoCameraPreviewPlugin/Plugin.swift (1)
isRunning(1525-1528)src/web.ts (1)
isRunning(721-724)
ios/Sources/CapgoCameraPreviewPlugin/CameraController.swift (2)
example-app/src/app/core/capacitor-camera-preview.service.ts (5)
isFaceDetectionEnabled(391-394)onFacesDetected(407-409)enableFaceDetection(377-379)disableFaceDetection(384-386)getFaceDetectionCapabilities(399-401)src/web.ts (4)
isFaceDetectionEnabled(1266-1268)enableFaceDetection(1255-1260)disableFaceDetection(1262-1264)getFaceDetectionCapabilities(1270-1284)
🪛 SwiftLint (0.57.0)
ios/Sources/CapgoCameraPreviewPlugin/CameraController.swift
[Warning] 58-58: Initializing an optional variable with nil is redundant
(redundant_optional_initialization)
⏰ Context from checks skipped due to timeout of 90000ms. You can increase the timeout in your CodeRabbit configuration to a maximum of 15 minutes (900000ms). (1)
- GitHub Check: build_android
🔇 Additional comments (41)
ios/Tests/CameraPreviewPluginTests/CameraPreviewPluginTests.swift (1)
2-2: LGTM: Import statement updated correctly.The module import has been updated to
CapgoCameraPreview, aligning with the broader refactoring in this PR.package.json (1)
69-71: Prettier plugins are using current stable versions with no known vulnerabilities.All three packages are at their latest stable releases:
[email protected](latest)[email protected](latest)[email protected](latest)npm audit reports no known vulnerabilities for these packages. All three are actively maintained with recent updates.
ios/capacitor-cordova-ios-plugins/resources/.gitkeep (1)
1-1: Standard directory placeholder.The
.gitkeepfile is a conventional way to preserve empty directories in Git. This is appropriate for maintaining the directory structure for iOS plugin resources.example-app/src/app/app.routes.ts (1)
16-22: LGTM! Route configuration is consistent.The new face-detection route follows the established lazy-loading pattern and is properly integrated into the routing structure.
example-app/src/app/components/tabs/tabs.component.html (1)
7-10: LGTM! Tab configuration is consistent.The new face detection tab follows the established pattern and integrates cleanly with the existing navigation structure. The "scan-sharp" icon is an appropriate choice for face detection functionality.
README.md (6)
29-29: LGTM! Clear feature highlight.The face detection feature is prominently listed in the feature set with appropriate emphasis.
182-209: Example code looks correct and comprehensive.The quick start example demonstrates the key API methods (enableFaceDetection, addListener, disableFaceDetection) with clear comments explaining the face detection data structure. The code follows best practices for async/await and cleanup.
429-443: LGTM! API index properly updated.All new face detection methods and the listener event are correctly added to the documentation index with appropriate formatting and links.
1169-1227: LGTM! Face detection method documentation is complete.All four face detection methods are properly documented with:
- Correct TypeScript signatures
- Clear descriptions
- Appropriate parameter and return type references
- Consistent versioning (8.1.0)
1393-1470: LGTM! Face detection data structure documentation is thorough.The interface documentation for face detection events and data structures is comprehensive:
- All properties are clearly described
- Coordinate normalization (0-1) is properly documented
- Probability ranges are specified
- Landmark points are well-defined
1484-1510: LGTM! Configuration and capability interfaces are well-documented.The
FaceDetectionOptionsandFaceDetectionCapabilitiesinterfaces provide clear configuration parameters with sensible defaults and capability flags for platform-specific features.android/build.gradle (1)
65-67: ML Kit Face Detection dependency is already at the latest version.Version 16.1.7 is the latest stable release from Google's Maven repository (last updated August 2024). No public security vulnerabilities were found for this version. No action is required.
ios/capacitor-cordova-ios-plugins/CordovaPluginsResources.podspec (1)
1-10: Review podspec configuration and verify external git tag.This podspec references an external ionic-team/capacitor repository with tag
0.0.105, but no evidence of this podspec being used elsewhere in the codebase (no Podfile or Pod dependencies found). Before merging:
- Verify that tag
0.0.105exists in the ionic-team/capacitor repository- Confirm where and how this podspec is consumed in the build process (no local Podfile references found)
- Clarify if this is infrastructure for the face detection feature or a general dependency
The version schemes are independent (project: 8.0.5, podspec: 0.0.105), which is acceptable, but the apparent lack of integration points raises questions about necessity and correct configuration.
example-app/src/app/pages/face-detection/face-detection.page.scss (3)
1-24: LGTM! Solid overlay layout.The fixed positioning for canvas and control panel with appropriate z-index layering provides a good foundation for the face detection UI.
160-177: Webkit-only scrollbar styling is a progressive enhancement.Custom scrollbar styles only apply to Webkit browsers (Chrome, Safari, Edge). Firefox users will see default scrollbars, which is acceptable as a graceful degradation.
26-63: Color scheme provides good contrast.The bright green accent color (#00ff00) on dark backgrounds with white/gray text should provide adequate contrast for readability.
example-app/src/app/pages/face-detection/face-detection.page.html (2)
135-197: Good use of track-by for performance.The
@forloop properly usestrack face.trackingIdwhich helps Angular optimize DOM updates when faces are added/removed.
98-113: Good UX: toggles disabled during detection.Disabling the configuration toggles while detection is running prevents inconsistent state and potential runtime issues from changing options mid-stream.
src/web.ts (1)
1262-1284: Appropriate stub implementation strategy.The stubs correctly distinguish between action methods (throw errors) and query methods (return unsupported status), providing a graceful degradation path for cross-platform code.
example-app/src/app/core/capacitor-camera-preview.service.ts (2)
15-17: LGTM! Types properly imported.The face detection types are correctly imported from the package alongside other camera types.
372-401: Face detection methods well-structured and documented.The implementation follows the service pattern established for other camera features, with proper type annotations and JSDoc.
android/src/main/java/app/capgo/capacitor/camera/preview/FaceDetectionAnalyzer.java (3)
77-140: Well-structured frame processing with proper resource management.The
analyzemethod correctly implements frame skipping, prevents concurrent processing, and ensuresimageProxyis always closed via try-finally blocks and failure handlers.
151-220: Robust face-to-JSON conversion with normalized coordinates.The conversion properly normalizes coordinates to 0-1 range for cross-platform consistency and handles optional fields (landmarks, classification) gracefully.
236-245: Resource cleanup is properly implemented.The
close()method correctly releases the ML Kit detector with error handling. Verification confirms it is called indisableFaceDetection()with proper null checking and nullification after cleanup.example-app/src/app/pages/face-detection/face-detection.page.ts (2)
114-151: Good implementation with proper async/await and error handling.The detection startup flow correctly checks camera state, enables detection with options, and subscribes to events. Error handling with user-friendly alerts is appropriate.
153-167: Cleanup logic is correct but could benefit from null safety.The listener removal and state reset are properly handled.
android/src/main/java/app/capgo/capacitor/camera/preview/CameraPreview.java (2)
1981-2013: Face detection methods follow existing patterns correctly.The
enableFaceDetectionanddisableFaceDetectionmethods properly check camera state before proceeding and handle exceptions appropriately.
2015-2024: Good null-safe implementation forisFaceDetectionEnabled.Returns
falsewhencameraXViewis null, which is the expected behavior.ios/Sources/CapgoCameraPreviewPlugin/Plugin.swift (1)
1646-1650: The zoom level validation is correct.The check rejecting
level == 0.0is not a bug. iOS devices'minAvailableVideoZoomFactoris always ≥ 1.0, making 0.0 an invalid zoom value on all supported devices. Using 0.0 as a sentinel to detect a missing parameter is appropriate, and the error message "level parameter is required" accurately reflects this intent. The actual range validation (lines 641 and 1684 in CameraController.swift) properly enforces device-specific min/max zoom constraints.android/src/main/java/app/capgo/capacitor/camera/preview/CameraXView.java (4)
118-119: LGTM: Clean interface extension for face detection callbacks.The new listener methods are well-defined and consistent with the existing callback pattern used in the interface.
155-160: LGTM: Appropriate fields for face detection state management.The fields are properly scoped and initialized for managing the face detection lifecycle.
3669-3704: LGTM with the executor fix noted above.The overall structure of the disable method is correct: it closes the analyzer and rebinds the camera without face detection. Once the executor shutdown is added, this will properly clean up resources.
3720-3732: LGTM: Capabilities accurately reflect ML Kit features.The hardcoded capabilities correctly represent what Google ML Kit supports on Android.
src/definitions.ts (5)
376-410: LGTM: Well-documented geometric types for face detection.The
Point,FaceBounds, andFaceAnglesinterfaces are cleanly designed with normalized coordinates (0-1) which is a good choice for cross-platform consistency. The JSDoc comments clearly explain the coordinate system and angle ranges.
412-458: LGTM: Comprehensive face detection data structures.The
FaceLandmarksandDetectedFaceinterfaces are well-structured with appropriately optional fields that align with the configurable detection options.
474-530: LGTM: Comprehensive options with good defaults and platform annotations.The
FaceDetectionOptionsinterface has sensible defaults documented (performanceMode: 'fast',enableTracking: true) and correctly notes thatenableContoursis Android-only. TheFaceDetectionCapabilitiesinterface provides a clean way to query platform support.
878-892: LGTM: Consistent listener pattern for face detection events.The
addListeneroverload for'onFacesDetected'follows the existing event listener pattern established byscreenResizeandorientationChangeevents.
972-1009: LGTM: Well-documented face detection API surface.The new plugin methods are thoroughly documented with JSDoc including
@sincetags and@platformannotations. The API design is clean and follows Capacitor plugin conventions.ios/Sources/CapgoCameraPreviewPlugin/CameraController.swift (3)
2439-2443: LGTM!Face detection is appropriately invoked on the video capture queue before other sample buffer processing. The conditional check ensures minimal overhead when detection is disabled.
2746-2754: LGTM with documentation note.The angle extraction correctly converts radians to degrees. The pitch value is documented as
0.0since Vision framework doesn't provide it directly. Consider adding a comment in the TypeScript definitions or documentation noting this iOS limitation.
90-94: LGTM!The
CGRect.areaextension is simple and correctly implemented for IoU calculations.
| try { | ||
| // Get options from call | ||
| JSObject options = call.getObject("options"); | ||
| JSONObject jsonOptions = options != null ? new JSONObject(options.toString()) : new JSONObject(); | ||
|
|
||
| cameraXView.enableFaceDetection(jsonOptions); | ||
| call.resolve(); |
There was a problem hiding this comment.
🧩 Analysis chain
🏁 Script executed:
# Search for TypeScript/JavaScript files that call enableFaceDetection
find . -type f \( -name "*.ts" -o -name "*.tsx" -o -name "*.js" -o -name "*.jsx" \) | head -20Repository: Cap-go/capacitor-camera-preview
Length of output: 206
🏁 Script executed:
# Look for enableFaceDetection usage in the codebase
rg -n "enableFaceDetection" --type ts --type tsx --type js --type jsx -C 3Repository: Cap-go/capacitor-camera-preview
Length of output: 102
🏁 Script executed:
# Also check for TypeScript interface/type definitions
rg -n "enableFaceDetection|FaceDetection" --type ts --type tsx -B 2 -A 2 | head -80Repository: Cap-go/capacitor-camera-preview
Length of output: 102
🏁 Script executed:
# Check the web plugin directory for the TypeScript definition
find . -type f -name "*.ts" | xargs grep -l "enableFaceDetection" 2>/dev/nullRepository: Cap-go/capacitor-camera-preview
Length of output: 237
🏁 Script executed:
# Check the definitions file for enableFaceDetection interface
cat ./src/definitions.ts | head -200Repository: Cap-go/capacitor-camera-preview
Length of output: 5681
🏁 Script executed:
# Check the web.ts implementation
cat ./src/web.ts | head -300Repository: Cap-go/capacitor-camera-preview
Length of output: 10210
🏁 Script executed:
# Check face-detection example page
cat ./example-app/src/app/pages/face-detection/face-detection.page.tsRepository: Cap-go/capacitor-camera-preview
Length of output: 8388
🏁 Script executed:
# Check the service implementation
cat ./example-app/src/app/core/capacitor-camera-preview.service.tsRepository: Cap-go/capacitor-camera-preview
Length of output: 11183
Fix parameter extraction to match the JavaScript API contract.
The code extracts call.getObject("options"), but the JavaScript implementation passes options as root-level properties (e.g., {enableLandmarks, enableClassification, performanceMode, detectionInterval, enableTracking}). The Android code should process the call parameters directly rather than looking for a nested "options" object.
| } else { | ||
| JSObject ret = new JSObject(); | ||
| ret.put("supported", true); | ||
| ret.put("landmarks", true); | ||
| ret.put("contours", true); | ||
| ret.put("classification", true); | ||
| ret.put("tracking", true); | ||
| call.resolve(ret); |
There was a problem hiding this comment.
Misleading default capabilities when camera not initialized.
When cameraXView is null, returning all capabilities as true is incorrect. The camera isn't running, so capabilities cannot be determined. Return supported: false or require the camera to be running.
🔎 Proposed fix
} else {
JSObject ret = new JSObject();
- ret.put("supported", true);
- ret.put("landmarks", true);
- ret.put("contours", true);
- ret.put("classification", true);
- ret.put("tracking", true);
+ ret.put("supported", false);
+ ret.put("landmarks", false);
+ ret.put("contours", false);
+ ret.put("classification", false);
+ ret.put("tracking", false);
call.resolve(ret);
}Alternatively, reject with "Camera is not running" for consistency with other methods.
🤖 Prompt for AI Agents
In @android/src/main/java/app/capgo/capacitor/camera/preview/CameraPreview.java
around lines 2042-2049, The current else branch returns a JSObject claiming all
capabilities are true when cameraXView is null; instead, either return
supported:false with all capability flags false or reject the call to match
other methods—update the null-handling in CameraPreview (where cameraXView is
checked and the code currently builds JSObject and calls call.resolve) to either
build a JSObject with ret.put("supported", false) and set
landmarks/contours/classification/tracking to false, then call
call.resolve(ret), or replace that resolve with call.reject("Camera is not
running") to signal the camera isn't initialized; ensure you modify the branch
that currently ends with call.resolve(ret) so it no longer reports capabilities
as true when cameraXView is null.
| boolean enableTracking = options.optBoolean("enableTracking", true); | ||
| String performanceMode = options.optString("performanceMode", "fast"); | ||
| float minFaceSize = (float) options.optDouble("minFaceSize", 0.1); | ||
| int detectionInterval = options.optInt("detectionInterval", 1); |
There was a problem hiding this comment.
🧩 Analysis chain
🏁 Script executed:
rg -n "detectionInterval|frameSkip|skipFrame" android/src/main/java/app/capgo/capacitor/camera/preview/Repository: Cap-go/capacitor-camera-preview
Length of output: 791
🏁 Script executed:
# Check the enableFaceDetection method and surrounding context
fd -t f "CameraXView.java" android/ | head -1 | xargs -I {} sed -n '3540,3650p' {}Repository: Cap-go/capacitor-camera-preview
Length of output: 4896
🏁 Script executed:
# Look for FaceDetectionAnalyzer class
fd -t f "FaceDetectionAnalyzer.java" android/Repository: Cap-go/capacitor-camera-preview
Length of output: 158
🏁 Script executed:
# View FaceDetectionAnalyzer constructor and initialization
fd -t f "FaceDetectionAnalyzer.java" android/ | xargs sed -n '1,100p'Repository: Cap-go/capacitor-camera-preview
Length of output: 3380
🏁 Script executed:
# Also check the complete constructor with signature
rg -A 10 "FaceDetectionAnalyzer.*{" android/src/main/java/app/capgo/capacitor/camera/preview/FaceDetectionAnalyzer.java | head -40Repository: Cap-go/capacitor-camera-preview
Length of output: 186
🏁 Script executed:
# Check the optionsToJson method to see what it converts
rg -A 20 "optionsToJson" android/src/main/java/app/capgo/capacitor/camera/preview/FaceDetectionAnalyzer.javaRepository: Cap-go/capacitor-camera-preview
Length of output: 1346
Pass detectionInterval to FaceDetectionAnalyzer when instantiating it.
The detectionInterval option is parsed at line 3559 but is never passed to the FaceDetectionAnalyzer. Currently, FaceDetectionAnalyzer extracts detectionInterval from a placeholder method that always returns 1, so user-provided values are ignored. Either pass the parsed detectionInterval to the analyzer (e.g., through a constructor parameter or separate setter), or remove the unused parsing if the feature is not intended to be configurable.
| // Create ImageAnalysis use case | ||
| faceDetectionAnalysis = new ImageAnalysis.Builder().setBackpressureStrategy(ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST).build(); | ||
|
|
||
| faceDetectionAnalysis.setAnalyzer(Executors.newSingleThreadExecutor(), faceDetectionAnalyzer); |
There was a problem hiding this comment.
Executor resource leak: SingleThreadExecutor is never shutdown.
A new SingleThreadExecutor is created each time face detection is enabled but never shutdown when face detection is disabled. This causes thread leaks if the feature is toggled multiple times.
🔎 Proposed fix: Store and shutdown the executor
Add a field to track the executor and shut it down in disableFaceDetection:
// Face detection
private ImageAnalysis faceDetectionAnalysis;
private FaceDetectionAnalyzer faceDetectionAnalyzer;
private boolean isFaceDetectionEnabled = false;
private com.google.mlkit.vision.face.FaceDetectorOptions faceDetectorOptions;
+private ExecutorService faceDetectionExecutor;In enableFaceDetection:
- faceDetectionAnalysis.setAnalyzer(Executors.newSingleThreadExecutor(), faceDetectionAnalyzer);
+ faceDetectionExecutor = Executors.newSingleThreadExecutor();
+ faceDetectionAnalysis.setAnalyzer(faceDetectionExecutor, faceDetectionAnalyzer);In disableFaceDetection:
// Close the analyzer
if (faceDetectionAnalyzer != null) {
faceDetectionAnalyzer.close();
faceDetectionAnalyzer = null;
}
+
+ // Shutdown the executor
+ if (faceDetectionExecutor != null) {
+ faceDetectionExecutor.shutdown();
+ faceDetectionExecutor = null;
+ }Committable suggestion skipped: line range outside the PR's diff.
🤖 Prompt for AI Agents
In @android/src/main/java/app/capgo/capacitor/camera/preview/CameraXView.java
around lines 3622-3625, The ImageAnalysis executor is leaked because a new
Executors.newSingleThreadExecutor() is created for faceDetectionAnalysis without
being stored or shutdown; modify the class to add a field (e.g.,
faceDetectionExecutor), assign Executors.newSingleThreadExecutor() in the
enableFaceDetection sequence and pass that executor to
faceDetectionAnalysis.setAnalyzer(..., faceDetectionAnalyzer), and then in
disableFaceDetection shut down the executor (faceDetectionExecutor.shutdownNow()
or shutdown() and null it) and clear references to faceDetectionAnalysis and
faceDetectionAnalyzer to avoid thread leaks.
| private int frameCounter = 0; | ||
| private boolean isProcessing = false; |
There was a problem hiding this comment.
Potential race condition with non-atomic flags.
The frameCounter and isProcessing fields are accessed from camera callback threads without synchronization. While the isProcessing guard might work in practice due to frame ordering, consider using AtomicInteger for frameCounter and AtomicBoolean for isProcessing to guarantee thread safety.
🔎 Proposed fix
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
public class FaceDetectionAnalyzer implements ImageAnalysis.Analyzer {
private static final String TAG = "FaceDetectionAnalyzer";
private final FaceDetector detector;
private final FaceDetectionListener listener;
private final int detectionInterval;
- private int frameCounter = 0;
- private boolean isProcessing = false;
+ private final AtomicInteger frameCounter = new AtomicInteger(0);
+ private final AtomicBoolean isProcessing = new AtomicBoolean(false);Then update the usage:
@Override
@SuppressLint("UnsafeOptInUsageError")
public void analyze(@NonNull ImageProxy imageProxy) {
- frameCounter++;
+ frameCounter.incrementAndGet();
// Skip frames based on detection interval
- if (frameCounter % detectionInterval != 0) {
+ if (frameCounter.get() % detectionInterval != 0) {
imageProxy.close();
return;
}
// Skip if previous detection is still processing
- if (isProcessing) {
+ if (!isProcessing.compareAndSet(false, true)) {
imageProxy.close();
return;
}
-
- isProcessing = true;And in callbacks:
} finally {
imageProxy.close();
- isProcessing = false;
+ isProcessing.set(false);
}Committable suggestion skipped: line range outside the PR's diff.
🤖 Prompt for AI Agents
In
@android/src/main/java/app/capgo/capacitor/camera/preview/FaceDetectionAnalyzer.java
around lines 32-33, Replace the non-thread-safe fields in FaceDetectionAnalyzer:
change frameCounter to an AtomicInteger and isProcessing to an AtomicBoolean,
then update all accesses to use atomic operations (e.g.,
frameCounter.incrementAndGet()/get() and isProcessing.compareAndSet(false,
true)/set(false)) inside the camera callback and processing logic so checks and
updates are atomic and avoid race conditions across camera callback threads.
| var value = call.getFloat("value", 0.0) | ||
| guard value != 0.0 else { | ||
| call.reject("value parameter is required") | ||
| return | ||
| } |
There was a problem hiding this comment.
Bug: Valid exposure compensation value 0.0 incorrectly rejected.
The condition value != 0.0 rejects when value is zero. However, 0.0 is a valid exposure compensation (no adjustment) and should be accepted.
🔎 Proposed fix
- var value = call.getFloat("value", 0.0)
- guard value != 0.0 else {
+ guard let value = call.getFloat("value") else {
call.reject("value parameter is required")
return
}
+ var adjustedValue = valueThen use adjustedValue in the subsequent logic instead of value.
Committable suggestion skipped: line range outside the PR's diff.
🤖 Prompt for AI Agents
In @ios/Sources/CapgoCameraPreviewPlugin/Plugin.swift around lines 2245-2249,
The current check uses value != 0.0 to detect a missing parameter and therefore
incorrectly rejects the valid exposure 0.0; instead, retrieve the parameter as
an optional (use the variant of call.getFloat that returns nil when absent or
check call.has("value")), guard let value = ... to detect truly missing input,
then compute an adjustedValue if needed and use adjustedValue in the subsequent
logic (replace references to the old value variable with adjustedValue); update
the guard to only reject when the parameter is actually absent, not when it
equals 0.0.
| // TODO: Implement actual tests for CameraPreview plugin | ||
| XCTAssertTrue(true) |
There was a problem hiding this comment.
Add unit tests for the camera preview plugin functionality.
This PR introduces comprehensive face detection features (enable/disable detection, capabilities query, face tracking, event listeners), but the only iOS test file now contains a placeholder that asserts true with no functional verification. The original functional tests have been removed.
Automated unit tests are essential for:
- Verifying core plugin behavior and new face detection APIs
- Catching regressions during future changes
- Documenting expected behavior
- Ensuring reliability across iOS versions and devices
Please add unit tests covering at least:
- Basic plugin initialization and lifecycle
- Face detection enable/disable functionality
- Capabilities query (
getFaceDetectionCapabilities) - Face tracking data structure validation
- Error handling for invalid configurations
Would you like me to help draft a test plan or generate example test cases for the face detection functionality?
🤖 Prompt for AI Agents
In @ios/Tests/CameraPreviewPluginTests/CameraPreviewPluginTests.swift around
lines 9-10, Replace the placeholder XCTAssertTrue(true) in
CameraPreviewPluginTests with real unit tests that exercise the CameraPreview
plugin lifecycle and new face-detection APIs: instantiate the plugin
(CameraPreviewPlugin) and test initialization/start/stop behavior, call
enableFaceDetection and disableFaceDetection and assert expected state changes
or callbacks, call getFaceDetectionCapabilities and assert returned capability
fields, validate the shape and types of a face-tracking payload returned by the
plugin (e.g., face IDs, boundingBox, landmarks), and add tests that pass invalid
configurations to enableFaceDetection to assert proper error handling; implement
these as individual XCTest methods inside CameraPreviewPluginTests using
mocks/stubs for any camera or detector dependencies and assert expected
events/errors.
| - **Basic face detection**: See [FACE_DETECTION_EXAMPLE.md](./FACE_DETECTION_EXAMPLE.md) | ||
| - **Interactive demo**: See [FACE_DETECTION_DEMO_GUIDE.md](./FACE_DETECTION_DEMO_GUIDE.md) - Test all features in the example app |
There was a problem hiding this comment.
🧩 Analysis chain
🏁 Script executed:
#!/bin/bash
# Check for the specific referenced documentation files
echo "Checking for referenced documentation files..."
fd -t f "FACE_DETECTION_EXAMPLE.md|FACE_DETECTION_DEMO_GUIDE.md" 2>/dev/null
# Check what files are available in the root
echo -e "\nMarkdown files in repository root:"
fd -t f -e md --max-depth 1 | sort
# Also check if there are any similar named files that might be relevant
echo -e "\nAll markdown files (checking full depth):"
fd -t f -e md | head -30Repository: Cap-go/capacitor-camera-preview
Length of output: 287
Create missing documentation files or remove broken references.
The referenced files FACE_DETECTION_EXAMPLE.md and FACE_DETECTION_DEMO_GUIDE.md do not exist in the repository. Either create these files with appropriate content or remove the references from the README to avoid broken links that users will encounter.
🤖 Prompt for AI Agents
In @README.md around lines 225-226, The README contains broken references to
FACE_DETECTION_EXAMPLE.md and FACE_DETECTION_DEMO_GUIDE.md; either create those
two markdown files with the appropriate example and demo guide content (ensuring
filenames exactly match FACE_DETECTION_EXAMPLE.md and
FACE_DETECTION_DEMO_GUIDE.md and include headings, usage steps, and any required
code snippets), or remove/update the two lines in README.md that reference
**Basic face detection** and **Interactive demo** so they no longer link to
non-existent files (or replace them with links to existing docs); ensure the
README no longer points to missing resources.
| ### addListener('onFacesDetected', ...) | ||
| ```typescript | ||
| addListener(eventName: 'onFacesDetected', listenerFunc: (event: FaceDetectionEvent) => void) => Promise<PluginListenerHandle> | ||
| ``` | ||
| Adds a listener for face detection events. | ||
| Called continuously with detected face data when face detection is enabled. | ||
| | Param | Type | Description | | ||
| | ------------------ | ------------------------------------------------------------------------------------- | --------------------------------------------------- | | ||
| | **`eventName`** | <code>'onFacesDetected'</code> | - The event name to listen for ('onFacesDetected'). | | ||
| | **`listenerFunc`** | <code>(event: <a href="#facedetectionevent">FaceDetectionEvent</a>) => void</code> | - The function to call when faces are detected. | | ||
| **Returns:** <code>Promise<<a href="#pluginlistenerhandle">PluginListenerHandle</a>></code> | ||
| **Since:** 8.1.0 | ||
| -------------------- |
There was a problem hiding this comment.
🧩 Analysis chain
🏁 Script executed:
#!/bin/bash
# Check package.json for current version and CHANGELOG for version history
echo "Current package version:"
cat package.json | jq -r '.version' 2>/dev/null || grep -m1 '"version"' package.json
echo -e "\nSearching for version 8.1.0 references:"
rg "8\.1\.0" CHANGELOG.md -C 3 || echo "No 8.1.0 found"
echo -e "\nSearching for face detection in CHANGELOG:"
rg -i "face.*detection|onFacesDetected" CHANGELOG.md -C 2 || echo "No face detection mentions found"Repository: Cap-go/capacitor-camera-preview
Length of output: 238
Update the Since version: 8.1.0 does not exist.
The listener documentation structure is well-organized and consistent, but the Since: 8.1.0 annotation is incorrect. The current package version is 8.0.5, and there are no references to version 8.1.0 in the CHANGELOG. Update this to reflect the actual version where this feature was introduced, or remove it if this is a new feature being added in the next release.
🤖 Prompt for AI Agents
In @README.md around lines 996-1014, The "Since: 8.1.0" annotation in the
addListener('onFacesDetected', ...) docs is incorrect; update the Since field to
the actual version this feature was introduced (e.g., 8.0.5) or remove the Since
line if this is being added for the next unreleased version, ensuring the change
is applied to the addListener('onFacesDetected', listenerFunc) section so the
documentation matches the package/CHANGELOG history.
| // Face detection methods (unsupported on web - would require TensorFlow.js or similar) | ||
| async enableFaceDetection(_options?: any): Promise<void> { | ||
| void _options; | ||
| throw new Error( | ||
| 'Face detection not supported under the web platform. Consider using TensorFlow.js face-landmarks-detection for web implementation.', | ||
| ); | ||
| } |
There was a problem hiding this comment.
🛠️ Refactor suggestion | 🟠 Major
Use specific type for options parameter.
The _options parameter is typed as any, but should use FaceDetectionOptions from the definitions to maintain type consistency across the plugin API.
🔎 Proposed fix
- async enableFaceDetection(_options?: any): Promise<void> {
+ async enableFaceDetection(_options?: FaceDetectionOptions): Promise<void> {
void _options;
throw new Error(
'Face detection not supported under the web platform. Consider using TensorFlow.js face-landmarks-detection for web implementation.',
);
}Note: Ensure FaceDetectionOptions is imported at the top of the file from './definitions'.
Committable suggestion skipped: line range outside the PR's diff.
🤖 Prompt for AI Agents
In @src/web.ts around lines 1254-1260, The enableFaceDetection method currently
types its parameter as any; change the signature async
enableFaceDetection(_options?: any): Promise<void> to use the
FaceDetectionOptions type (async enableFaceDetection(_options?:
FaceDetectionOptions): Promise<void>), import FaceDetectionOptions from
'./definitions' at the top of the file, and keep or adjust the existing void
_options; line so the unused-parameter pattern remains valid after the type
change.
Pull Request: Real-Time Face Detection & Tracking
Summary
This PR introduces real-time face detection and tracking capabilities to the Capacitor Camera Preview plugin, enabling developers to build Snapchat-like filters, AR experiences, and facial recognition applications.
What This PR Accomplishes:
Why These Changes Are Necessary:
Breaking Changes:
None - This is a purely additive feature. All existing APIs remain unchanged and backward compatible.
API Modifications:
New Methods Added:
enableFaceDetection(options?: FaceDetectionOptions): Promise<void>disableFaceDetection(): Promise<void>isFaceDetectionEnabled(): Promise<{ enabled: boolean }>getFaceDetectionCapabilities(): Promise<FaceDetectionCapabilities>New Event Listener:
addListener('onFacesDetected', callback): Promise<PluginListenerHandle>Test Plan
Prerequisites:
Android Testing:
Setup & Build:
cd example-app bun run androidManual Test Scenarios:
Performance Testing:
Edge Cases:
iOS Testing:
Setup & Build:
cd example-app bun run iosManual Test Scenarios:
Performance Testing:
Device Orientation:
Web Testing:
Run Web Example:
Verification:
enableFaceDetection()throws proper error messagegetFaceDetectionCapabilities()returns supported: falseQuality Assurance:
Code Style & Linting:
Expected: ✅ All checks pass (0 errors)
Type Checking:
Expected: ✅ All types correct (0 errors)
Build Verification:
Expected: ✅ Production build succeeds
Screenshots & Demonstrations
Android - Basic Face Detection
Android - Landmarks & Smile Detection
iOS - Face Tracking
iOS - Eye Detection
Performance Graph