@rejourneyco/react-native 1.0.7 → 1.0.9

package/android/src/main/java/com/rejourney/recording/VisualCapture.kt

@@ -26,8 +26,11 @@ import android.graphics.Rect
 import android.os.Handler
 import android.os.Looper
 import android.os.SystemClock
+import android.view.TextureView
 import android.view.View
+import android.view.ViewGroup
 import android.view.WindowManager
+import android.widget.EditText
 import com.rejourney.engine.DiagnosticLog
 import com.rejourney.utility.gzipCompress
 import java.io.ByteArrayOutputStream
@@ -60,7 +63,7 @@ class VisualCapture private constructor(private val context: Context) {
             get() = instance
     }
     
-    var snapshotInterval: Double = 0.5
+    var snapshotInterval: Double = 1.0
     var quality: Float = 0.5f
     
     val isCapturing: Boolean
@@ -91,18 +94,17 @@ class VisualCapture private constructor(private val context: Context) {
     
     // Current activity reference
     private var currentActivity: WeakReference<Activity>? = null
+
     
     fun setCurrentActivity(activity: Activity?) {
         currentActivity = if (activity != null) WeakReference(activity) else null
-        DiagnosticLog.notice("[VisualCapture] setCurrentActivity: ${activity?.javaClass?.simpleName ?: "null"}")
+        DiagnosticLog.trace("[VisualCapture] setCurrentActivity: ${activity?.javaClass?.simpleName ?: "null"}")
     }
     
     fun beginCapture(sessionOrigin: Long) {
-        DiagnosticLog.notice("[VisualCapture] beginCapture called, currentActivity=${currentActivity?.get()?.javaClass?.simpleName ?: "null"}, state=${stateMachine.currentState}")
-        DiagnosticLog.trace("[VisualCapture] beginCapture called, currentActivity=${currentActivity?.get()?.javaClass?.simpleName ?: "null"}")
+        DiagnosticLog.trace("[VisualCapture] beginCapture called, currentActivity=${currentActivity?.get()?.javaClass?.simpleName ?: "null"}, state=${stateMachine.currentState}")
         if (!stateMachine.transition(CaptureState.CAPTURING)) {
-            DiagnosticLog.notice("[VisualCapture] beginCapture REJECTED - state transition failed from ${stateMachine.currentState}")
-            DiagnosticLog.trace("[VisualCapture] beginCapture failed - state transition rejected")
+            DiagnosticLog.trace("[VisualCapture] beginCapture REJECTED - state transition failed from ${stateMachine.currentState}")
             return
         }
         sessionEpoch = sessionOrigin
@@ -116,7 +118,6 @@ class VisualCapture private constructor(private val context: Context) {
             }
         }
         
-        DiagnosticLog.notice("[VisualCapture] Starting capture timer with interval=${snapshotInterval}s")
         DiagnosticLog.trace("[VisualCapture] Starting capture timer with interval=${snapshotInterval}s")
         startCaptureTimer()
     }
@@ -138,6 +139,21 @@ class VisualCapture private constructor(private val context: Context) {
         flushBufferToDisk()
     }
     
+    /** Submit any buffered frames to the upload pipeline immediately
+     *  (regardless of batch size threshold). Packages synchronously to
+     *  avoid race conditions during backgrounding. */
+    fun flushBufferToNetwork() {
+        // Take frames from buffer synchronously (not via async sendScreenshots)
+        val images = stateLock.withLock {
+            val copy = screenshots.toList()
+            screenshots.clear()
+            copy
+        }
+        if (images.isEmpty()) return
+        // Package and submit synchronously on this thread
+        packageAndShip(images, sessionEpoch)
+    }
+    
     fun activateDeferredMode() {
         deferredUntilCommit = true
     }
@@ -155,6 +171,10 @@ class VisualCapture private constructor(private val context: Context) {
         redactionMask.remove(view)
     }
     
+    fun invalidateMaskCache() {
+        redactionMask.invalidateCache()
+    }
+    
     fun configure(snapshotInterval: Double, jpegQuality: Double) {
         this.snapshotInterval = snapshotInterval
         this.quality = jpegQuality.toFloat()
@@ -165,14 +185,14 @@ class VisualCapture private constructor(private val context: Context) {
     }
     
     fun snapshotNow() {
-        mainHandler.post { captureFrame() }
+        mainHandler.post { captureFrame(force = true) }
     }
     
     private fun startCaptureTimer() {
         stopCaptureTimer()
         captureRunnable = object : Runnable {
             override fun run() {
-                captureFrame()
+                captureFrame(force = false)
                 mainHandler.postDelayed(this, (snapshotInterval * 1000).toLong())
             }
         }
@@ -184,101 +204,178 @@ class VisualCapture private constructor(private val context: Context) {
         captureRunnable = null
     }
     
-    private fun captureFrame() {
+    private fun captureFrame(force: Boolean = false) {
         val currentFrameNum = frameCounter.get()
-        // Log first 3 frames at notice level
         if (currentFrameNum < 3) {
-            DiagnosticLog.notice("[VisualCapture] captureFrame #$currentFrameNum, state=${stateMachine.currentState}, activity=${currentActivity?.get()?.javaClass?.simpleName ?: "null"}")
+            DiagnosticLog.trace("[VisualCapture] captureFrame #$currentFrameNum, state=${stateMachine.currentState}, activity=${currentActivity?.get()?.javaClass?.simpleName ?: "null"}")
         }
         
         if (stateMachine.currentState != CaptureState.CAPTURING) {
-            DiagnosticLog.notice("[VisualCapture] captureFrame skipped - state=${stateMachine.currentState}")
             DiagnosticLog.trace("[VisualCapture] captureFrame skipped - state=${stateMachine.currentState}")
             return
         }
         
         val activity = currentActivity?.get()
         if (activity == null) {
-            if (currentFrameNum < 3) {
-                DiagnosticLog.notice("[VisualCapture] captureFrame skipped - NO ACTIVITY")
-            }
             DiagnosticLog.trace("[VisualCapture] captureFrame skipped - no activity")
             return
         }
         
+        // Refresh map detection state (very cheap shallow walk)
+        SpecialCases.shared.refreshMapState(activity)
+        
+        // Map stutter prevention: when a map view is visible and its camera
+        // is still moving (user gesture or animation), skip decorView.draw()
+        // entirely — this call triggers GPU readback on SurfaceView/TextureView
+        // map tiles which causes visible stutter.  We resume capture at 1 FPS
+        // once the map SDK reports idle.
+        if (!force && SpecialCases.shared.mapVisible && !SpecialCases.shared.mapIdle) {
+            if (currentFrameNum < 3 || currentFrameNum % 30 == 0L) {
+                DiagnosticLog.trace("[VisualCapture] SKIPPING capture - map moving (mapIdle=false)")
+            }
+            return
+        }
+        
         val frameStart = SystemClock.elapsedRealtime()
         
         try {
-            val decorView = activity.window?.decorView ?: return
+            val window = activity.window ?: return
+            val decorView = window.decorView
             val bounds = Rect()
             decorView.getWindowVisibleDisplayFrame(bounds)
             
             if (bounds.width() <= 0 || bounds.height() <= 0) return
             
-            val redactRects = redactionMask.computeRects()
+            val redactRects = redactionMask.computeRects(decorView)
             
-            // Use lower scale to reduce encoding time significantly
             val screenScale = 1.25f
             val scaledWidth = (bounds.width() / screenScale).toInt()
             val scaledHeight = (bounds.height() / screenScale).toInt()
             
+            // 1. Draw the View tree (captures everything except GPU surfaces)
             val bitmap = Bitmap.createBitmap(scaledWidth, scaledHeight, Bitmap.Config.ARGB_8888)
             val canvas = Canvas(bitmap)
             canvas.scale(1f / screenScale, 1f / screenScale)
-            
             decorView.draw(canvas)
             
-            // Apply redactions
-            if (redactRects.isNotEmpty()) {
-                val paint = Paint().apply {
-                    color = Color.BLACK
-                    style = Paint.Style.FILL
-                }
-                for (rect in redactRects) {
-                    if (rect.width() > 0 && rect.height() > 0) {
-                        canvas.drawRect(
-                            rect.left / screenScale,
-                            rect.top / screenScale,
-                            rect.right / screenScale,
-                            rect.bottom / screenScale,
-                            paint
-                        )
-                    }
-                }
-            }
+            // 2. Composite GPU surfaces (TextureView/SurfaceView) on top.
+            //    decorView.draw() renders these as black; we grab their pixels
+            //    directly and paint them at the correct position.
+            compositeGpuSurfaces(decorView, canvas, screenScale)
             
-            // Compress to JPEG
-            val stream = ByteArrayOutputStream()
-            bitmap.compress(Bitmap.CompressFormat.JPEG, (quality * 100).toInt(), stream)
-            bitmap.recycle()
+            processCapture(bitmap, redactRects, screenScale, frameStart, force)
             
-            val data = stream.toByteArray()
-            val captureTs = System.currentTimeMillis()
-            val frameNum = frameCounter.incrementAndGet()
-            
-            // Log first frame and every 30 frames
-            if (frameNum == 1L) {
-                DiagnosticLog.notice("[VisualCapture] First frame captured! size=${data.size} bytes")
+        } catch (e: Exception) {
+            DiagnosticLog.fault("Frame capture failed: ${e.message}")
+        }
+    }
+    
+    /**
+     * Find all TextureView instances in the hierarchy and draw their GPU-rendered
+     * content onto the capture canvas at the correct position.  decorView.draw()
+     * renders TextureView/SurfaceView as black; this fills in the actual pixels.
+     *
+     * Mapbox uses SurfaceView by default, so we use MapView.snapshot() to capture
+     * the map and composite it at the correct position.
+     */
+    private fun compositeGpuSurfaces(root: View, canvas: Canvas, screenScale: Float) {
+        findTextureViews(root) { tv ->
+            try {
+                val tvBitmap = tv.bitmap ?: return@findTextureViews
+                val loc = IntArray(2)
+                tv.getLocationInWindow(loc)
+                canvas.drawBitmap(tvBitmap, loc[0].toFloat(), loc[1].toFloat(), null)
+                tvBitmap.recycle()
+            } catch (_: Exception) {
+                // Safety: never crash if TextureView.getBitmap() fails
             }
-            if (frameNum % 30 == 0L) {
-                val frameDurationMs = (SystemClock.elapsedRealtime() - frameStart).toDouble()
-                val isMainThread = Looper.myLooper() == Looper.getMainLooper()
-                DiagnosticLog.perfFrame("screenshot", frameDurationMs, frameNum.toInt(), isMainThread)
+        }
+        compositeMapboxSnapshot(root, canvas)
+    }
+
+    /**
+     * Mapbox MapView uses SurfaceView; decorView.draw() renders it black.
+     * Use MapView.snapshot() (Mapbox SDK API) to capture the map and composite it.
+     */
+    private fun compositeMapboxSnapshot(root: View, canvas: Canvas) {
+        val mapView = SpecialCases.shared.getMapboxMapViewForSnapshot(root) ?: return
+        try {
+            val snapshot = mapView.javaClass.getMethod("snapshot").invoke(mapView)
+            val bitmap = snapshot as? Bitmap ?: return
+            val loc = IntArray(2)
+            mapView.getLocationInWindow(loc)
+            canvas.drawBitmap(bitmap, loc[0].toFloat(), loc[1].toFloat(), null)
+            bitmap.recycle()
+        } catch (e: Exception) {
+            DiagnosticLog.trace("[VisualCapture] Mapbox snapshot failed: ${e.message}")
+        }
+    }
+    
+    private fun findTextureViews(view: View, action: (TextureView) -> Unit) {
+        if (view is TextureView && view.isAvailable) {
+            action(view)
+        }
+        if (view is ViewGroup) {
+            for (i in 0 until view.childCount) {
+                findTextureViews(view.getChildAt(i), action)
             }
-            
-            // Store in buffer
-            stateLock.withLock {
-                screenshots.add(Pair(data, captureTs))
-                enforceScreenshotCaps()
-                val shouldSend = !deferredUntilCommit && screenshots.size >= batchSize
-                
-                if (shouldSend) {
-                    sendScreenshots()
+        }
+    }
+    
+    private fun processCapture(
+        bitmap: Bitmap,
+        redactRects: List<Rect>,
+        screenScale: Float,
+        frameStart: Long,
+        force: Boolean
+    ) {
+        // Apply redactions
+        if (redactRects.isNotEmpty()) {
+            val canvas = Canvas(bitmap)
+            val paint = Paint().apply {
+                color = Color.BLACK
+                style = Paint.Style.FILL
+            }
+            for (rect in redactRects) {
+                if (rect.width() > 0 && rect.height() > 0) {
+                    canvas.drawRect(
+                        rect.left / screenScale,
+                        rect.top / screenScale,
+                        rect.right / screenScale,
+                        rect.bottom / screenScale,
+                        paint
+                    )
                 }
             }
+        }
+        
+        // Compress to JPEG
+        val stream = ByteArrayOutputStream()
+        bitmap.compress(Bitmap.CompressFormat.JPEG, (quality * 100).toInt(), stream)
+        bitmap.recycle()
+        
+        val data = stream.toByteArray()
+        val captureTs = System.currentTimeMillis()
+        val frameNum = frameCounter.incrementAndGet()
+        
+        if (frameNum == 1L) {
+            DiagnosticLog.trace("[VisualCapture] First frame captured! size=${data.size} bytes")
+        }
+        if (frameNum % 30 == 0L) {
+            val frameDurationMs = (SystemClock.elapsedRealtime() - frameStart).toDouble()
+            val isMainThread = Looper.myLooper() == Looper.getMainLooper()
+            DiagnosticLog.perfFrame("screenshot", frameDurationMs, frameNum.toInt(), isMainThread)
+        }
+        
+        // Store in buffer
+        stateLock.withLock {
+            screenshots.add(Pair(data, captureTs))
+            enforceScreenshotCaps()
+            val shouldSend = !deferredUntilCommit && screenshots.size >= batchSize
             
-        } catch (e: Exception) {
-            DiagnosticLog.fault("Frame capture failed: ${e.message}")
+            if (shouldSend) {
+                sendScreenshots()
+            }
         }
     }
     
@@ -302,7 +399,7 @@ class VisualCapture private constructor(private val context: Context) {
             return
         }
         
-        DiagnosticLog.notice("[VisualCapture] sendScreenshots: sending ${images.size} frames")
+        DiagnosticLog.trace("[VisualCapture] sendScreenshots: sending ${images.size} frames")
         
         // All heavy work happens in background
         encodeExecutor.execute {
@@ -374,12 +471,18 @@ class VisualCapture private constructor(private val context: Context) {
         sendScreenshots()
     }
     
-    fun uploadPendingFrames(sessionId: String) {
+    fun uploadPendingFrames(sessionId: String, completion: ((Boolean) -> Unit)? = null) {
         val framesPath = File(context.cacheDir, "rj_pending/$sessionId/frames")
         
-        if (!framesPath.exists()) return
+        if (!framesPath.exists()) {
+            completion?.invoke(true)
+            return
+        }
         
-        val frameFiles = framesPath.listFiles()?.sortedBy { it.name } ?: return
+        val frameFiles = framesPath.listFiles()?.sortedBy { it.name } ?: run {
+            completion?.invoke(true)
+            return
+        }
         
         val frames = mutableListOf<Pair<ByteArray, Long>>()
         for (file in frameFiles) {
@@ -389,9 +492,15 @@ class VisualCapture private constructor(private val context: Context) {
             frames.add(Pair(data, ts))
         }
         
-        if (frames.isEmpty()) return
+        if (frames.isEmpty()) {
+            completion?.invoke(true)
+            return
+        }
         
-        val bundle = packageFrameBundle(frames, frames.first().second) ?: return
+        val bundle = packageFrameBundle(frames, frames.first().second) ?: run {
+            completion?.invoke(false)
+            return
+        }
         
         SegmentDispatcher.shared.transmitFrameBundle(
             payload = bundle,
@@ -404,6 +513,7 @@ class VisualCapture private constructor(private val context: Context) {
                 frameFiles.forEach { it.delete() }
                 framesPath.delete()
             }
+            completion?.invoke(ok)
         }
     }
 }
@@ -438,6 +548,10 @@ private class CaptureStateMachine {
 private class RedactionMask {
     private val views = CopyOnWriteArrayList<WeakReference<View>>()
     
+    private val cachedAutoRects = mutableListOf<Rect>()
+    private var lastScanTime = 0L
+    private val scanCacheDurationMs = 500L
+    
     fun add(view: View) {
         views.add(WeakReference(view))
     }
@@ -446,29 +560,81 @@ private class RedactionMask {
         views.removeIf { it.get() === view || it.get() == null }
     }
     
-    fun computeRects(): List<Rect> {
+    fun invalidateCache() {
+        lastScanTime = 0L
+    }
+    
+    fun computeRects(decorView: View? = null): List<Rect> {
         val rects = mutableListOf<Rect>()
         views.removeIf { it.get() == null }
         
         for (ref in views) {
             val view = ref.get() ?: continue
-            if (!view.isShown) continue
-            
-            val location = IntArray(2)
-            view.getLocationOnScreen(location)
-            
-            val rect = Rect(
-                location[0],
-                location[1],
-                location[0] + view.width,
-                location[1] + view.height
-            )
-            
-            if (rect.width() > 0 && rect.height() > 0) {
-                rects.add(rect)
+            val rect = getViewRect(view)
+            if (rect != null) rects.add(rect)
+        }
+        
+        if (decorView != null) {
+            val now = SystemClock.elapsedRealtime()
+            if (now - lastScanTime >= scanCacheDurationMs) {
+                cachedAutoRects.clear()
+                scanForSensitiveViews(decorView, cachedAutoRects)
+                lastScanTime = now
             }
+            rects.addAll(cachedAutoRects)
         }
         
         return rects
     }
+    
+    private fun getViewRect(view: View): Rect? {
+        if (!view.isShown || view.width <= 0 || view.height <= 0) return null
+        val location = IntArray(2)
+        view.getLocationOnScreen(location)
+        val rect = Rect(
+            location[0],
+            location[1],
+            location[0] + view.width,
+            location[1] + view.height
+        )
+        if (rect.width() > 0 && rect.height() > 0) return rect
+        return null
+    }
+
+    private fun scanForSensitiveViews(view: View, rects: MutableList<Rect>, depth: Int = 0) {
+        if (depth > 20) return
+        if (!view.isShown || view.alpha <= 0.01f || view.width <= 0 || view.height <= 0) return
+        
+        if (shouldMask(view)) {
+            val rect = getViewRect(view)
+            if (rect != null) {
+                rects.add(rect)
+                return
+            }
+        }
+        
+        if (view is ViewGroup) {
+            for (i in 0 until view.childCount) {
+                scanForSensitiveViews(view.getChildAt(i), rects, depth + 1)
+            }
+        }
+    }
+
+    private fun shouldMask(view: View): Boolean {
+        if (view.contentDescription?.toString() == "rejourney_occlude") return true
+        
+        try {
+            val hint = view.getTag(com.facebook.react.R.id.accessibility_hint) as? String
+            if (hint == "rejourney_occlude") return true
+        } catch (_: Exception) { }
+        
+        if (view is EditText) return true
+        
+        val className = view.javaClass.simpleName.lowercase(java.util.Locale.US)
+        if (className.contains("camera") || (className.contains("surfaceview") && className.contains("preview"))) {
+            return true
+        }
+        
+        return false
+    }
 }

package/android/src/newarch/java/com/rejourney/RejourneyModule.kt

@@ -191,6 +191,20 @@ class RejourneyModule(reactContext: ReactApplicationContext) :
            instance.getUserIdentity(promise)
     }
 
+    @ReactMethod
+    @DoNotStrip
+    override fun setAnonymousId(anonymousId: String, promise: Promise) {
+           val instance = getImplOrReject(promise) ?: return
+           instance.setAnonymousId(anonymousId, promise)
+    }
+
+    @ReactMethod
+    @DoNotStrip
+    override fun getAnonymousId(promise: Promise) {
+           val instance = getImplOrReject(promise) ?: return
+           instance.getAnonymousId(promise)
+    }
+
     @ReactMethod
     @DoNotStrip
     override fun setDebugMode(enabled: Boolean, promise: Promise) {

package/android/src/oldarch/java/com/rejourney/RejourneyModule.kt

@@ -224,6 +224,24 @@ class RejourneyModule(reactContext: ReactApplicationContext) :
         }
     }
 
+    @ReactMethod
+    fun setAnonymousId(anonymousId: String, promise: Promise) {
+        try {
+            impl.setAnonymousId(anonymousId, promise)
+        } catch (e: Exception) {
+            promise.resolve(createErrorMap("Module initialization failed: ${e.message}"))
+        }
+    }
+
+    @ReactMethod
+    fun getAnonymousId(promise: Promise) {
+        try {
+            impl.getAnonymousId(promise)
+        } catch (e: Exception) {
+            promise.resolve(null)
+        }
+    }
+
     @ReactMethod
     fun setSDKVersion(version: String) {
         try {

package/ios/Engine/DeviceRegistrar.swift

@@ -37,6 +37,7 @@ public final class DeviceRegistrar: NSObject {
     // MARK: Private State
     
     private let _keychainId = "com.rejourney.device.fingerprint"
+    private let _fallbackIdKey = "com.rejourney.device.fallbackId"
     
     private lazy var _httpSession: URLSession = {
         let config = URLSessionConfiguration.default
@@ -124,13 +125,22 @@ public final class DeviceRegistrar: NSObject {
         
         var composite = bundleId
         composite += device.model
-        composite += device.systemName
-        composite += device.systemVersion
-        composite += device.identifierForVendor?.uuidString ?? UUID().uuidString
+        composite += device.identifierForVendor?.uuidString ?? _stableDeviceFallback()
         
         return _sha256(composite)
     }
     
+    /// Returns a keychain-persisted UUID so the fingerprint stays stable even when
+    /// identifierForVendor is temporarily nil (early boot, App Clips, extensions).
+    private func _stableDeviceFallback() -> String {
+        if let existing = _keychainLoad(_fallbackIdKey) {
+            return existing
+        }
+        let fresh = UUID().uuidString
+        _keychainSave(_fallbackIdKey, value: fresh)
+        return fresh
+    }
+    
     // MARK: Server Communication
     
     private func _fetchServerCredential(fingerprint: String, apiToken: String, completion: @escaping (Bool, String?) -> Void) {