@rejourneyco/react-native 1.0.0 → 1.0.2

package/README.md

@@ -0,0 +1,29 @@
+# @rejourneyco/react-native
+
+Lightweight session replay and observability SDK for React Native. Pixel-perfect video capture with real-time incident detection.
+
+## Installation
+
+```bash
+npm install @rejourneyco/react-native
+```
+
+## Quick Start
+
+```typescript
+import { initRejourney, startRejourney } from '@rejourneyco/react-native';
+
+// Initialize with your public key
+initRejourney('pk_live_xxxxxxxxxxxx');
+
+// Start recording after obtaining user consent
+startRejourney();
+```
+
+## Documentation
+
+Full integration guides and API reference: https://rejourney.co/docs/reactnative/overview
+
+## License
+
+Licensed under Apache 2.0

package/android/src/main/java/com/rejourney/RejourneyModuleImpl.kt

@@ -57,7 +57,6 @@ import java.io.File
 import java.util.*
 import java.util.concurrent.CopyOnWriteArrayList
 
-// Enum for session end reasons
 enum class EndReason {
     SESSION_TIMEOUT,
     MANUAL_STOP,
@@ -107,7 +106,6 @@ class RejourneyModuleImpl(
         }
     }
 
-    // Core components
     private var captureEngine: CaptureEngine? = null
     private var uploadManager: UploadManager? = null
     private var touchInterceptor: TouchInterceptor? = null
@@ -116,7 +114,6 @@ class RejourneyModuleImpl(
     private var keyboardTracker: KeyboardTracker? = null
     private var textInputTracker: TextInputTracker? = null
 
-    // Session state
     private var currentSessionId: String? = null
     private var userId: String? = null
     @Volatile private var isRecording: Boolean = false
@@ -134,59 +131,43 @@ class RejourneyModuleImpl(
     private var maxRecordingMinutes: Int = 10
     @Volatile private var sessionEndSent: Boolean = false
     
-    // Keyboard state
     private var keyPressCount: Int = 0
     private var isKeyboardVisible: Boolean = false
     private var lastKeyboardHeight: Int = 0
     
-    // Session state saved on background - used to restore on foreground if within timeout
     private var savedApiUrl: String = ""
     private var savedPublicKey: String = ""
     private var savedDeviceHash: String = ""
 
-    // Events buffer
     private val sessionEvents = CopyOnWriteArrayList<Map<String, Any?>>()
 
-    // Throttle immediate upload kicks (ms)
     @Volatile private var lastImmediateUploadKickMs: Long = 0
     
-    // Write-first event buffer for crash-safe persistence
     private var eventBuffer: EventBuffer? = null
 
-    // Coroutine scope for async operations
     private val scope = CoroutineScope(Dispatchers.Main + SupervisorJob())
     
-    // Dedicated scope for background flush - survives independently of main scope
-    // This prevents cancellation when app goes to background
     private val backgroundScope = CoroutineScope(Dispatchers.IO + SupervisorJob())
 
-    // Timer jobs
     private var batchUploadJob: Job? = null
     private var durationLimitJob: Job? = null
     
-    // Main thread handler for posting delayed tasks
     private val mainHandler = android.os.Handler(android.os.Looper.getMainLooper())
 
-    // Debounced background detection (prevents transient pauses from ending sessions)
     private var scheduledBackgroundRunnable: Runnable? = null
     private var backgroundScheduled: Boolean = false
 
-    // Safety flag
     @Volatile private var isShuttingDown = false
 
-    // Auth resilience - retry mechanism
     private var authRetryCount = 0
     private var authPermanentlyFailed = false
     private var authRetryJob: Job? = null
 
     init {
         // DO NOT initialize anything here that could throw exceptions
-        // React Native needs the module constructor to complete cleanly
-        // All initialization will happen lazily on first method call
         Logger.debug("RejourneyModuleImpl constructor completed")
     }
     
-    // Lazy initialization flag
     @Volatile
     private var isInitialized = false
     private val initLock = Any()
@@ -237,21 +218,19 @@ class RejourneyModuleImpl(
                     Logger.error("Failed to schedule recovery upload (non-critical)", e)
                 }
                 
-                // Check if app was killed in previous session (Android 11+)
+                // Che  ck if app was killed in previous session (Android 11+)
                 try {
                     checkPreviousAppKill()
                 } catch (e: Exception) {
                     Logger.error("Failed to check previous app kill (non-critical)", e)
                 }
                 
-                // Check for unclosed sessions from previous launch
                 try {
                     checkForUnclosedSessions()
                 } catch (e: Exception) {
                     Logger.error("Failed to check for unclosed sessions (non-critical)", e)
                 }
                 
-                // Log OEM information for debugging
                 val oem = OEMDetector.getOEM()
                 Logger.debug("Device OEM: $oem")
                 Logger.debug("OEM Recommendations: ${OEMDetector.getRecommendations()}")
@@ -291,7 +270,6 @@ class RejourneyModuleImpl(
                     Logger.error("Failed to set up task removed listener (non-critical)", e)
                 }
                 
-                // Use lifecycle log - only shown in debug builds
                 Logger.logInitSuccess(Constants.SDK_VERSION)
                 
                 isInitialized = true
@@ -313,8 +291,6 @@ class RejourneyModuleImpl(
         
         Logger.debug("[Rejourney] addEventWithPersistence: type=$eventType, sessionId=$sessionId, inMemoryCount=${sessionEvents.size + 1}")
         
-        // CRITICAL: Write to disk immediately for crash safety
-        // This ensures events are never lost even if app is force-killed
         val bufferSuccess = eventBuffer?.appendEvent(event) ?: false
         if (!bufferSuccess) {
             Logger.warning("[Rejourney] addEventWithPersistence: Failed to append event to buffer: type=$eventType")
@@ -322,7 +298,6 @@ class RejourneyModuleImpl(
             Logger.debug("[Rejourney] addEventWithPersistence: Event appended to buffer: type=$eventType")
         }
 
-        // Also add to in-memory buffer for batched upload
         sessionEvents.add(event)
         Logger.debug("[Rejourney] addEventWithPersistence: Event added to in-memory list: type=$eventType, totalInMemory=${sessionEvents.size}")
     }
@@ -332,14 +307,12 @@ class RejourneyModuleImpl(
      * This is more reliable than Activity lifecycle callbacks.
      */
     private fun registerProcessLifecycleObserver() {
-        // Must run on main thread
         Handler(Looper.getMainLooper()).post {
             try {
                 ProcessLifecycleOwner.get().lifecycle.addObserver(this)
                 Logger.debug("ProcessLifecycleOwner observer registered")
             } catch (e: Exception) {
                 Logger.error("Failed to register ProcessLifecycleOwner observer (non-critical)", e)
-                // This is non-critical - we can still use Activity lifecycle callbacks as fallback
             }
         }
     }
@@ -472,7 +445,40 @@ class RejourneyModuleImpl(
         }
     }
 
-    // ==================== React Native Methods ====================
+    fun getDeviceInfo(promise: Promise) {
+        try {
+            val map = Arguments.createMap()
+            map.putString("model", android.os.Build.MODEL)
+            map.putString("brand", android.os.Build.MANUFACTURER)
+            map.putString("systemName", "Android")
+            map.putString("systemVersion", android.os.Build.VERSION.RELEASE)
+            map.putString("bundleId", reactContext.packageName)
+            
+            try {
+                val pInfo = reactContext.packageManager.getPackageInfo(reactContext.packageName, 0)
+                map.putString("appVersion", pInfo.versionName)
+                if (android.os.Build.VERSION.SDK_INT >= 28) {
+                    map.putString("buildNumber", pInfo.longVersionCode.toString())
+                } else {
+                    @Suppress("DEPRECATION")
+                    map.putString("buildNumber", pInfo.versionCode.toString())
+                }
+            } catch (e: Exception) {
+                map.putString("appVersion", "unknown")
+            }
+            
+            map.putBoolean("isTablet", isTablet())
+            promise.resolve(map)
+        } catch (e: Exception) {
+            promise.reject("DEVICE_INFO_ERROR", e)
+        }
+    }
+
+    private fun isTablet(): Boolean {
+        val configuration = reactContext.resources.configuration
+        return (configuration.screenLayout and android.content.res.Configuration.SCREENLAYOUT_SIZE_MASK) >= 
+                android.content.res.Configuration.SCREENLAYOUT_SIZE_LARGE
+    }
 
     fun startSession(userId: String, apiUrl: String, publicKey: String, promise: Promise) {
         ensureInitialized() // Lazy init on first call
@@ -1005,7 +1011,14 @@ class RejourneyModuleImpl(
         try {
             val safeUserId = userId.ifEmpty { "anonymous" }
             
-            // Update userId
+            // KEY CHANGE: Persist directly to SharedPreferences (Native Storage)
+            // This replaces the need for async-storage on the JS side
+            reactContext.getSharedPreferences("rejourney", 0)
+                .edit()
+                .putString("rj_user_identity", safeUserId)
+                .apply()
+            
+            // Update in-memory state
             this.userId = safeUserId
             
             // Update upload manager
@@ -1030,6 +1043,10 @@ class RejourneyModuleImpl(
         }
     }
 
+    fun getUserIdentity(promise: Promise) {
+        promise.resolve(userId)
+    }
+
     // ==================== Helper Methods ====================
 
     private fun createResultMap(success: Boolean, sessionId: String, error: String? = null): WritableMap {

package/android/src/main/java/com/rejourney/capture/CaptureEngine.kt

@@ -178,6 +178,7 @@ class CaptureEngine(private val context: Context) : VideoEncoderDelegate {
     private val isShuttingDown = AtomicBoolean(false)
     private var _isRecording: Boolean = false
     private val captureInProgress = AtomicBoolean(false)
+    private val isWarmingUp = AtomicBoolean(false)
     private var sessionId: String? = null
     private var currentScreenName: String? = null
     private var viewScanner: ViewHierarchyScanner? = null
@@ -407,6 +408,23 @@ class CaptureEngine(private val context: Context) : VideoEncoderDelegate {
         
         Logger.info("[CaptureEngine] Resuming video capture")
 
+        // DEFENSIVE FIX: Warmup period
+        // When returning from background, the view hierarchy and layout may not be stable immediately.
+        // This is primarily an iOS issue but we apply it here for consistency and safety.
+        isWarmingUp.set(true)
+        Logger.debug("[CaptureEngine] Warmup started (200ms)")
+        
+        mainHandler.postDelayed({
+            if (isShuttingDown.get()) return@postDelayed
+            isWarmingUp.set(false)
+            Logger.debug("[CaptureEngine] Warmup complete")
+            
+            // Trigger immediate capture check
+            if (_isRecording) {
+                 requestCapture(CaptureImportance.MEDIUM, "warmup_complete", forceCapture = false)
+            }
+        }, 200)
+
         captureHeuristics.reset()
         resetCachedFrames()
         pendingCapture = null
@@ -594,6 +612,11 @@ class CaptureEngine(private val context: Context) : VideoEncoderDelegate {
     }
     private fun requestCapture(importance: CaptureImportance, reason: String, forceCapture: Boolean) {
         if (!_isRecording || isShuttingDown.get()) return
+
+        if (isWarmingUp.get()) {
+            return
+        }
+
         if (!forceCapture && !shouldCapture(importance)) {
             Logger.debug("[CaptureEngine] Capture throttled: $reason (importance: $importance)")
             return
@@ -687,7 +710,8 @@ class CaptureEngine(private val context: Context) : VideoEncoderDelegate {
         val decision = captureHeuristics.decisionForSignature(
             pending.layoutSignature,
             now,
-            hasLastFrame = lastCapturedBitmap != null
+            hasLastFrame = lastCapturedBitmap != null,
+            importance = pending.importance
         )
 
         if (decision.action == CaptureAction.Defer) {

package/android/src/main/java/com/rejourney/capture/CaptureHeuristics.kt

@@ -1,5 +1,7 @@
 package com.rejourney.capture
 
+import com.rejourney.core.CaptureImportance
+
 
 enum class CaptureAction {
     RenderNow,
@@ -216,53 +218,89 @@ class CaptureHeuristics {
         }
     }
 
-    fun decisionForSignature(signature: String?, nowMs: Long, hasLastFrame: Boolean): CaptureDecision {
+    fun decisionForSignature(signature: String?, nowMs: Long, hasLastFrame: Boolean, importance: CaptureImportance): CaptureDecision {
         var earliestSafeTime = nowMs
         var blockerReason = CaptureReason.RenderNow
 
-        considerBlockerSince(lastTouchTime, QUIET_TOUCH_MS, nowMs, earliestSafeTime)?.let {
-            earliestSafeTime = it
-            blockerReason = CaptureReason.DeferTouch
+        // Check importance to potentially bypass heuristics
+        val isUrgent = importance == CaptureImportance.HIGH || importance == CaptureImportance.CRITICAL
+
+        // Touch - Usually want smooth input, but CRITICAL updates (like navigation) take precedence
+        if (!isUrgent) {
+            considerBlockerSince(lastTouchTime, QUIET_TOUCH_MS, nowMs, earliestSafeTime)?.let {
+                earliestSafeTime = it
+                blockerReason = CaptureReason.DeferTouch
+            }
         }
-        considerBlockerSince(lastScrollTime, QUIET_SCROLL_MS, nowMs, earliestSafeTime)?.let {
-            earliestSafeTime = it
-            blockerReason = CaptureReason.DeferScroll
+
+        // Scroll - High jank risk
+        // Even urgent captures should respect scroll to avoid visible hitching, unless CRITICAL
+        if (importance != CaptureImportance.CRITICAL) {
+            considerBlockerSince(lastScrollTime, QUIET_SCROLL_MS, nowMs, earliestSafeTime)?.let {
+                earliestSafeTime = it
+                blockerReason = CaptureReason.DeferScroll
+            }
         }
-        considerBlockerSince(lastBounceTime, QUIET_BOUNCE_MS, nowMs, earliestSafeTime)?.let {
-            earliestSafeTime = it
-            blockerReason = CaptureReason.DeferBounce
+
+        // Bounce/Rubber-banding
+        if (!isUrgent) {
+            considerBlockerSince(lastBounceTime, QUIET_BOUNCE_MS, nowMs, earliestSafeTime)?.let {
+                earliestSafeTime = it
+                blockerReason = CaptureReason.DeferBounce
+            }
         }
-        considerBlockerSince(lastRefreshTime, QUIET_REFRESH_MS, nowMs, earliestSafeTime)?.let {
-            earliestSafeTime = it
-            blockerReason = CaptureReason.DeferRefresh
+
+        // Refresh
+        if (!isUrgent) {
+            considerBlockerSince(lastRefreshTime, QUIET_REFRESH_MS, nowMs, earliestSafeTime)?.let {
+                earliestSafeTime = it
+                blockerReason = CaptureReason.DeferRefresh
+            }
         }
-        considerBlockerSince(lastTransitionTime, QUIET_TRANSITION_MS, nowMs, earliestSafeTime)?.let {
-            earliestSafeTime = it
-            blockerReason = CaptureReason.DeferTransition
+
+        // Transition - KEY FIX: Urgent captures (NAVIGATION) must bypass this!
+        if (!isUrgent) {
+            considerBlockerSince(lastTransitionTime, QUIET_TRANSITION_MS, nowMs, earliestSafeTime)?.let {
+                earliestSafeTime = it
+                blockerReason = CaptureReason.DeferTransition
+            }
         }
 
         if (keyboardAnimating) {
             lastKeyboardTime = nowMs
         }
-        considerBlockerSince(lastKeyboardTime, QUIET_KEYBOARD_MS, nowMs, earliestSafeTime)?.let {
-            earliestSafeTime = it
-            blockerReason = CaptureReason.DeferKeyboard
+        // Keyboard animations can be jerky
+        if (!isUrgent) {
+            considerBlockerSince(lastKeyboardTime, QUIET_KEYBOARD_MS, nowMs, earliestSafeTime)?.let {
+                earliestSafeTime = it
+                blockerReason = CaptureReason.DeferKeyboard
+            }
         }
 
-        considerBlockerSince(lastMapTime, QUIET_MAP_MS, nowMs, earliestSafeTime)?.let {
-            earliestSafeTime = it
-            blockerReason = CaptureReason.DeferMap
-        }
+        // Map - Always defer map motion as it's very expensive and glitchy
+        // Maps are special; even CRITICAL captures might want to wait for map settle if possible,
+        // but we'll allow CRITICAL to force it if absolutely needed.
+        if (importance != CaptureImportance.CRITICAL) {
+             considerBlockerSince(lastMapTime, QUIET_MAP_MS, nowMs, earliestSafeTime)?.let {
+                earliestSafeTime = it
+                blockerReason = CaptureReason.DeferMap
+            }
 
-        if (mapSettleUntilMs > nowMs && mapSettleUntilMs > earliestSafeTime) {
-            earliestSafeTime = mapSettleUntilMs
-            blockerReason = CaptureReason.DeferMap
+            if (mapSettleUntilMs > nowMs && mapSettleUntilMs > earliestSafeTime) {
+                earliestSafeTime = mapSettleUntilMs
+                blockerReason = CaptureReason.DeferMap
+            }
         }
 
         if (animationBlocking) {
-            considerBlockerSince(lastAnimationTime, QUIET_ANIMATION_MS, nowMs, earliestSafeTime)?.let {
-                earliestSafeTime = it
-                blockerReason = CaptureReason.DeferBigAnimation
+            // Big animations (Lottie etc).
+            // If urgent, we might want to capture the final state of an animation or screen change
+            // regardless of the animation loop.
+            if (!isUrgent) {
+                considerBlockerSince(lastAnimationTime, QUIET_ANIMATION_MS, nowMs, earliestSafeTime)?.let {
+                    earliestSafeTime = it
+                    blockerReason = CaptureReason.DeferBigAnimation
+                }
             }
         }
 
@@ -278,11 +316,11 @@ class CaptureHeuristics {
         val staleOnly = stale && hasLastFrame && !signatureChanged && !keyframeDue
         val suppressStaleRender = staleOnly && (hasVideoSurface || hasWebSurface || hasCameraSurface)
 
-        if (suppressStaleRender) {
+        if (suppressStaleRender && !isUrgent) {
             return CaptureDecision(CaptureAction.ReuseLast, CaptureReason.ReuseSignatureUnchanged)
         }
 
-        if (!hasLastFrame || signatureChanged || stale || keyframeDue) {
+        if (!hasLastFrame || signatureChanged || stale || keyframeDue || isUrgent) {
             return CaptureDecision(CaptureAction.RenderNow, CaptureReason.RenderNow)
         }
 
@@ -351,7 +389,7 @@ class CaptureHeuristics {
         private const val QUIET_BOUNCE_MS = 200L
         private const val QUIET_REFRESH_MS = 220L
         private const val QUIET_MAP_MS = 550L
-        private const val QUIET_TRANSITION_MS = 200L
+        private const val QUIET_TRANSITION_MS = 100L
         private const val QUIET_KEYBOARD_MS = 250L
         private const val QUIET_ANIMATION_MS = 250L
 

package/android/src/main/java/com/rejourney/core/Constants.kt

@@ -11,11 +11,11 @@ object Constants {
     // Video Capture Configuration (H.264 Segment Mode)
     // These match iOS RJCaptureEngine defaults for performance
     
-    /** Default capture scale factor (0.35 = 35% of original size) - matches iOS */
-    const val DEFAULT_CAPTURE_SCALE = 0.35f
+    /** Default capture scale factor (0.25 = 25% of original size) - matches iOS */
+    const val DEFAULT_CAPTURE_SCALE = 0.25f
 
-    /** Target video bitrate in bits per second (1.5 Mbps) - matches iOS */
-    const val DEFAULT_VIDEO_BITRATE = 1_500_000
+    /** Target video bitrate in bits per second (1.0 Mbps) - matches iOS */
+    const val DEFAULT_VIDEO_BITRATE = 1_000_000
 
     /** Maximum video dimension in pixels (longest edge) - matches iOS */
     const val MAX_VIDEO_DIMENSION = 1920

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

@@ -132,6 +132,13 @@ class RejourneyModule(reactContext: ReactApplicationContext) :
            instance.getSDKMetrics(promise)
     }
 
+    @ReactMethod
+    @DoNotStrip
+    override fun getDeviceInfo(promise: Promise) {
+           val instance = getImplOrReject(promise) ?: return
+           instance.getDeviceInfo(promise)
+    }
+
     @ReactMethod
     @DoNotStrip
     override fun debugCrash() {
@@ -171,6 +178,13 @@ class RejourneyModule(reactContext: ReactApplicationContext) :
             instance.setUserIdentity(userId, promise)
     }
 
+    @ReactMethod
+    @DoNotStrip
+    override fun getUserIdentity(promise: Promise) {
+           val instance = getImplOrReject(promise) ?: return
+           instance.getUserIdentity(promise)
+    }
+
     @ReactMethod
     @DoNotStrip
     override fun setDebugMode(enabled: Boolean, promise: Promise) {

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

@@ -128,6 +128,15 @@ class RejourneyModule(reactContext: ReactApplicationContext) :
         }
     }
 
+    @ReactMethod
+    fun getDeviceInfo(promise: Promise) {
+        try {
+            impl.getDeviceInfo(promise)
+        } catch (e: Exception) {
+            promise.resolve(Arguments.createMap())
+        }
+    }
+
     @ReactMethod
     fun debugCrash() {
         try {