Merge develop → main (AR stability + depth estimation for non-LiDAR) (#428)

* chore: fix ios crash, add depth-based ar hit

* fix: hitResultId not available issue

* chore: made non-lidar to fallback to mono, simplify integration and bug fixes

* feat: integrate depth changes from virocore

* feat: include latest virocore

* chore: implement latest virocore

* fix: remove debug shader from production code

---------

Co-authored-by: Benito Mota <benmotanoti@gmail.com>

Author: doranteseduardo

android/react_viro/react_viro-release.aar

@@ -114,6 +114,8 @@ dependencies {
     implementation 'androidx.appcompat:appcompat:1.0.0'
     testImplementation 'junit:junit:4.12'
     implementation 'com.google.ar:core:1.43.0'
+    // Required for ARCore Geospatial API
+    implementation 'com.google.android.gms:play-services-location:21.0.1'
     implementation project(':gvr_common')
     implementation project(':viro_renderer')
     implementation 'com.google.android.exoplayer:exoplayer:2.19.1'

android/viro_bridge/build.gradle

@@ -30,6 +30,7 @@
 import com.facebook.react.bridge.Arguments;
 import com.facebook.react.bridge.WritableArray;
 import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.uimanager.events.RCTEventEmitter;
 import com.viro.core.ARAnchor;
 import com.viro.core.ARNode;
 import com.viro.core.ARScene;
@@ -60,6 +61,10 @@ public class VRTARSceneNavigator extends VRT3DSceneNavigator {
     private boolean mGeospatialModeEnabled = false;
     private boolean mNeedsGeospatialModeToggle = false;
 
+    // Track if we were detached from window (for tab switching detection)
+    // This is separate from VRTComponent's mDetached which tracks React tree detachment
+    private boolean mWasDetachedFromWindow = false;
+
     private static class StartupListenerARCore implements ViroViewARCore.StartupListener {
 
         private WeakReference<VRTARSceneNavigator> mNavigator;
@@ -178,36 +183,101 @@ public void resetARSession() {
         // No-op for now.
     }
 
+    @Override
+    protected void onAttachedToWindow() {
+        android.util.Log.i(TAG, "=== onAttachedToWindow START ===");
+        android.util.Log.i(TAG, "  mWasDetachedFromWindow: " + mWasDetachedFromWindow);
+        android.util.Log.i(TAG, "  mViroView: " + (mViroView != null ? "NOT NULL" : "NULL"));
+
+        // Detect tab switch scenario: we were detached before and ViroView was disposed
+        if (mWasDetachedFromWindow && mViroView == null) {
+            android.util.Log.i(TAG, "  TAB SWITCH DETECTED - Emitting event to React");
+
+            // Emit event to React side to trigger remount
+            emitTabSwitchEvent();
+
+            // Reset flag
+            mWasDetachedFromWindow = false;
+
+            // Don't call super - React will remount us with a fresh key
+            android.util.Log.i(TAG, "=== onAttachedToWindow END (waiting for React remount) ===");
+            return;
+        }
+
+        // Normal attach (first time or after resume without disposal)
+        super.onAttachedToWindow();
+
+        // Re-enable rotation listener when view is reattached
+        if (mRotationListener != null) {
+            mRotationListener.enable();
+            android.util.Log.i(TAG, "  Rotation listener enabled");
+        }
+
+        android.util.Log.i(TAG, "=== onAttachedToWindow END (normal) ===");
+    }
+
     @Override
     protected void onDetachedFromWindow() {
-        super.onDetachedFromWindow();
+        android.util.Log.i(TAG, "=== onDetachedFromWindow START ===");
+        android.util.Log.i(TAG, "  mViroView: " + (mViroView != null ? "NOT NULL" : "NULL"));
+
+        // Mark that we were detached - used to detect tab switches
+        mWasDetachedFromWindow = true;
+
+        // Disable rotation listener
         if (mRotationListener != null) {
             mRotationListener.disable();
+            android.util.Log.i(TAG, "  Rotation listener disabled");
         }
+
+        // Pause AR session before disposal
+        ViroViewARCore arView = getARView();
+        if (arView != null) {
+            android.app.Activity activity = mReactContext.getCurrentActivity();
+            if (activity != null) {
+                android.util.Log.i(TAG, "  Pausing AR session");
+                arView.onActivityPaused(activity);
+                arView.onActivityStopped(activity);
+            }
+        }
+
+        // Call parent to dispose ViroView normally
+        // This is correct for both tab switching and component unmount
+        super.onDetachedFromWindow();
+
+        android.util.Log.i(TAG, "=== onDetachedFromWindow END ===");
     }
 
     /**
-     * Explicitly dispose of AR resources. Called from componentWillUnmount to ensure
-     * proper cleanup even if onDetachedFromWindow is delayed or not called.
-     * This method can be called multiple times safely.
+     * Emit an event to the React side indicating a tab switch was detected.
+     * The React component will listen for this event and trigger a remount.
      */
+    private void emitTabSwitchEvent() {
+        WritableMap event = Arguments.createMap();
+        event.putString("type", "tabSwitch");
+
+        try {
+            mReactContext
+                .getJSModule(RCTEventEmitter.class)
+                .receiveEvent(getId(), "onTabSwitch", event);
+            android.util.Log.i(TAG, "  Tab switch event emitted to React");
+        } catch (Exception e) {
+            android.util.Log.e(TAG, "  Failed to emit tab switch event: " + e.getMessage());
+        }
+    }
+
     public void dispose() {
+        // Clear the window detachment flag since this is a permanent disposal
+        mWasDetachedFromWindow = false;
+
         // Disable rotation listener
         if (mRotationListener != null) {
             mRotationListener.disable();
             mRotationListener = null;
         }
 
-        // Get AR view and pause the session
-        ViroViewARCore arView = getARView();
-        if (arView != null) {
-            // Pause the AR session to release camera and other resources
-            arView.onActivityPaused(null);
-        }
-
-        // Trigger parent class cleanup which handles scene teardown and ViroView disposal
-        // This is the same logic as onDetachedFromWindow in VRT3DSceneNavigator
-        // but can be called proactively from React Native
+        // The parent's onDetachedFromWindow() will be called by the view system
+        // when the component is actually removed, so we don't need to call it here
     }
 
     public void setAutoFocusEnabled(boolean enabled) {

android/viro_bridge/src/main/java/com/viromedia/bridge/component/VRTARSceneNavigator.java

@@ -25,9 +25,12 @@
 
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.common.MapBuilder;
 import com.facebook.react.uimanager.ThemedReactContext;
 import com.facebook.react.uimanager.annotations.ReactProp;
 
+import java.util.Map;
+
 /**
  * ARSceneNavigatorManager for building a {@link VRTARSceneNavigator}
  * corresponding to the ViroARNavigator.js control.
@@ -113,4 +116,18 @@ public void setWorldMeshEnabled(VRTARSceneNavigator navigator, boolean enabled)
     public void setWorldMeshConfig(VRTARSceneNavigator navigator, ReadableMap config) {
         navigator.setWorldMeshConfig(config);
     }
+
+    @Override
+    public Map<String, Object> getExportedCustomDirectEventTypeConstants() {
+        Map<String, Object> events = super.getExportedCustomDirectEventTypeConstants();
+        if (events == null) {
+            events = MapBuilder.newHashMap();
+        }
+
+        // Export the onTabSwitch event so React can listen to it
+        // This event is emitted when a tab switch is detected (window reattach after detach)
+        events.put("onTabSwitch", MapBuilder.of("registrationName", "onTabSwitch"));
+
+        return events;
+    }
 }

android/viro_bridge/src/main/java/com/viromedia/bridge/component/VRTARSceneNavigatorManager.java

@@ -423,27 +423,49 @@ private void updateSpawnModifier(){
             for (int i = 0; i < burstArray.size(); i++) {
                 ReadableMap burstmap = burstArray.getMap(i);
 
+                // Validate required fields
+                if (!burstmap.hasKey("min") || !burstmap.hasKey("max")) {
+                    onError("Viro: emissionBurst[" + i + "] is missing required 'min' and/or 'max' fields, skipping.");
+                    continue;
+                }
+
                 ParticleEmitter.Factor referenceFactor;
                 float valueStart;
                 float coolPeriod;
                 int min, max;
                 int cycles;
+
+                // Handle time-based or distance-based burst
                 if (burstmap.hasKey("time")) {
                     referenceFactor = ParticleEmitter.Factor.TIME;
                     valueStart = (float) burstmap.getDouble("time");
+                    // cooldownPeriod is optional, defaults to 0
                     coolPeriod = (float) (burstmap.hasKey("cooldownPeriod") ? burstmap.getDouble("cooldownPeriod") : 0);
                 } else if (burstmap.hasKey("distance")) {
                     referenceFactor = ParticleEmitter.Factor.DISTANCE;
                     valueStart = (float) burstmap.getDouble("distance");
+                    // cooldownDistance is optional, defaults to 0
                     coolPeriod = (float) (burstmap.hasKey("cooldownDistance") ? burstmap.getDouble("cooldownDistance") : 0);
                 } else {
-                    onError("Invalid Burst parameters provided!");
-                    return;
+                    onError("Viro: emissionBurst[" + i + "] must specify either 'time' or 'distance', skipping.");
+                    continue;
                 }
 
-                min = burstmap.hasKey("min") ? burstmap.getInt("min") : 0;
-                max = burstmap.hasKey("max") ? burstmap.getInt("max") : 0;
-                cycles = burstmap.hasKey("cycles") ? burstmap.getInt("cycles") : 0;
+                // Get min/max particle count
+                min = burstmap.getInt("min");
+                max = burstmap.getInt("max");
+
+                // Validate min/max range
+                if (min < 0 || max < 0 || min > max) {
+                    onError("Viro: emissionBurst[" + i + "] has invalid min/max values (min: " + min + ", max: " + max + "). Min and max must be >= 0 and min <= max, skipping.");
+                    continue;
+                }
+
+                // cycles is optional, defaults to 1
+                cycles = burstmap.hasKey("cycles") ? burstmap.getInt("cycles") : 1;
+                if (cycles <= 0) {
+                    cycles = 1; // Ensure at least 1 cycle
+                }
 
                 ParticleEmitter.EmissionBurst burst = new ParticleEmitter.EmissionBurst(referenceFactor,
                         valueStart, min, max, cycles, coolPeriod);