Lightos - DONT MERGE

README.md

@@ -1,3 +1,23 @@
+# LightOS fork for finer focus control
+
+To run the example app:
+
+```
+cd package
+yarn install
+cd example
+yarn install
+run android
+------
+run start
+```
+
+# Building a new release for LightOS
+
+We have a script in this repo so that the package builds after being installed - see `scripts/prepare-package.js`.
+
+After making changes to this repo, update the version in `package.json` and create a new tag - you can then update the tag in /LightOS/package.json
+
 <a href="https://margelo.com">
   <picture>
     <source media="(prefers-color-scheme: dark)" srcset="./docs/static/img/banner-dark.png" />

package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-vision-camera",
-  "version": "4.6.19",
+  "version": "4.6.20",
   "description": "A powerful, high-performance React Native Camera library.",
   "main": "lib/commonjs/index",
   "module": "lib/module/index",

package/.gitignore

@@ -74,7 +74,6 @@ yarn-error.log
 !.yarn/versions
 
 # TypeScript output
-/lib
 /example/lib
 
 # Gems

package/android/build.gradle

@@ -100,6 +100,16 @@ android {
     namespace "com.mrousavy.camera"
   }
 
+  flavorDimensions "version"
+  productFlavors {
+    "lp2" {
+      dimension "version"
+    }
+    "lp3" {
+      dimension "version"
+    }
+  }
+
   // Used to override the NDK path/version on internal CI or by allowing
   // users to customize the NDK path/version from their root project (e.g. for M1 support)
   if (rootProject.hasProperty("ndkPath")) {
@@ -193,6 +203,9 @@ dependencies {
   // Some Coroutines extension functions
   implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.8.1"
 
+  // Include light jar files
+  lp3Implementation files('../../../../framework_all/lp3.jar')
+
   if (enableCodeScanner) {
     // User enabled code-scanner, so we bundle the 2.4 MB model in the app.
     implementation 'com.google.mlkit:barcode-scanning:17.3.0'
@@ -242,3 +255,13 @@ tasks.configureEach { task ->
     task.dependsOn(deleteCmakeCache)
   }
 }
+
+gradle.projectsEvaluated {
+  tasks.withType(JavaCompile) { task ->
+    def isLp3 = task.toString().indexOf("Lp3") != -1
+    if (!isLp3) {
+      return;
+    }
+    options.compilerArgs.add("-Xbootclasspath/p:${rootDir}/../../framework_all/lp3.jar")
+  }
+}

package/android/src/lp2/java/com/mrousavy/camera/core/CameraSession+EIS.kt

@@ -0,0 +1,5 @@
+package com.mrousavy.camera.core
+
+fun CameraSession.setEISMode(newMode: String) {
+  return
+}

package/android/src/lp3/java/com/mrousavy/camera/core/CameraSession+EIS.kt

@@ -0,0 +1,15 @@
+package com.mrousavy.camera.core
+
+import android.os.SystemProperties
+import android.util.Log
+
+fun CameraSession.setEISMode(newMode: String) {
+  try {
+    Log.i(CameraSession.TAG, "EIS: changed from: " + SystemProperties.get("persist.vendor.camera.enableEIS"));
+    SystemProperties.set("persist.vendor.camera.enableEIS", newMode);
+    Log.i(CameraSession.TAG, "EIS: changed to: " + SystemProperties.get("persist.vendor.camera.enableEIS"));
+  }
+  catch (e: Exception) {
+    Log.e(CameraSession.TAG, "Unable to set EIS mode ${e.message}")
+  }
+}

package/android/src/main/java/com/mrousavy/camera/core/CameraConfiguration.kt

@@ -47,7 +47,7 @@ data class CameraConfiguration(
 ) {
   // Output<T> types, those need to be comparable
   data class CodeScanner(val codeTypes: List<CodeType>)
-  data class Photo(val isMirrored: Boolean, val enableHdr: Boolean, val photoQualityBalance: QualityBalance)
+  data class Photo(val isMirrored: Boolean, val enableHdr: Boolean, val photoQualityBalance: QualityBalance, val jpegCompressionQuality: Int)
   data class Video(val isMirrored: Boolean, val enableHdr: Boolean)
   data class FrameProcessor(val isMirrored: Boolean, val pixelFormat: PixelFormat)
   data class Audio(val nothing: Unit)

package/android/src/main/java/com/mrousavy/camera/core/CameraSession+Configuration.kt

@@ -20,9 +20,12 @@ import androidx.camera.video.VideoCapture
 import androidx.lifecycle.Lifecycle
 import com.mrousavy.camera.core.extensions.*
 import com.mrousavy.camera.core.types.CameraDeviceFormat
+import com.mrousavy.camera.core.types.QualityBalance
 import com.mrousavy.camera.core.types.Torch
 import com.mrousavy.camera.core.types.VideoStabilizationMode
 import kotlin.math.roundToInt
+import androidx.camera.camera2.interop.Camera2Interop
+import android.hardware.camera2.CaptureRequest
 
 private fun assertFormatRequirement(
   propName: String,
@@ -91,8 +94,22 @@ internal fun CameraSession.configureOutputs(configuration: CameraConfiguration)
   if (photoConfig != null) {
     Log.i(CameraSession.TAG, "Creating Photo output...")
     val photo = ImageCapture.Builder().also { photo ->
+      // Set exposure metering based on SnapdragonCamera
+      val camera2Extender = Camera2Interop.Extender(photo)
+      camera2Extender.setCaptureRequestOption(
+        CaptureRequest.Key<Integer>(
+          "org.codeaurora.qcamera3.exposure_metering.exposure_metering_mode",
+          Integer::class.java
+        ),
+        Integer(1)
+      )
+
       // Configure Photo Output
       photo.setCaptureMode(photoConfig.config.photoQualityBalance.toCaptureMode())
+      Log.i("LP3_PROFILER", "Mode: ${photoConfig.config.photoQualityBalance}")
+      Log.i("LP3_PROFILER", "Quality: ${photoConfig.config.jpegCompressionQuality}")
+      Log.i(LP3_TAG, "Setting jpeg compression to ${photoConfig.config.jpegCompressionQuality}")
+      photo.setJpegQuality(photoConfig.config.jpegCompressionQuality)
       if (format != null) {
         Log.i(CameraSession.TAG, "Photo size: ${format.photoSize}")
         val resolutionSelector = ResolutionSelector.Builder()
@@ -107,6 +124,34 @@ internal fun CameraSession.configureOutputs(configuration: CameraConfiguration)
     photoOutput = null
   }
 
+  /*
+   * LP3: The aim with this was to provide a second Photo UseCase which would be used for when we lock the focus
+   * This use case is set to aim for fastest shutter speed
+   * Unfortunately, we can't bind two Photo UseCases at once and so this fails to initialize
+   * And if we don't bind it, photo taking fails
+   * Trying to dynamically rebind which UseCase is being used at runtime also seems to be full of pitfalls and complications
+   * Rebinding takes time and passing in the appropriate
+  // 2.1 Image Capture with Locked Focus
+  if (photoConfig != null) {
+    Log.i(CameraSession.TAG, "Creating Photo output...")
+    val photo = ImageCapture.Builder().also { photo ->
+      // Configure Photo Output
+      photo.setCaptureMode(QualityBalance.BALANCED.toCaptureMode())
+      if (format != null) {
+        Log.i(CameraSession.TAG, "Photo size: ${format.photoSize}")
+        val resolutionSelector = ResolutionSelector.Builder()
+          .forSize(format.photoSize)
+          .setAllowedResolutionMode(ResolutionSelector.PREFER_CAPTURE_RATE_OVER_HIGHER_RESOLUTION)
+          .build()
+        photo.setResolutionSelector(resolutionSelector)
+      }
+    }.build()
+    photoOutputLockedFocus = photo
+  } else {
+    photoOutputLockedFocus = null
+  }
+  */
+
   // 3. Video Capture
   if (videoConfig != null) {
     Log.i(CameraSession.TAG, "Creating Video output...")
@@ -129,6 +174,16 @@ internal fun CameraSession.configureOutputs(configuration: CameraConfiguration)
     }
 
     val video = VideoCapture.Builder(recorder).also { video ->
+      // Set exposure metering based on SnapdragonCamera
+      val camera2Extender = Camera2Interop.Extender(video)
+      camera2Extender.setCaptureRequestOption(
+        CaptureRequest.Key<Integer>(
+          "org.codeaurora.qcamera3.exposure_metering.exposure_metering_mode",
+          Integer::class.java
+        ),
+        Integer(1)
+      )
+
       // Configure Video Output
       if (videoConfig.config.isMirrored) {
         video.setMirrorMode(MirrorMode.MIRROR_MODE_ON)
@@ -219,6 +274,7 @@ internal suspend fun CameraSession.configureCamera(provider: ProcessCameraProvid
   checkCameraPermission()
 
   // Outputs
+  // val useCases = listOfNotNull(previewOutput, photoOutput, photoOutputLockedFocus, videoOutput, frameProcessorOutput, codeScannerOutput)
   val useCases = listOfNotNull(previewOutput, photoOutput, videoOutput, frameProcessorOutput, codeScannerOutput)
   if (useCases.isEmpty()) {
     throw NoOutputsError()

package/android/src/main/java/com/mrousavy/camera/core/CameraSession+FocusExposureControl.kt

@@ -0,0 +1,93 @@
+package com.mrousavy.camera.core
+
+import android.annotation.SuppressLint
+import android.util.Log
+import androidx.camera.core.CameraControl
+import android.hardware.camera2.CaptureRequest
+import androidx.annotation.OptIn
+import androidx.camera.camera2.interop.CaptureRequestOptions
+import androidx.camera.core.FocusMeteringAction
+import androidx.camera.core.MeteringPoint
+import com.mrousavy.camera.core.extensions.await
+import androidx.camera.camera2.interop.Camera2CameraControl
+import androidx.camera.camera2.interop.ExperimentalCamera2Interop
+
+// There are a few different focus control modes available in the docs: 
+// https://developer.android.com/reference/android/hardware/camera2/CaptureRequest#CONTROL_AF_MODE
+// The relevant to us are:
+// - CONTROL_AF_MODE_AUTO - allows us to manually tell the camera where to focus
+// - CONTROL_AF_MODE_CONTINUOUS_PICTURE - tells the camera to continuously autofocus
+@OptIn(ExperimentalCamera2Interop::class)
+fun CameraSession.setFocusMode(mode: Int) {
+  val camera = camera ?: throw CameraNotReadyError()
+
+  Camera2CameraControl.from(camera.cameraControl).setCaptureRequestOptions(
+    CaptureRequestOptions.Builder().setCaptureRequestOption(CaptureRequest.CONTROL_AF_MODE, mode).build()
+  )
+  Log.i(CameraSession.TAG, "LP3: set focus mode: $mode")
+}
+
+/*
+ * LP3: Trying to rebind the photoOutput at runtime.
+ * Pulling up all the necessary context such as the cameraSelector doesn't seem possible without rebuilding it
+ * This approach also seems vulnerable to race conditions since we can't easily guarantee it being executed before
+ * a photo request is made as this is async
+suspend fun CameraSession.bindNormal() {
+  val provider = cameraProvider.await(mainExecutor)
+
+  provider.unbind(currentlyBoundPhotoOutput)
+  provider.bindToLifecycle(list, cameraSelector, listOf(photoOutputLockedFocus))
+  currentlyBoundPhotoOutput = photoOutputLockedFocus
+}*/
+
+// For exposure we can just set it to be locked
+@OptIn(ExperimentalCamera2Interop::class)
+fun CameraSession.setExposureLock(setLocked: Boolean) {
+  val camera = camera ?: throw CameraNotReadyError()
+
+  Camera2CameraControl.from(camera.cameraControl).setCaptureRequestOptions(
+    CaptureRequestOptions.Builder().setCaptureRequestOption(CaptureRequest.CONTROL_AE_LOCK, setLocked).build()
+  )
+}
+
+fun CameraSession.freeFocusAndExposure() {
+
+  setExposureLock(false)
+  setFocusMode(CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_PICTURE)
+}
+
+@SuppressLint("RestrictedApi")
+suspend fun CameraSession.lockFocusAndExposureToPoint(meteringPoint: MeteringPoint): Boolean {
+  val camera = camera ?: throw CameraNotReadyError()
+
+  setFocusMode(CaptureRequest.CONTROL_AF_MODE_AUTO)
+
+  // So it seems like using, disableAutoCancel might actually be the solution
+  // Hidden in this obscure SO post
+  // https://stackoverflow.com/questions/66633338/disable-autofocus-in-android-camerax-camera-2
+  val action = FocusMeteringAction.Builder(meteringPoint,
+    FocusMeteringAction.FLAG_AF or FocusMeteringAction.FLAG_AE).apply {
+      disableAutoCancel()
+  }.build()
+
+  if (!camera.cameraInfo.isFocusMeteringSupported(action)) {
+    throw FocusNotSupportedError()
+  }
+
+  try {
+    Log.i(CameraSession.TAG, "LP3: Focusing to ${action.meteringPointsAf.joinToString { "(${it.x}, ${it.y})" }}...")
+    val future = camera.cameraControl.startFocusAndMetering(action)
+    val result = future.await(CameraQueues.cameraExecutor)
+    if (result.isFocusSuccessful) {
+      Log.i(CameraSession.TAG, "LP3: Focused successfully")
+      setExposureLock(true)
+      return true
+    } else {
+      Log.i(CameraSession.TAG, "LP3: Failed to focus")
+      freeFocusAndExposure()
+    }
+  } catch (e: CameraControl.OperationCanceledException) {
+    throw FocusCanceledError()
+  }
+  return false
+}