replate-camera 0.8.1 → 0.9.0

package/android/build.gradle

@@ -93,5 +93,6 @@ dependencies {
   implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
   implementation 'com.google.ar:core:1.45.0'
   implementation 'com.google.ar.sceneform.ux:sceneform-ux:1.17.1'
+  implementation("androidx.exifinterface:exifinterface:1.3.7")
 }
 

package/android/src/main/java/com/replatecamera/ReplateCameraModule.kt

@@ -0,0 +1,60 @@
+package com.replatecamera
+
+import com.facebook.react.bridge.*
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.uimanager.UIManagerHelper
+import com.facebook.react.uimanager.common.UIManagerType
+
+@ReactModule(name = ReplateCameraModule.NAME)
+class ReplateCameraModule(private val reactContext: ReactApplicationContext) :
+  ReactContextBaseJavaModule(reactContext) {
+
+  companion object {
+    const val NAME = "ReplateCameraModule"
+  }
+
+  override fun getName(): String = NAME
+
+  /**
+   * Example: takePhoto(...) from JS, returning a promise that resolves with the file URI or rejects on error.
+   *
+   * @param viewTag The React tag (integer) of the ReplateCameraView. From JS, you can get this via findNodeHandle(ref).
+   */
+  @ReactMethod
+  fun takePhoto(viewTag: Int, promise: Promise) {
+    val cameraView = findCameraViewByTag(viewTag)
+    if (cameraView == null) {
+      promise.reject("VIEW_NOT_FOUND", "No ReplateCameraView found with tag $viewTag")
+      return
+    }
+
+    // Call the Kotlin AR method:
+    cameraView.takePhoto { uri ->
+      if (uri != null) {
+        // resolve the promise with the URI string
+        promise.resolve(uri.toString())
+      } else {
+        promise.reject("PHOTO_ERROR", "Failed to capture photo.")
+      }
+    }
+  }
+
+  /**
+   * Example: resetSession(...) from JS, no return value needed.
+   */
+  @ReactMethod
+  fun resetSession(viewTag: Int) {
+    val cameraView = findCameraViewByTag(viewTag)
+    cameraView?.resetSession()
+  }
+
+  /**
+   * Helper function that looks up the ReplateCameraView instance by its React tag.
+   */
+  private fun findCameraViewByTag(viewTag: Int): ReplateCameraView? {
+    // Use UIManagerHelper to look up the native view associated with 'viewTag'.
+    val uiManager = UIManagerHelper.getUIManager(reactContext, UIManagerType.DEFAULT /* 1 => default type for Fabric or not */)
+    val nativeView = uiManager?.resolveView(viewTag)
+    return nativeView as? ReplateCameraView
+  }
+}

package/android/src/main/java/com/replatecamera/ReplateCameraPackage.kt

@@ -8,7 +8,7 @@ import com.facebook.react.uimanager.ViewManager
 
 class ReplateCameraPackage : ReactPackage {
   override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
-    return emptyList()
+    return listOf(ReplateCameraModule(reactContext))
   }
 
   override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {

package/android/src/main/java/com/replatecamera/ReplateCameraView.kt

@@ -4,105 +4,267 @@ import android.Manifest
 import android.app.Activity
 import android.content.Context
 import android.content.pm.PackageManager
+import android.graphics.*
+import android.net.Uri
 import android.os.Build
+import android.os.Environment
+import android.os.Handler
+import android.os.Looper
 import android.util.AttributeSet
+import android.util.Log
 import android.view.GestureDetector
 import android.view.MotionEvent
+import android.view.PixelCopy
 import android.view.ScaleGestureDetector
 import android.widget.FrameLayout
 import androidx.annotation.RequiresApi
 import androidx.core.app.ActivityCompat
 import androidx.core.content.ContextCompat
+import androidx.exifinterface.media.ExifInterface
 import androidx.fragment.app.FragmentActivity
+import com.google.ar.core.Anchor
 import com.google.ar.core.HitResult
-import com.google.ar.sceneform.AnchorNode
+import com.google.ar.core.Plane
+import com.google.ar.core.TrackingState
+import com.google.ar.sceneform.*
 import com.google.ar.sceneform.math.Vector3
+import com.google.ar.sceneform.rendering.Color
+import com.google.ar.sceneform.rendering.Material
 import com.google.ar.sceneform.rendering.MaterialFactory
 import com.google.ar.sceneform.rendering.ShapeFactory
 import com.google.ar.sceneform.ux.ArFragment
 import com.google.ar.sceneform.ux.TransformableNode
-import com.google.ar.sceneform.rendering.Color
+import java.io.File
+import java.io.FileOutputStream
+import java.text.SimpleDateFormat
+import java.util.Date
+import kotlin.math.acos
+import kotlin.math.atan2
+import kotlin.math.cos
+import kotlin.math.round
+import kotlin.math.sin
 import kotlin.math.sqrt
 
+/**
+ * Kotlin version of an ARCore/Sceneform view, mimicking much of the Swift+RealityKit approach.
+ * - Creates spheres in two circles around an anchor.
+ * - Allows pan/pinch to move/scale.
+ * - Captures screenshots with metadata placeholders.
+ * - Tracks gravity vector via SensorManager (TYPE_GRAVITY).
+ *
+ * Usage:
+ * 1) In your Activity/Fragment layout, add a <FrameLayout> that hosts this view.
+ * 2) Instantiate ReplateCameraView in code or via XML. The ARFragment is attached dynamically.
+ * 3) Call takePhoto() to save a screenshot to external files.
+ */
 @RequiresApi(Build.VERSION_CODES.N)
 class ReplateCameraView @JvmOverloads constructor(
-  context: Context, attrs: AttributeSet? = null, defStyleAttr: Int = 0
-) : FrameLayout(context, attrs, defStyleAttr) {
+  context: Context,
+  attrs: AttributeSet? = null,
+  defStyleAttr: Int = 0
+) : FrameLayout(context, attrs, defStyleAttr), Scene.OnUpdateListener,
+  android.hardware.SensorEventListener {
+
+  companion object {
+    private const val TAG = "ReplateCameraView"
+
+    // Number of spheres per circle (mirrors Swift code's 72)
+    private const val TOTAL_SPHERES_PER_CIRCLE = 72
+    // Each sphere is placed 5 degrees apart => 360/5 = 72
+    private const val ANGLE_INCREMENT_DEGREES = 5f
+
+    // Initial defaults that match the Swift code
+    private const val DEFAULT_SPHERE_RADIUS = 0.004f
+    private const val DEFAULT_SPHERES_RADIUS = 0.13f
+    private const val DEFAULT_SPHERES_HEIGHT = 0.10f
+    private const val DEFAULT_DISTANCE_BETWEEN_CIRCLES = 0.10f
+    private const val DEFAULT_DRAG_SPEED = 7000f
+    private const val ANGLE_THRESHOLD = 0.6f  // Radians
+    private const val MIN_DISTANCE = 0.15f
+    private const val MAX_DISTANCE = 0.65f
 
+    // Track whether each sphere index is "set" (mirroring Swift arrays)
+    private val upperSpheresSet = BooleanArray(TOTAL_SPHERES_PER_CIRCLE) { false }
+    private val lowerSpheresSet = BooleanArray(TOTAL_SPHERES_PER_CIRCLE) { false }
+
+    // Stats
+    var totalPhotosTaken = 0
+    var photosFromDifferentAnglesTaken = 0
+  }
+
+  // AR Sceneform stuff
   private lateinit var arFragment: ArFragment
   private var anchorNode: AnchorNode? = null
-  private var spheres: MutableList<TransformableNode> = mutableListOf()
+
+  // Spheres and a "focus node"
+  private val spheresModels = mutableListOf<TransformableNode>()
+  private var focusNode: Node? = null
+
+  // Scene geometry
+  private var sphereRadius = DEFAULT_SPHERE_RADIUS
+  private var spheresRadius = DEFAULT_SPHERES_RADIUS
+  private var sphereAngle = ANGLE_INCREMENT_DEGREES  // If you want to “scale angle”
+  private var spheresHeight = DEFAULT_SPHERES_HEIGHT
+  private var distanceBetweenCircles = DEFAULT_DISTANCE_BETWEEN_CIRCLES
+  private var circleInFocus = 0 // 0 => lower circle, 1 => upper circle
+  private var dragSpeed = DEFAULT_DRAG_SPEED
+
+  // Gravity vector
+  private var gravityVector = mutableMapOf<String, Double>()
+
+  // Gesture detectors for custom pan/pinch (replicating Swift approach)
   private var gestureDetector: GestureDetector
   private var scaleDetector: ScaleGestureDetector
-  private var sphereRadius = 0.004f
-  private var sphereCircleRadius =  0.13f
-  private var dragSpeed = 0.005f
 
+  // ------------------------------------------------------------------------
+  // Init & Setup
+  // ------------------------------------------------------------------------
   init {
-    setupArFragment()
     requestCameraPermission()
+    setupArFragment()
+
     gestureDetector = GestureDetector(context, GestureListener())
     scaleDetector = ScaleGestureDetector(context, ScaleListener())
+
+    // Register a gravity sensor to replicate iOS's CMMotionManager
+    val sensorManager = context.getSystemService(Context.SENSOR_SERVICE)
+      as? android.hardware.SensorManager
+    sensorManager?.getDefaultSensor(android.hardware.Sensor.TYPE_GRAVITY)?.also { gravitySensor ->
+      sensorManager.registerListener(this, gravitySensor, android.hardware.SensorManager.SENSOR_DELAY_GAME)
+    }
   }
 
+  /**
+   * If camera permission not granted, request at runtime (for AR use).
+   */
+  private fun requestCameraPermission() {
+    if (ContextCompat.checkSelfPermission(context, Manifest.permission.CAMERA)
+      != PackageManager.PERMISSION_GRANTED) {
+      ActivityCompat.requestPermissions(
+        context as Activity,
+        arrayOf(Manifest.permission.CAMERA),
+        0
+      )
+    }
+  }
+
+  /**
+   * Programmatically attach an ArFragment into this FrameLayout.
+   * We also add ourselves as a Scene update listener.
+   */
   @RequiresApi(Build.VERSION_CODES.N)
   private fun setupArFragment() {
     arFragment = ArFragment()
-    val fragmentManager = (context as FragmentActivity).supportFragmentManager
-    fragmentManager.beginTransaction().replace(this.id, arFragment).commit()
+    val fm = (context as FragmentActivity).supportFragmentManager
 
-    arFragment.arSceneView.scene.addOnUpdateListener { frameTime ->
-      arFragment.onUpdate(frameTime)
-      onUpdateFrame()
-    }
+    fm.beginTransaction().replace(this.id, arFragment).commitAllowingStateLoss()
+    // Add an update listener
+    arFragment.arSceneView.scene.addOnUpdateListener(this)
 
-    arFragment.setOnTapArPlaneListener { hitResult, plane, motionEvent ->
+    // Listen for plane taps
+    arFragment.setOnTapArPlaneListener { hitResult: HitResult, plane: Plane, motionEvent: MotionEvent ->
       if (anchorNode == null) {
         anchorNode = createAnchorNode(hitResult)
-        createSpheres()
+        createSpheresAtY(spheresHeight) // Lower circle
+        createSpheresAtY(distanceBetweenCircles + spheresHeight) // Upper circle
+        createFocusSphere()
       }
     }
   }
 
+  /**
+   * Creates and returns an AnchorNode from a tap HitResult.
+   */
   private fun createAnchorNode(hitResult: HitResult): AnchorNode {
-    val anchor = hitResult.createAnchor()
-    val anchorNode = AnchorNode(anchor)
-    anchorNode.setParent(arFragment.arSceneView.scene)
-    return anchorNode
+    val anchor: Anchor = hitResult.createAnchor()
+    return AnchorNode(anchor).also { node ->
+      node.setParent(arFragment.arSceneView.scene)
+    }
+  }
+
+  // ------------------------------------------------------------------------
+  // Scene OnUpdateListener => replicates Swift ARSessionDelegate
+  // ------------------------------------------------------------------------
+  override fun onUpdate(frameTime: FrameTime?) {
+    val frame = arFragment.arSceneView.arFrame ?: return
+    if (frame.camera.trackingState != TrackingState.TRACKING) return
+
+    // If you need per-frame logic, do it here.
+    // Example: check lighting, or do real-time distance checks, etc.
   }
 
+  // ------------------------------------------------------------------------
+  // Spheres Logic
+  // ------------------------------------------------------------------------
   @RequiresApi(Build.VERSION_CODES.N)
-  private fun createSpheres() {
-    for (i in 0 until 72) {
-      val angle = Math.toRadians((i * 5).toDouble()).toFloat()
-      val x = sphereCircleRadius * Math.cos(angle.toDouble()).toFloat()
-      val z = sphereCircleRadius * Math.sin(angle.toDouble()).toFloat()
-      createSphere(Vector3(x, 0.10f, z))
+  private fun createSpheresAtY(y: Float) {
+    for (i in 0 until TOTAL_SPHERES_PER_CIRCLE) {
+      val angleRad = Math.toRadians((i * ANGLE_INCREMENT_DEGREES).toDouble()).toFloat()
+      val x = spheresRadius * cos(angleRad.toDouble()).toFloat()
+      val z = spheresRadius * sin(angleRad.toDouble()).toFloat()
+      createSphere(Vector3(x, y, z))
     }
   }
 
   @RequiresApi(Build.VERSION_CODES.N)
   private fun createSphere(position: Vector3) {
     MaterialFactory.makeOpaqueWithColor(context, Color(android.graphics.Color.WHITE))
-      .thenAccept { material ->
-        val sphere = ShapeFactory.makeSphere(sphereRadius, position, material)
-        val node = TransformableNode(arFragment.transformationSystem)
-        node.renderable = sphere
-        node.setParent(anchorNode)
-        spheres.add(node)
+      .thenAccept { material: Material ->
+        val sphereRenderable = ShapeFactory.makeSphere(sphereRadius, Vector3.zero(), material)
+        val sphereNode = TransformableNode(arFragment.transformationSystem)
+        sphereNode.renderable = sphereRenderable
+        sphereNode.worldPosition = position
+        sphereNode.setParent(anchorNode)
+        spheresModels.add(sphereNode)
       }
   }
 
-  private fun onUpdateFrame() {
-    // Handle frame updates
+  @RequiresApi(Build.VERSION_CODES.N)
+  private fun createFocusSphere() {
+    // Parent node for the two green spheres + optional overlay
+    val parentNode = Node().apply { setParent(anchorNode) }
+    focusNode = parentNode
+
+    // Lower focus sphere
+    MaterialFactory.makeOpaqueWithColor(context, Color(0f, 1f, 0f))
+      .thenAccept { mat ->
+        val r = sphereRadius * 1.5f
+        val renderable = ShapeFactory.makeSphere(r, Vector3.zero(), mat)
+        val sphereN = Node()
+        sphereN.worldPosition = Vector3(0f, spheresHeight, 0f)
+        sphereN.renderable = renderable
+        parentNode.addChild(sphereN)
+      }
+
+    // Upper focus sphere
+    MaterialFactory.makeOpaqueWithColor(context, Color(0f, 1f, 0f))
+      .thenAccept { mat ->
+        val r = sphereRadius * 1.5f
+        val renderable = ShapeFactory.makeSphere(r, Vector3.zero(), mat)
+        val sphereN = Node()
+        sphereN.worldPosition = Vector3(0f, spheresHeight + distanceBetweenCircles, 0f)
+        sphereN.renderable = renderable
+        parentNode.addChild(sphereN)
+      }
+
+    // If you have a custom "center.obj", load via ModelRenderable builder or Filament loader
+    // parentNode.addChild(loadedCustomOverlayNode)
   }
 
+  // ------------------------------------------------------------------------
+  // Gestures (Mirror Swift's tap, pan, pinch)
+  // ------------------------------------------------------------------------
   override fun onTouchEvent(event: MotionEvent): Boolean {
-    return scaleDetector.onTouchEvent(event) || gestureDetector.onTouchEvent(event)
+    scaleDetector.onTouchEvent(event)
+    gestureDetector.onTouchEvent(event)
+    return true
   }
 
   private inner class GestureListener : GestureDetector.SimpleOnGestureListener() {
-    override fun onSingleTapUp(event: MotionEvent): Boolean {
+
+    override fun onSingleTapUp(e: MotionEvent): Boolean {
+      Log.d(TAG, "Single tap up at x=${e.x}, y=${e.y}")
+      // If you want custom logic (like Swift's "viewTapped"), put it here
       return true
     }
 
@@ -112,105 +274,197 @@ class ReplateCameraView @JvmOverloads constructor(
       distanceX: Float,
       distanceY: Float
     ): Boolean {
-      // Assuming you have a reference to the AR scene view and the anchor entity
       val sceneView = arFragment.arSceneView
-      val anchorEntity = anchorNode
-      anchorEntity?.let {
-        // Get the camera's transformation matrix
-        val cameraTransform = sceneView.scene.camera.worldPosition
-
-        if (e2.action == MotionEvent.ACTION_MOVE) {
-          // Calculate the translation
-          val translationX = -distanceX
-          val translationY = -distanceY
-
-          // Extract forward and right vectors from the camera transform matrix
-          val forward = Vector3(
-            -cameraTransform.x,
-            0f,
-            -cameraTransform.z
-          ) // Assuming Y is up
-          val right = Vector3(
-            cameraTransform.x,
-            0f,
-            cameraTransform.z
-          ) // Assuming Y is up
-
-          // Normalize the vectors
-          val forwardNormalized = normalize(forward)
-          val rightNormalized = normalize(right)
-
-          // Calculate the adjusted movement based on user input and camera orientation
-          val adjustedMovement = Vector3(
-            translationX * rightNormalized.x + translationY * forwardNormalized.x,
-            0f, // Assuming you want to keep the movement in the horizontal plane
-            -translationX * rightNormalized.z - translationY * forwardNormalized.z // Invert the z movement
-          )
-
-          // Update the position of the anchor entity
-          val initialPosition = anchorEntity.worldPosition
-          anchorEntity.worldPosition = Vector3.add(
-            initialPosition,
-            adjustedMovement.scaled(1f / dragSpeed)
-          )
-
-          // Reset translation
-          e2.setLocation(0f, 0f)
-        }
-      }
+      val currentAnchor = anchorNode ?: return true
+
+      // Replicate Swift handlePan => anchorNode position changes based on camera orientation
+      val camera = sceneView.scene.camera
+      if (e2.action == MotionEvent.ACTION_MOVE && camera != null) {
+        val translationX = -distanceX
+        val translationY = -distanceY
+
+        // Sceneform camera: forward is -Z, right is +X
+        val cameraForward = Vector3(camera.forward.x, 0f, camera.forward.z)
+        val cameraRight = Vector3(camera.right.x, 0f, camera.right.z)
 
+        val forwardNorm = normalize(cameraForward)
+        val rightNorm = normalize(cameraRight)
+
+        // Similar to Swift: anchorEntity.position = initialPosition + adjustedMovement / dragSpeed
+        val adjustedMovement = Vector3(
+          translationX * rightNorm.x + translationY * forwardNorm.x,
+          0f,
+          translationX * rightNorm.z + translationY * forwardNorm.z
+        ).scaled(1f / dragSpeed)
+
+        val initialPos = currentAnchor.worldPosition
+        currentAnchor.worldPosition = Vector3.add(initialPos, adjustedMovement)
+      }
       return true
     }
 
-    private fun normalize(vector: Vector3): Vector3 {
-      val length = sqrt(vector.x * vector.x + vector.y * vector.y + vector.z * vector.z)
-      return Vector3(vector.x / length, vector.y / length, vector.z / length)
+    private fun normalize(v: Vector3): Vector3 {
+      val length = sqrt(v.x * v.x + v.y * v.y + v.z * v.z)
+      return if (length > 0.0001f) {
+        Vector3(v.x / length, v.y / length, v.z / length)
+      } else {
+        Vector3.zero()
+      }
     }
   }
 
   private inner class ScaleListener : ScaleGestureDetector.SimpleOnScaleGestureListener() {
     override fun onScale(detector: ScaleGestureDetector): Boolean {
-      // Ensure ARCore is set up properly
-      if (anchorNode == null) return false
-
-      // Calculate the scale factor from the detector
+      // Like Swift handlePinch => remove child spheres, scale, recreate
+      val currentAnchor = anchorNode ?: return false
       val scale = detector.scaleFactor
 
-      // Remove all spheres from the anchor node
-      arFragment.arSceneView.scene.addOnUpdateListener {
-        spheres.forEach { sphere ->
-          anchorNode?.removeChild(sphere)
+      // Remove all existing spheres
+      spheresModels.forEach { node -> currentAnchor.removeChild(node) }
+      spheresModels.clear()
+
+      // Remove focus
+      focusNode?.let { currentAnchor.removeChild(it) }
+      focusNode = null
+
+      // Scale the radii
+      sphereRadius *= scale
+      spheresRadius *= scale
+      sphereAngle *= scale  // if also scaling the angle
+      // Rebuild
+      createSpheresAtY(spheresHeight)
+      createSpheresAtY(distanceBetweenCircles + spheresHeight)
+      createFocusSphere()
+
+      return true
+    }
+  }
+
+  // ------------------------------------------------------------------------
+  // Photo Capture Implementation (PixelCopy)
+  // ------------------------------------------------------------------------
+  /**
+   * Takes a screenshot of the ArSceneView and embeds the current gravityVector
+   * as a JSON string in the EXIF “UserComment” field.
+   *
+   * @param onPhotoSaved Callback that gives you the Uri of the saved file (or null on failure).
+   */
+  fun takePhoto(onPhotoSaved: (Uri?) -> Unit = {}) {
+    val sceneView: ArSceneView = arFragment.arSceneView
+    val bitmap = Bitmap.createBitmap(sceneView.width, sceneView.height, Bitmap.Config.ARGB_8888)
+
+    PixelCopy.request(sceneView, bitmap, { copyResult ->
+      if (copyResult == PixelCopy.SUCCESS) {
+        // Save + embed EXIF
+        val savedUri = saveBitmapWithExif(bitmap, gravityVector)
+        if (savedUri != null) {
+          totalPhotosTaken += 1
+          Log.d(TAG, "Photo saved to: $savedUri")
+          onPhotoSaved(savedUri)
+        } else {
+          Log.e(TAG, "Failed to save photo.")
+          onPhotoSaved(null)
         }
-        spheres.clear()
+      } else {
+        Log.e(TAG, "PixelCopy failed with code $copyResult")
+        onPhotoSaved(null)
+      }
+    }, Handler(Looper.getMainLooper()))
+  }
 
-        // Update the scales for the spheres
-        sphereRadius *= scale
-        sphereCircleRadius *= scale
-        dragSpeed *= scale
+  /**
+   * Save the [bitmap] into JPEG. Then embed an EXIF “UserComment” that includes the gravity vector.
+   */
+  private fun saveBitmapWithExif(
+    bitmap: Bitmap,
+    gravity: Map<String, Double>
+  ): Uri? {
+    val picturesDir = context.getExternalFilesDir(Environment.DIRECTORY_PICTURES) ?: return null
+    val timeStamp = SimpleDateFormat("yyyyMMdd_HHmmss").format(Date())
+    val file = File(picturesDir, "AR_Capture_$timeStamp.jpg")
 
-        // Recreate spheres (similar to your Swift logic)
-        createSpheres()
+    return try {
+      // Write JPEG
+      FileOutputStream(file).use { out ->
+        bitmap.compress(Bitmap.CompressFormat.JPEG, 100, out)
+        out.flush()
       }
 
-      return true
+      // Now embed EXIF metadata
+      val exif = ExifInterface(file.absolutePath)
+      // Convert gravity vector to JSON-like string
+      val gx = gravity["x"] ?: 0.0
+      val gy = gravity["y"] ?: 0.0
+      val gz = gravity["z"] ?: 0.0
+
+      // Example JSON
+      // { "gravity": { "x":0.123, "y":-0.456, "z":9.81 } }
+      val gravityJson = """{ "gravity": { "x": $gx, "y": $gy, "z": $gz } }"""
+
+      exif.setAttribute(ExifInterface.TAG_USER_COMMENT, gravityJson)
+      // Save EXIF
+      exif.saveAttributes()
+
+      Uri.fromFile(file)
+    } catch (e: Exception) {
+      Log.e(TAG, "Error saving or updating EXIF: ${e.message}")
+      null
     }
   }
 
-  private fun requestCameraPermission() {
-    if (ContextCompat.checkSelfPermission(context, Manifest.permission.CAMERA)
-      != PackageManager.PERMISSION_GRANTED
-    ) {
-      ActivityCompat.requestPermissions(context as Activity, arrayOf(Manifest.permission.CAMERA), 0)
+  // ------------------------------------------------------------------------
+  // Gravity Sensor => Replicates CMMotionManager
+  // ------------------------------------------------------------------------
+  override fun onSensorChanged(event: android.hardware.SensorEvent?) {
+    if (event?.sensor?.type == android.hardware.Sensor.TYPE_GRAVITY) {
+      gravityVector["x"] = event.values[0].toDouble()
+      gravityVector["y"] = event.values[1].toDouble()
+      gravityVector["z"] = event.values[2].toDouble()
+      Log.d(TAG, "Gravity vector => x=${gravityVector["x"]}, y=${gravityVector["y"]}, z=${gravityVector["z"]}")
     }
   }
 
-  fun onRequestPermissionsResult(
-    requestCode: Int, permissions: Array<out String>, grantResults: IntArray
-  ) {
-    if (requestCode == 0 && grantResults.isNotEmpty() && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
-      // Permission granted
-    } else {
-      // Permission denied
+  override fun onAccuracyChanged(sensor: android.hardware.Sensor?, accuracy: Int) {
+    // Not used
+  }
+
+  // ------------------------------------------------------------------------
+  // Reset Logic
+  // ------------------------------------------------------------------------
+  /**
+   * Resets the AR session, removing anchors and restoring default geometry.
+   */
+  fun resetSession() {
+    anchorNode?.let { node ->
+      node.children.forEach { child ->
+        node.removeChild(child)
+      }
+      arFragment.arSceneView.scene.removeChild(node)
+    }
+    anchorNode = null
+    spheresModels.clear()
+    focusNode = null
+
+    // Reset booleans
+    for (i in upperSpheresSet.indices) {
+      upperSpheresSet[i] = false
+      lowerSpheresSet[i] = false
     }
+    totalPhotosTaken = 0
+    photosFromDifferentAnglesTaken = 0
+
+    // Reset geometry
+    sphereRadius = DEFAULT_SPHERE_RADIUS
+    spheresRadius = DEFAULT_SPHERES_RADIUS
+    sphereAngle = ANGLE_INCREMENT_DEGREES
+    spheresHeight = DEFAULT_SPHERES_HEIGHT
+    distanceBetweenCircles = DEFAULT_DISTANCE_BETWEEN_CIRCLES
+    circleInFocus = 0
+    dragSpeed = DEFAULT_DRAG_SPEED
+
+    // If you want to fully re-init the AR session, you could do:
+    // arFragment.arSceneView.session?.close()
+    // setupArFragment()
+    // But that may require re-attaching the fragment, so it depends on your usage.
   }
 }

package/android/src/main/java/com/replatecamera/ReplateCameraViewManager.kt

@@ -8,11 +8,11 @@ import com.facebook.react.uimanager.SimpleViewManager
 import com.facebook.react.uimanager.ThemedReactContext
 import com.facebook.react.uimanager.annotations.ReactProp
 
-class ReplateCameraViewManager : SimpleViewManager<View>() {
+class ReplateCameraViewManager : SimpleViewManager<ReplateCameraView>() {
   override fun getName() = "ReplateCameraView"
 
   @RequiresApi(Build.VERSION_CODES.N)
-  override fun createViewInstance(reactContext: ThemedReactContext): View {
+  override fun createViewInstance(reactContext: ThemedReactContext): ReplateCameraView {
     return ReplateCameraView(reactContext)
   }
 
@@ -20,4 +20,5 @@ class ReplateCameraViewManager : SimpleViewManager<View>() {
   fun setColor(view: View, color: String) {
     view.setBackgroundColor(Color.parseColor(color))
   }
+
 }

package/ios/ReplateCameraViewManager.swift

@@ -704,8 +704,8 @@ class ReplateCameraController: NSObject {
     private static let arQueue = DispatchQueue(label: "com.replate.ar.controller", qos: .userInteractive)
 
     // Configuration Constants
-    private static let MIN_DISTANCE: Float = 0.15
-    private static let MAX_DISTANCE: Float = 0.65
+    private static let MIN_DISTANCE: Float = 0.25
+    private static let MAX_DISTANCE: Float = 0.55
     private static let ANGLE_THRESHOLD: Float = 0.6
 //    private static let TARGET_IMAGE_SIZE = CGSize(width: 2048, height: 1556)
     private static let TARGET_IMAGE_SIZE = CGSize(width: 3072, height: 2304)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "replate-camera",
-  "version": "0.8.1",
+  "version": "0.9.0",
   "description": "Camera component for Replate Manager",
   "main": "lib/commonjs/index",
   "module": "lib/module/index",