@rejourneyco/react-native 1.0.8 → 1.0.10

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

@@ -19,6 +19,7 @@ package com.rejourney.recording
 import com.rejourney.engine.DiagnosticLog
 import kotlinx.coroutines.*
 import okhttp3.*
+import com.rejourney.recording.RejourneyNetworkInterceptor
 import okhttp3.MediaType.Companion.toMediaType
 import okhttp3.RequestBody.Companion.toRequestBody
 import org.json.JSONObject
@@ -127,6 +128,8 @@ class SegmentDispatcher private constructor() {
         .connectTimeout(5, TimeUnit.SECONDS) // Short timeout for debugging
         .readTimeout(10, TimeUnit.SECONDS)
         .writeTimeout(10, TimeUnit.SECONDS)
+        // Mirror iOS URLProtocol: ensure native upload/auth traffic is captured
+        .addInterceptor(RejourneyNetworkInterceptor())
         .build()
     
     private val retryQueue = mutableListOf<PendingUpload>()
@@ -259,6 +262,8 @@ class SegmentDispatcher private constructor() {
         backgroundDurationMs: Long,
         metrics: Map<String, Any>?,
         currentQueueDepth: Int = 0,
+        endReason: String? = null,
+        lifecycleVersion: Int? = null,
         completion: (Boolean) -> Unit
     ) {
         val url = "$endpoint/api/ingest/session/end"
@@ -270,6 +275,8 @@ class SegmentDispatcher private constructor() {
             if (backgroundDurationMs > 0) put("totalBackgroundTimeMs", backgroundDurationMs)
             metrics?.let { put("metrics", JSONObject(it)) }
             put("sdkTelemetry", buildSdkTelemetry(currentQueueDepth))
+            if (!endReason.isNullOrBlank()) put("endReason", endReason)
+            if ((lifecycleVersion ?: 0) > 0) put("lifecycleVersion", lifecycleVersion)
         }
         
         val request = buildRequest(url, body)

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

@@ -173,6 +173,9 @@ class StabilityMonitor private constructor(private val context: Context) {
         ReplayOrchestrator.shared?.incrementFaultTally()
         persistIncident(incident)
         
+        // Flush visual frames to disk for crash safety
+        try { VisualCapture.shared?.flushToDisk() } catch (_: Exception) { }
+        
         // Give time to write
         Thread.sleep(150)
     }

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

@@ -130,6 +130,32 @@ class TelemetryPipeline private constructor(private val context: Context) {
         }
     }
     
+    /**
+     * Pause the heartbeat timer when the app goes to background.
+     * This prevents the pipeline from uploading empty event batches
+     * while backgrounded, which would inflate session duration.
+     */
+    fun pause() {
+        heartbeatRunnable?.let { mainHandler.removeCallbacks(it) }
+        heartbeatRunnable = null
+    }
+    
+    /**
+     * Resume the heartbeat timer when the app returns to foreground.
+     */
+    fun resume() {
+        if (heartbeatRunnable != null) return
+        mainHandler.post {
+            heartbeatRunnable = object : Runnable {
+                override fun run() {
+                    dispatchNow()
+                    mainHandler.postDelayed(this, 5000)
+                }
+            }
+            mainHandler.postDelayed(heartbeatRunnable!!, 5000)
+        }
+    }
+    
     fun shutdown() {
         heartbeatRunnable?.let { mainHandler.removeCallbacks(it) }
         heartbeatRunnable = null
@@ -320,6 +346,15 @@ class TelemetryPipeline private constructor(private val context: Context) {
         ))
     }
     
+    fun recordConsoleLogEvent(level: String, message: String) {
+        enqueue(mapOf(
+            "type" to "log",
+            "timestamp" to ts(),
+            "level" to level,
+            "message" to message
+        ))
+    }
+    
     fun recordJSErrorEvent(name: String, message: String, stack: String?) {
         val event = mutableMapOf<String, Any>(
             "type" to "error",
@@ -331,6 +366,8 @@ class TelemetryPipeline private constructor(private val context: Context) {
             event["stack"] = stack
         }
         enqueue(event)
+        // Prioritize JS error delivery to reduce loss on fatal terminations.
+        serialWorker.execute { shipPendingEvents() }
     }
     
     fun recordAnrEvent(durationMs: Long, stack: String?) {
@@ -344,6 +381,8 @@ class TelemetryPipeline private constructor(private val context: Context) {
             event["stack"] = stack
         }
         enqueue(event)
+        // Prioritize ANR delivery while the process is still alive.
+        serialWorker.execute { shipPendingEvents() }
     }
     
     fun recordUserAssociation(userId: String) {

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

@@ -203,6 +203,14 @@ class ViewHierarchyScanner private constructor() {
     }
     
     private fun isSensitive(view: View): Boolean {
+        if (view.contentDescription?.toString() == "rejourney_occlude") return true
+        
+        try {
+            // Check for React Native accessibility hint tag
+            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) {
             val inputType = view.inputType
             // Check for password input types

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

@@ -30,6 +30,7 @@ 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
@@ -170,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()
@@ -241,7 +246,7 @@ class VisualCapture private constructor(private val context: Context) {
             
             if (bounds.width() <= 0 || bounds.height() <= 0) return
             
-            val redactRects = redactionMask.computeRects()
+            val redactRects = redactionMask.computeRects(decorView)
             
             val screenScale = 1.25f
             val scaledWidth = (bounds.width() / screenScale).toInt()
@@ -466,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) {
@@ -481,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,
@@ -496,6 +513,7 @@ class VisualCapture private constructor(private val context: Context) {
                 frameFiles.forEach { it.delete() }
                 framesPath.delete()
             }
+            completion?.invoke(ok)
         }
     }
 }
@@ -530,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))
     }
@@ -538,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/main/java/com/rejourney/utility/DataCompression.kt

@@ -17,21 +17,33 @@
 package com.rejourney.utility
 
 import java.io.ByteArrayOutputStream
+import java.io.OutputStream
+import java.util.zip.Deflater
 import java.util.zip.GZIPOutputStream
 
 /**
  * Data compression utilities
  * Android implementation aligned with iOS DataCompression.swift
+ * Uses level 9 (BEST_COMPRESSION) for smaller S3 payloads.
  */
 object DataCompression {
+
+    /**
+     * GZIPOutputStream that uses Deflater.BEST_COMPRESSION for maximum ratio.
+     */
+    private class GzipLevel9OutputStream(out: OutputStream) : GZIPOutputStream(out) {
+        init {
+            def.setLevel(Deflater.BEST_COMPRESSION)
+        }
+    }
     
     /**
-     * Compress data using gzip
+     * Compress data using gzip (level 9)
      */
     fun gzipCompress(data: ByteArray): ByteArray? {
         return try {
             val bos = ByteArrayOutputStream()
-            GZIPOutputStream(bos).use { gzip ->
+            GzipLevel9OutputStream(bos).use { gzip ->
                 gzip.write(data)
             }
             bos.toByteArray()

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) {