petrus-react-native 0.1.0

package/PetrusReactNative.podspec

@@ -0,0 +1,20 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = "PetrusReactNative"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = package["homepage"]
+  s.license      = package["license"]
+  s.authors      = package["author"]
+
+  s.platforms    = { :ios => min_ios_version_supported }
+  s.source       = { :git => "https://github.com/petrus/petrus-react-native.git", :tag => "#{s.version}" }
+
+  s.source_files = "ios/**/*.{h,m,mm,swift,cpp}"
+  s.private_header_files = "ios/**/*.h"
+
+  install_modules_dependencies(s)
+end

package/android/build.gradle

@@ -0,0 +1,64 @@
+buildscript {
+  ext.PetrusReactNative = [
+    kotlinVersion: "2.0.21",
+    minSdkVersion: 24,
+    compileSdkVersion: 36
+  ]
+
+  ext.getExtOrDefault = { prop ->
+    if (rootProject.ext.has(prop)) {
+      return rootProject.ext.get(prop)
+    }
+
+    return PetrusReactNative[prop]
+  }
+
+  repositories {
+    google()
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:8.7.2"
+    // noinspection DifferentKotlinGradleVersion
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${getExtOrDefault('kotlinVersion')}"
+  }
+}
+
+
+apply plugin: "com.android.library"
+apply plugin: "kotlin-android"
+
+apply plugin: "com.facebook.react"
+
+android {
+  namespace "com.petrusreactnative"
+
+  compileSdkVersion getExtOrDefault("compileSdkVersion")
+
+  defaultConfig {
+    minSdkVersion getExtOrDefault("minSdkVersion")
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_17
+    targetCompatibility JavaVersion.VERSION_17
+  }
+
+  // Explicit to avoid "Inconsistent JVM-target compatibility" failures under JDK 17 --
+  // flagged in the Phase 0 review as an implicit-inference risk.
+  kotlinOptions {
+    jvmTarget = "17"
+  }
+}
+
+dependencies {
+  implementation "com.facebook.react:react-android"
+  // petrus-core exposes CameraX as `api`, so PreviewView etc. resolve on *our* compile
+  // classpath via this `implementation` dependency -- we don't need `api` here since
+  // nothing downstream of petrus-react-native touches CameraX types directly.
+  implementation project(":petrus-core")
+  // For launching a CoroutineScope around OCRProcessor's suspend API from the
+  // (non-suspend) TurboModule method.
+  implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.11.0"
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,4 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+    <uses-permission android:name="android.permission.CAMERA" />
+    <uses-feature android:name="android.hardware.camera" android:required="true" />
+</manifest>

package/android/src/main/java/com/petrusreactnative/PDF417ScanSession.kt

@@ -0,0 +1,86 @@
+package com.petrusreactnative
+
+import android.os.Handler
+import android.os.Looper
+import androidx.camera.core.CameraSelector
+import androidx.camera.core.ImageAnalysis
+import androidx.camera.lifecycle.ProcessCameraProvider
+import androidx.core.content.ContextCompat
+import androidx.lifecycle.LifecycleOwner
+import com.facebook.react.bridge.ReactApplicationContext
+import com.petrus.vision.pdf417.PDF417Result
+import com.petrus.vision.pdf417.PDF417Scanner
+import java.util.concurrent.Executors
+import java.util.concurrent.atomic.AtomicBoolean
+
+/**
+ * One-shot headless PDF417 scan: binds just an `ImageAnalysis` use case (no
+ * `Preview`/`PreviewView` -- nothing is displayed) to the current Activity's
+ * lifecycle, scans frames until one decodes or [timeoutMs] elapses, then unbinds.
+ *
+ * Deliberately separate from `CameraController` (petrus-core) rather than reusing
+ * it: `CameraController`'s API requires a `PreviewView`, which a headless scan has
+ * no use for. Needs `Activity`/`LifecycleOwner` access, same reasoning as why
+ * `PetrusCameraView` lives here rather than in petrus-core.
+ */
+class PDF417ScanSession(private val reactContext: ReactApplicationContext) {
+
+  private val scanner = PDF417Scanner()
+  private val executor = Executors.newSingleThreadExecutor()
+  private val finished = AtomicBoolean(false)
+  private var cameraProvider: ProcessCameraProvider? = null
+
+  fun start(timeoutMs: Long, onResult: (PDF417Result?) -> Unit) {
+    val lifecycleOwner = reactContext.currentActivity as? LifecycleOwner
+    if (lifecycleOwner == null) {
+      onResult(null)
+      return
+    }
+
+    val timeoutHandler = Handler(Looper.getMainLooper())
+
+    fun finish(result: PDF417Result?) {
+      if (!finished.compareAndSet(false, true)) return
+      timeoutHandler.removeCallbacksAndMessages(null)
+      cameraProvider?.unbindAll()
+      executor.shutdown()
+      onResult(result)
+    }
+
+    timeoutHandler.postDelayed({ finish(null) }, timeoutMs)
+
+    val providerFuture = ProcessCameraProvider.getInstance(reactContext)
+    providerFuture.addListener(
+      {
+        if (finished.get()) return@addListener
+
+        val provider = providerFuture.get()
+        cameraProvider = provider
+
+        val analysis =
+          ImageAnalysis.Builder()
+            .setBackpressureStrategy(ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST)
+            .build()
+            .also {
+              it.setAnalyzer(executor) { image ->
+                try {
+                  if (!finished.get()) {
+                    scanner.scan(image)?.let { result -> finish(result) }
+                  }
+                } finally {
+                  image.close()
+                }
+              }
+            }
+
+        try {
+          provider.unbindAll()
+          provider.bindToLifecycle(lifecycleOwner, CameraSelector.DEFAULT_BACK_CAMERA, analysis)
+        } catch (e: Exception) {
+          finish(null)
+        }
+      },
+      ContextCompat.getMainExecutor(reactContext),
+    )
+  }
+}

package/android/src/main/java/com/petrusreactnative/PassportScanSession.kt

@@ -0,0 +1,137 @@
+package com.petrusreactnative
+
+import android.os.Handler
+import android.os.Looper
+import androidx.camera.core.CameraSelector
+import androidx.camera.core.ImageAnalysis
+import androidx.camera.lifecycle.ProcessCameraProvider
+import androidx.core.content.ContextCompat
+import androidx.lifecycle.LifecycleOwner
+import com.facebook.react.bridge.ReactApplicationContext
+import com.petrus.core.detection.DocumentDetector
+import com.petrus.vision.mrz.MRZDetector
+import com.petrus.vision.mrz.PassportParser
+import com.petrus.vision.mrz.PassportResult
+import com.petrus.vision.ocr.OCRProcessor
+import java.util.concurrent.Executors
+import java.util.concurrent.atomic.AtomicBoolean
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.launch
+
+/**
+ * One-shot headless passport scan: binds just an `ImageAnalysis` use case (no
+ * `Preview`/`PreviewView`) to the current Activity's lifecycle. Per frame:
+ * detects the document boundary ([DocumentDetector], Phase 1/2, reused not
+ * re-implemented), crops the MRZ band ([MRZDetector], ICAO 9303 ERZ geometry),
+ * runs OCR on *just that crop* ([OCRProcessor.processBitmap]), and parses it
+ * ([PassportParser]) -- stopping once a frame yields a result with a non-empty
+ * passport number, or [start]'s timeout elapses. Structurally mirrors
+ * `VehicleRegistrationScanSession`/`PDF417ScanSession`.
+ *
+ * Frames with no confidently-detected document boundary are skipped entirely (no
+ * crop, no OCR) rather than falling back to whole-frame OCR -- unlike
+ * `VehicleRegistrationScanSession` (Phase 6), which OCRs the whole frame every
+ * time since it has no separate region to isolate first, this scan session's
+ * whole point is running OCR on *only the MRZ crop*, so a missing/low-confidence
+ * detection has nothing meaningful to crop yet.
+ */
+class PassportScanSession(private val reactContext: ReactApplicationContext) {
+
+  private val documentDetector = DocumentDetector()
+  private val ocrProcessor = OCRProcessor()
+  private val executor = Executors.newSingleThreadExecutor()
+  private val scope = CoroutineScope(SupervisorJob() + Dispatchers.Default)
+  private val finished = AtomicBoolean(false)
+  private var cameraProvider: ProcessCameraProvider? = null
+
+  fun start(timeoutMs: Long, onResult: (PassportResult?) -> Unit) {
+    val lifecycleOwner = reactContext.currentActivity as? LifecycleOwner
+    if (lifecycleOwner == null) {
+      onResult(null)
+      return
+    }
+
+    val timeoutHandler = Handler(Looper.getMainLooper())
+
+    fun finish(result: PassportResult?) {
+      if (!finished.compareAndSet(false, true)) return
+      timeoutHandler.removeCallbacksAndMessages(null)
+      cameraProvider?.unbindAll()
+      ocrProcessor.close()
+      scope.cancel()
+      executor.shutdown()
+      onResult(result)
+    }
+
+    timeoutHandler.postDelayed({ finish(null) }, timeoutMs)
+
+    val providerFuture = ProcessCameraProvider.getInstance(reactContext)
+    providerFuture.addListener(
+      {
+        if (finished.get()) return@addListener
+
+        val provider = providerFuture.get()
+        cameraProvider = provider
+
+        val analysis =
+          ImageAnalysis.Builder()
+            .setBackpressureStrategy(ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST)
+            .build()
+            .also {
+              it.setAnalyzer(executor) { image ->
+                if (finished.get()) {
+                  image.close()
+                  return@setAnalyzer
+                }
+
+                // Synchronous, same as FrameAnalyzer's own per-frame detection call --
+                // fast CPU work (OpenCV edge/contour detection on the Y plane only).
+                val corners = documentDetector.detect(image)
+                if (corners == null || corners.confidence < MIN_DETECTION_CONFIDENCE) {
+                  image.close()
+                  return@setAnalyzer
+                }
+
+                scope.launch {
+                  try {
+                    val mrzCrop = MRZDetector.crop(image, corners)
+                    val ocrResult =
+                      try {
+                        ocrProcessor.processBitmap(mrzCrop, image.imageInfo.rotationDegrees)
+                      } finally {
+                        mrzCrop.recycle()
+                      }
+                    if (!finished.get()) {
+                      val parsed = PassportParser.parse(ocrResult.fullText)
+                      if (parsed.passportNumber.isNotEmpty()) {
+                        finish(parsed)
+                      }
+                    }
+                  } catch (e: Exception) {
+                    // Swallow -- a single failed frame shouldn't end the scan session.
+                  } finally {
+                    image.close()
+                  }
+                }
+              }
+            }
+
+        try {
+          provider.unbindAll()
+          provider.bindToLifecycle(lifecycleOwner, CameraSelector.DEFAULT_BACK_CAMERA, analysis)
+        } catch (e: Exception) {
+          finish(null)
+        }
+      },
+      ContextCompat.getMainExecutor(reactContext),
+    )
+  }
+
+  companion object {
+    /** Below this, DocumentDetector's own quad is too unreliable to crop an MRZ band from confidently. */
+    private const val MIN_DETECTION_CONFIDENCE = 0.5f
+  }
+}

package/android/src/main/java/com/petrusreactnative/PetrusCameraView.kt

@@ -0,0 +1,146 @@
+package com.petrusreactnative
+
+import android.util.Log
+import android.widget.FrameLayout
+import androidx.camera.view.PreviewView
+import androidx.lifecycle.LifecycleOwner
+import com.facebook.react.bridge.LifecycleEventListener
+import com.facebook.react.uimanager.ThemedReactContext
+import com.petrus.core.camera.CameraController
+import com.petrus.core.camera.FrameMetadata
+import com.petrus.core.detection.DetectionUpdate
+import com.petrus.core.detection.DocumentDetectionPipeline
+import java.util.concurrent.Executors
+import java.util.concurrent.atomic.AtomicLong
+
+/**
+ * Hosts a CameraX [PreviewView] (+ a [PetrusOverlayView] drawn on top of it) and drives
+ * [CameraController] off the RN view/host lifecycle. Document detection runs on every
+ * analyzed frame via [DocumentDetectionPipeline]; the overlay updates natively (no
+ * bridge cost) while [onDocumentDetectedListener]/[onCapturedListener] cross to JS,
+ * throttled/one-shot respectively.
+ */
+class PetrusCameraView(private val reactContext: ThemedReactContext) :
+  FrameLayout(reactContext), LifecycleEventListener {
+
+  private val previewView: PreviewView = PreviewView(reactContext)
+  private val overlayView: PetrusOverlayView = PetrusOverlayView(reactContext)
+  private val cameraController = CameraController()
+  private val detectionPipeline = DocumentDetectionPipeline()
+  private val analysisExecutor = Executors.newSingleThreadExecutor()
+  private val lastFrameEmitMs = AtomicLong(0L)
+  private val lastDetectionEmitMs = AtomicLong(0L)
+
+  var isActive: Boolean = false
+    set(value) {
+      if (field == value) return
+      field = value
+      updateCameraBinding()
+    }
+
+  /** Set by the ViewManager in addEventEmitters(); already throttled to 1/sec. */
+  var onFrameMetadataListener: ((FrameMetadata) -> Unit)? = null
+
+  /** Set by the ViewManager; already throttled (see [DETECTION_EVENT_THROTTLE_MS]). */
+  var onDocumentDetectedListener: ((DetectionUpdate) -> Unit)? = null
+
+  /** Set by the ViewManager; fires once per auto-capture trigger, not throttled. */
+  var onCapturedListener: ((DetectionUpdate) -> Unit)? = null
+
+  init {
+    addView(previewView, LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT))
+    addView(overlayView, LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT))
+    reactContext.addLifecycleEventListener(this)
+  }
+
+  override fun onAttachedToWindow() {
+    super.onAttachedToWindow()
+    updateCameraBinding()
+  }
+
+  override fun onDetachedFromWindow() {
+    super.onDetachedFromWindow()
+    cameraController.stop()
+  }
+
+  override fun onHostResume() {
+    updateCameraBinding()
+  }
+
+  override fun onHostPause() {
+    cameraController.stop()
+  }
+
+  override fun onHostDestroy() {
+    cameraController.stop()
+  }
+
+  /** Called by the ViewManager when RN drops this view instance. */
+  fun release() {
+    cameraController.stop()
+    reactContext.removeLifecycleEventListener(this)
+    analysisExecutor.shutdown()
+  }
+
+  private fun updateCameraBinding() {
+    if (!isActive || !isAttachedToWindow) {
+      cameraController.stop()
+      return
+    }
+
+    val lifecycleOwner = reactContext.currentActivity as? LifecycleOwner
+    if (lifecycleOwner == null) {
+      Log.w(TAG, "no LifecycleOwner available on currentActivity; cannot bind camera")
+      return
+    }
+
+    cameraController.start(
+      context = reactContext,
+      lifecycleOwner = lifecycleOwner,
+      previewView = previewView,
+      analysisExecutor = analysisExecutor,
+      onFrame = { metadata -> emitFrameThrottled(metadata) },
+      detectionPipeline = detectionPipeline,
+      onDetection = { update -> handleDetection(update) },
+    )
+  }
+
+  private fun handleDetection(update: DetectionUpdate) {
+    // Native, every frame -- no bridge cost, so the overlay stays smooth regardless of
+    // how the JS-facing event below is throttled.
+    overlayView.post { overlayView.update(update.corners, update.isStable) }
+
+    emitDetectionThrottled(update)
+
+    if (update.shouldCapture) {
+      onCapturedListener?.invoke(update)
+      detectionPipeline.resetAfterCapture()
+    }
+  }
+
+  private fun emitFrameThrottled(metadata: FrameMetadata) {
+    val now = metadata.timestampMs
+    val last = lastFrameEmitMs.get()
+    if (now - last >= FRAME_EVENT_THROTTLE_MS && lastFrameEmitMs.compareAndSet(last, now)) {
+      onFrameMetadataListener?.invoke(metadata)
+    }
+  }
+
+  private fun emitDetectionThrottled(update: DetectionUpdate) {
+    val now = System.currentTimeMillis()
+    val last = lastDetectionEmitMs.get()
+    if (now - last >= DETECTION_EVENT_THROTTLE_MS && lastDetectionEmitMs.compareAndSet(last, now)) {
+      onDocumentDetectedListener?.invoke(update)
+    }
+  }
+
+  companion object {
+    private const val TAG = "PetrusCameraView"
+    private const val FRAME_EVENT_THROTTLE_MS = 1000L
+
+    // Faster than the frame-metadata throttle: onDocumentDetected drives live
+    // stability/confidence feedback in JS, where 1/sec would feel laggy. The overlay
+    // itself already renders at full frame rate natively, independent of this.
+    private const val DETECTION_EVENT_THROTTLE_MS = 150L
+  }
+}

package/android/src/main/java/com/petrusreactnative/PetrusCameraViewManager.kt

@@ -0,0 +1,93 @@
+package com.petrusreactnative
+
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.uimanager.SimpleViewManager
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.UIManagerHelper
+import com.facebook.react.uimanager.ViewManagerDelegate
+import com.facebook.react.uimanager.annotations.ReactProp
+import com.facebook.react.viewmanagers.PetrusCameraViewManagerDelegate
+import com.facebook.react.viewmanagers.PetrusCameraViewManagerInterface
+import com.petrusreactnative.events.CapturedEvent
+import com.petrusreactnative.events.DocumentDetectedEvent
+import com.petrusreactnative.events.FrameMetadataEvent
+
+/**
+ * Fabric ViewManager for PetrusCameraView. [PetrusCameraViewManagerInterface] and
+ * [PetrusCameraViewManagerDelegate] are codegen-generated at build time from
+ * src/PetrusCameraViewNativeComponent.ts -- they don't exist in source form.
+ */
+@ReactModule(name = PetrusCameraViewManager.NAME)
+class PetrusCameraViewManager :
+  SimpleViewManager<PetrusCameraView>(), PetrusCameraViewManagerInterface<PetrusCameraView> {
+
+  private val delegate: ViewManagerDelegate<PetrusCameraView> =
+    PetrusCameraViewManagerDelegate(this)
+
+  override fun getDelegate(): ViewManagerDelegate<PetrusCameraView> = delegate
+
+  override fun getName(): String = NAME
+
+  override fun createViewInstance(context: ThemedReactContext): PetrusCameraView =
+    PetrusCameraView(context)
+
+  @ReactProp(name = "isActive", defaultBoolean = false)
+  override fun setIsActive(view: PetrusCameraView, value: Boolean) {
+    view.isActive = value
+  }
+
+  override fun addEventEmitters(reactContext: ThemedReactContext, view: PetrusCameraView) {
+    view.onFrameMetadataListener = { metadata ->
+      UIManagerHelper.getEventDispatcher(reactContext)
+        ?.dispatchEvent(FrameMetadataEvent(UIManagerHelper.getSurfaceId(view), view.id, metadata))
+    }
+
+    view.onDocumentDetectedListener = { update ->
+      UIManagerHelper.getEventDispatcher(reactContext)
+        ?.dispatchEvent(
+          DocumentDetectedEvent(UIManagerHelper.getSurfaceId(view), view.id, update)
+        )
+    }
+
+    view.onCapturedListener = { update ->
+      val corners = update.corners
+      if (corners != null) {
+        UIManagerHelper.getEventDispatcher(reactContext)
+          ?.dispatchEvent(
+            CapturedEvent(
+              UIManagerHelper.getSurfaceId(view),
+              view.id,
+              corners,
+              update.confidence,
+              System.currentTimeMillis(),
+            )
+          )
+      }
+    }
+  }
+
+  // The generated Delegate handles prop dispatch, but event registration still has to
+  // be exported manually -- matches RN's own built-in ViewManagers (e.g.
+  // SwipeRefreshLayoutManager), which do the same even where a generated
+  // Interface/Delegate is also in use.
+  override fun getExportedCustomDirectEventTypeConstants(): MutableMap<String, Any> {
+    val eventTypeConstants = super.getExportedCustomDirectEventTypeConstants() ?: HashMap()
+    eventTypeConstants["topFrameMetadata"] = mutableMapOf("registrationName" to "onFrameMetadata")
+    eventTypeConstants["topDocumentDetected"] =
+      mutableMapOf("registrationName" to "onDocumentDetected")
+    eventTypeConstants["topCaptured"] = mutableMapOf("registrationName" to "onCaptured")
+    return eventTypeConstants
+  }
+
+  override fun onDropViewInstance(view: PetrusCameraView) {
+    view.onFrameMetadataListener = null
+    view.onDocumentDetectedListener = null
+    view.onCapturedListener = null
+    view.release()
+    super.onDropViewInstance(view)
+  }
+
+  companion object {
+    const val NAME = "PetrusCameraView"
+  }
+}

package/android/src/main/java/com/petrusreactnative/PetrusOverlayView.kt

@@ -0,0 +1,87 @@
+package com.petrusreactnative
+
+import android.content.Context
+import android.graphics.Canvas
+import android.graphics.Color
+import android.graphics.Paint
+import android.graphics.Path
+import android.view.View
+import com.petrus.core.detection.DocumentCorners
+import com.petrus.core.detection.Point2D
+
+/**
+ * Transparent overlay drawing the detected document boundary on top of the camera
+ * preview. Pure rendering -- receives already-computed [DocumentCorners], does no CV
+ * itself. Owned and updated by [PetrusCameraView]; not a separately RN-exposed view.
+ *
+ * Coordinate mapping assumes this view's aspect ratio approximates the (rotated)
+ * analysis frame's aspect ratio -- PreviewView's exact scale-type crop isn't accounted
+ * for. See the README's known limitations.
+ */
+class PetrusOverlayView(context: Context) : View(context) {
+
+  private var corners: DocumentCorners? = null
+  private var isStable: Boolean = false
+
+  private val strokePaint =
+    Paint(Paint.ANTI_ALIAS_FLAG).apply {
+      style = Paint.Style.STROKE
+      strokeWidth = STROKE_WIDTH_PX
+    }
+  private val cornerPaint = Paint(Paint.ANTI_ALIAS_FLAG).apply { style = Paint.Style.FILL }
+  private val path = Path()
+
+  init {
+    setWillNotDraw(false)
+  }
+
+  fun update(corners: DocumentCorners?, isStable: Boolean) {
+    this.corners = corners
+    this.isStable = isStable
+    invalidate()
+  }
+
+  override fun onDraw(canvas: Canvas) {
+    super.onDraw(canvas)
+    val current = corners ?: return
+    if (width == 0 || height == 0) return
+
+    val color = if (isStable) STABLE_COLOR else DETECTING_COLOR
+    strokePaint.color = color
+    cornerPaint.color = color
+
+    val points = mapToViewSpace(current)
+
+    path.reset()
+    path.moveTo(points[0].first, points[0].second)
+    for (i in 1 until points.size) {
+      path.lineTo(points[i].first, points[i].second)
+    }
+    path.close()
+    canvas.drawPath(path, strokePaint)
+
+    for ((x, y) in points) {
+      canvas.drawCircle(x, y, CORNER_RADIUS_PX, cornerPaint)
+    }
+  }
+
+  private fun mapToViewSpace(corners: DocumentCorners): List<Pair<Float, Float>> =
+    listOf(corners.topLeft, corners.topRight, corners.bottomRight, corners.bottomLeft)
+      .map { rotateNormalized(it, corners.rotationDegrees) }
+      .map { (x, y) -> x * width to y * height }
+
+  private fun rotateNormalized(point: Point2D, rotationDegrees: Int): Pair<Float, Float> =
+    when (((rotationDegrees % 360) + 360) % 360) {
+      90 -> (1f - point.y) to point.x
+      180 -> (1f - point.x) to (1f - point.y)
+      270 -> point.y to (1f - point.x)
+      else -> point.x to point.y
+    }
+
+  companion object {
+    private val STABLE_COLOR = Color.parseColor("#4CD964")
+    private val DETECTING_COLOR = Color.parseColor("#FFCC00")
+    private const val CORNER_RADIUS_PX = 10f
+    private const val STROKE_WIDTH_PX = 6f
+  }
+}