feat: Add native tap-to-focus reset listener

packages/react-native-vision-camera/android/src/main/java/com/margelo/nitro/camera/hybrids/HybridCameraController.kt

@@ -2,6 +2,9 @@ package com.margelo.nitro.camera.hybrids
 
 import android.animation.Animator
 import android.animation.ValueAnimator
+import android.os.Handler
+import android.os.Looper
+import android.util.Log
 import androidx.camera.core.Camera
 import androidx.camera.core.CameraState
 import androidx.camera.core.FocusMeteringAction
@@ -33,6 +36,7 @@ import com.margelo.nitro.core.Promise
 import com.margelo.nitro.core.resolve
 import com.margelo.nitro.core.resolved
 import java.util.concurrent.TimeUnit
+import java.util.concurrent.atomic.AtomicLong
 
 class HybridCameraController(
   val camera: Camera,
@@ -41,6 +45,10 @@ class HybridCameraController(
   private val cameraState: CameraState?
     get() = camera.cameraInfo.cameraState.value
   private var zoomAnimator: ValueAnimator? = null
+  private val focusResetHandler = Handler(Looper.getMainLooper())
+  private val focusGeneration = AtomicLong()
+  private val focusResetLock = Any()
+  private var pendingFocusReset: Runnable? = null
 
   override val isConnected: Boolean
     get() = cameraState?.type == CameraState.Type.OPEN
@@ -140,7 +148,14 @@ class HybridCameraController(
   override fun focusTo(
     point: HybridMeteringPointSpec,
     options: FocusOptions,
+  ): Promise<Unit> = focusTo(point, options, null)
+
+  fun focusTo(
+    point: HybridMeteringPointSpec,
+    options: FocusOptions,
+    onReset: (() -> Unit)?,
   ): Promise<Unit> {
+    val generation = beginFocusOperation()
     return Promise.async {
       val point =
         point as? HybridMeteringPoint
@@ -159,14 +174,68 @@ class HybridCameraController(
             SceneAdaptiveness.CONTINUOUS -> action.setLockingMode(0)
           }
           // Disable auto reset, or set it to a fixed duration (seconds)
-          autoResetAfter.match(
-            { _ -> action.disableAutoCancel() },
-            { duration -> action.setAutoCancelDuration(duration.toLong(), TimeUnit.SECONDS) },
-          )
+          if (onReset != null) {
+            action.disableAutoCancel()
+          } else {
+            autoResetAfter.match(
+              { _ -> action.disableAutoCancel() },
+              { duration -> action.setAutoCancelDuration(duration.toLong(), TimeUnit.SECONDS) },
+            )
+          }
         }
       camera.cameraControl
         .startFocusAndMetering(focusAction.build())
         .await()
+
+      if (onReset != null) {
+        autoResetAfter.match(
+          { _ -> },
+          { duration -> scheduleFocusReset(generation, duration, onReset) },
+        )
+      }
+    }
+  }
+
+  private fun beginFocusOperation(): Long {
+    val generation = focusGeneration.incrementAndGet()
+    synchronized(focusResetLock) {
+      pendingFocusReset?.let { focusResetHandler.removeCallbacks(it) }
+      pendingFocusReset = null
+    }
+    return generation
+  }
+
+  private fun scheduleFocusReset(
+    generation: Long,
+    duration: Double,
+    onReset: () -> Unit,
+  ) {
+    val reset =
+      Runnable {
+        if (focusGeneration.get() != generation) return@Runnable
+        val future = camera.cameraControl.cancelFocusAndMetering()
+        future.addListener(
+          {
+            try {
+              future.get()
+              if (focusGeneration.get() == generation) {
+                synchronized(focusResetLock) {
+                  pendingFocusReset = null
+                }
+                onReset()
+              }
+            } catch (error: Throwable) {
+              Log.e(TAG, "Failed to automatically reset focus!", error)
+            }
+          },
+          { command -> focusResetHandler.post(command) },
+        )
+      }
+    synchronized(focusResetLock) {
+      if (focusGeneration.get() == generation) {
+        pendingFocusReset = reset
+        focusResetHandler.postDelayed(reset, (duration * 1_000).toLong())
+      }
     }
   }
 
@@ -183,6 +252,7 @@ class HybridCameraController(
   }
 
   override fun resetFocus(): Promise<Unit> {
+    beginFocusOperation()
     return Promise.async {
       camera.cameraControl
         .cancelFocusAndMetering()

packages/react-native-vision-camera/android/src/main/java/com/margelo/nitro/camera/hybrids/gestures/HybridTapToFocusGestureController.kt

@@ -28,6 +28,7 @@ class HybridTapToFocusGestureController :
   private var previewView: PreviewView? = null
   private val onTapListeners = mutableSetOf<(HybridMeteringPointSpec) -> Unit>()
   private val onFocusCompletedListeners = mutableSetOf<(HybridMeteringPointSpec) -> Unit>()
+  private val onFocusResetListeners = mutableSetOf<(HybridMeteringPointSpec) -> Unit>()
   private val context: Context
     get() = NitroModules.applicationContext ?: throw Error("Context not available!")
   private val mainHandler = Handler(Looper.getMainLooper())
@@ -50,8 +51,18 @@ class HybridTapToFocusGestureController :
           val density = context.resources.displayMetrics.density
           val meteringPoint = HybridMeteringPoint((e.x / density).toDouble(), (e.y / density).toDouble(), null, point)
           onTapListeners.toList().forEach { it(meteringPoint) }
-          controller
-            .focusTo(meteringPoint, FocusOptions(null, null, null, null))
+          val focusOptions = FocusOptions(null, null, null, null)
+          val focusPromise =
+            if (controller is HybridCameraController) {
+              controller.focusTo(meteringPoint, focusOptions) {
+                mainHandler.post {
+                  onFocusResetListeners.toList().forEach { it(meteringPoint) }
+                }
+              }
+            } else {
+              controller.focusTo(meteringPoint, focusOptions)
+            }
+          focusPromise
             .then {
               mainHandler.post {
                 onFocusCompletedListeners.toList().forEach { it(meteringPoint) }
@@ -122,4 +133,11 @@ class HybridTapToFocusGestureController :
       onFocusCompletedListeners.remove(onFocusCompleted)
     }
   }
+
+  override fun addOnFocusResetListener(onFocusReset: (HybridMeteringPointSpec) -> Unit): ListenerSubscription {
+    onFocusResetListeners.add(onFocusReset)
+    return ListenerSubscription {
+      onFocusResetListeners.remove(onFocusReset)
+    }
+  }
 }

packages/react-native-vision-camera/ios/Hybrid Objects/Gestures/HybridTapToFocusGestureController.swift

@@ -18,6 +18,7 @@ final class HybridTapToFocusGestureController: HybridTapToFocusGestureController
   private weak var previewView: (any HybridPreviewViewSpec)? = nil
   private var onTapListeners: [UUID: (any HybridMeteringPointSpec) -> Void] = [:]
   private var onFocusCompletedListeners: [UUID: (any HybridMeteringPointSpec) -> Void] = [:]
+  private var onFocusResetListeners: [UUID: (any HybridMeteringPointSpec) -> Void] = [:]
 
   override init() {
     super.init()
@@ -39,7 +40,24 @@ final class HybridTapToFocusGestureController: HybridTapToFocusGestureController
       let tapListeners = Array(onTapListeners.values)
       tapListeners.forEach { $0(meteringPoint) }
 
-      try controller.focusTo(point: meteringPoint, options: FocusOptions())
+      let onReset = { [weak self] in
+        DispatchQueue.main.async { [weak self] in
+          guard let self else { return }
+          let focusResetListeners = Array(self.onFocusResetListeners.values)
+          focusResetListeners.forEach { $0(meteringPoint) }
+        }
+      }
+      let focusPromise: Promise<Void>
+      if let nativeController = controller as? HybridCameraController {
+        focusPromise = nativeController.focusTo(
+          point: meteringPoint,
+          options: FocusOptions(),
+          onReset: onReset)
+      } else {
+        focusPromise = try controller.focusTo(point: meteringPoint, options: FocusOptions())
+      }
+
+      focusPromise
         .then { [weak self] _ in
           DispatchQueue.main.async { [weak self] in
             guard let self else { return }
@@ -75,6 +93,16 @@ final class HybridTapToFocusGestureController: HybridTapToFocusGestureController
     }
   }
 
+  func addOnFocusResetListener(onFocusReset: @escaping (any HybridMeteringPointSpec) -> Void)
+    -> ListenerSubscription
+  {
+    let id = UUID()
+    onFocusResetListeners[id] = onFocusReset
+    return ListenerSubscription { [weak self] in
+      self?.onFocusResetListeners.removeValue(forKey: id)
+    }
+  }
+
   func onAttached(to preview: any HybridPreviewViewSpec) {
     self.previewView = preview
   }

packages/react-native-vision-camera/ios/Hybrid Objects/HybridCameraController.swift

@@ -171,6 +171,14 @@ final class HybridCameraController: HybridCameraControllerSpec, NativeCameraCont
   func focusTo(
     point: any HybridMeteringPointSpec,
     options: FocusOptions
+  ) -> Promise<Void> {
+    return focusTo(point: point, options: options, onReset: nil)
+  }
+
+  func focusTo(
+    point: any HybridMeteringPointSpec,
+    options: FocusOptions,
+    onReset: (() -> Void)?
   ) -> Promise<Void> {
     return captureDevice.withLock(queue) { resolve, reject in
       guard let point = point as? HybridMeteringPoint else {
@@ -214,7 +222,8 @@ final class HybridCameraController: HybridCameraControllerSpec, NativeCameraCont
       // Start listening to updates
       task.startListening(
         onComplete: resolve,
-        onError: reject
+        onError: reject,
+        onReset: onReset
       )
       self.activeMeteringTask = task
 

packages/react-native-vision-camera/ios/Utils/MeteringTask.swift

@@ -42,6 +42,7 @@ final class MeteringTask {
   private var isFinished = false
   private var onComplete: (() -> Void)? = nil
   private var onError: ((Error) -> Void)? = nil
+  private var onReset: (() -> Void)? = nil
 
   private struct MeteringProgress {
     var settledAt: Date? = nil
@@ -87,10 +88,12 @@ final class MeteringTask {
    */
   func startListening(
     onComplete: @escaping () -> Void,
-    onError: @escaping (Error) -> Void
+    onError: @escaping (Error) -> Void,
+    onReset: (() -> Void)?
   ) {
     self.onComplete = onComplete
     self.onError = onError
+    self.onReset = onReset
     // the Timer periodically polls AE/AF/AWB state - this is how we can ensure the states have
     // been stable for 120ms+ and aren't just fluctuating.
     let pollTimer = DispatchSource.makeTimerSource(queue: queue)
@@ -171,7 +174,14 @@ final class MeteringTask {
       if case .after(let seconds) = self.autoReset {
         self.queue.asyncAfter(deadline: .now() + seconds) { [weak self] in
           guard let self else { return }
-          try? self.resetMeteringValues()
+          do {
+            try self.resetMeteringValues()
+            let onReset = self.onReset
+            self.onReset = nil
+            onReset?()
+          } catch {
+            logger.error("Failed to automatically reset metering! \(error)")
+          }
         }
       }
     }

packages/react-native-vision-camera/src/specs/gestures/TapToFocusGestureController.nitro.ts

@@ -30,4 +30,17 @@ export interface TapToFocusGestureController extends GestureController {
   addOnFocusCompletedListener(
     onFocusCompleted: (point: MeteringPoint) => void,
   ): ListenerSubscription
+
+  /**
+   * Adds a listener that is called after focus triggered by a native tap
+   * automatically resets.
+   *
+   * This is not called if the reset fails or the focus is superseded by a
+   * newer focus operation. Call
+   * {@linkcode ListenerSubscription.remove | remove()} on the returned
+   * subscription to stop receiving updates.
+   */
+  addOnFocusResetListener(
+    onFocusReset: (point: MeteringPoint) => void,
+  ): ListenerSubscription
 }