@rejourneyco/react-native 1.0.0 → 1.0.1

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

@@ -1005,7 +1005,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 +1037,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

@@ -171,6 +171,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/ios/Capture/RJCaptureEngine.m

@@ -61,6 +61,7 @@ typedef struct {
 @property(nonatomic, assign) NSInteger generation;
 @property(nonatomic, strong, nullable) RJViewHierarchyScanResult *scanResult;
 @property(nonatomic, copy, nullable) NSString *layoutSignature;
+@property(nonatomic, assign) RJCaptureImportance importance;
 
 @end
 
@@ -168,6 +169,8 @@ typedef struct {
 @property(nonatomic, assign) CFRunLoopObserverRef runLoopObserver;
 @property(nonatomic, assign) BOOL runLoopCapturePending;
 
+@property(nonatomic, assign) BOOL isWarmingUp;
+
 @end
 
 #pragma mark - Implementation
@@ -300,6 +303,7 @@ typedef struct {
     _isShuttingDown = NO;
     _uiReadyForCapture = NO;
     _framesSinceHierarchy = 0;
+    _isWarmingUp = NO;
 
     [self applyDefaultConfiguration];
 
@@ -494,7 +498,38 @@ typedef struct {
 
 - (void)appDidBecomeActive:(NSNotification *)notification {
   self.isInBackground = NO;
-  RJLogDebug(@"CaptureEngine: App became active - warmup before capture");
+
+  // DEFENSIVE FIX: Warmup period
+  // When returning from background, the view hierarchy and layout may not be
+  // stable immediately. This can cause privacy masks to be drawn in the wrong
+  // position relative to the content (race condition). We impose a short
+  // "warmup" period where we skip capture to allow AutoLayout to settle.
+  self.isWarmingUp = YES;
+
+  // Clear stale caches to force fresh scan
+  if (self.lastCapturedPixelBuffer) {
+    CVPixelBufferRelease(self.lastCapturedPixelBuffer);
+    self.lastCapturedPixelBuffer = NULL;
+  }
+  self.lastMaskScanResult = nil;
+  self.lastSafeMaskScanResult = nil;
+
+  RJLogDebug(@"CaptureEngine: App became active - starting warmup (0.2s)");
+
+  __weak typeof(self) weakSelf = self;
+  dispatch_after(
+      dispatch_time(DISPATCH_TIME_NOW, (int64_t)(0.2 * NSEC_PER_SEC)),
+      dispatch_get_main_queue(), ^{
+        __strong typeof(weakSelf) strongSelf = weakSelf;
+        if (!strongSelf)
+          return;
+
+        strongSelf.isWarmingUp = NO;
+        RJLogDebug(@"CaptureEngine: Warmup complete - resuming capture");
+
+        // Trigger an immediate capture check
+        [strongSelf captureVideoFrame];
+      });
 }
 
 #pragma mark - System Monitoring
@@ -1087,14 +1122,31 @@ typedef struct {
 }
 
 - (void)captureVideoFrame {
+  [self captureVideoFrameWithImportance:RJCaptureImportanceLow reason:@"timer"];
+}
+
+- (void)captureVideoFrameWithImportance:(RJCaptureImportance)importance
+                                 reason:(NSString *)reason {
   if (!self.internalIsRecording || self.isShuttingDown)
     return;
+
+  if (self.isWarmingUp) {
+    return;
+  }
+
+  // Critical events (like navigation) should bypass UI ready checks if
+  // possible, but we still need a valid UI.
   if (!self.uiReadyForCapture) {
     if (self.framesSinceSessionStart % 60 == 0)
       RJLogDebug(@"Skipping capture: UI not ready");
     return;
   }
-  if (self.internalPerformanceLevel == RJPerformanceLevelPaused) {
+
+  // Critical events override paused state
+  BOOL isCritical = (importance == RJCaptureImportanceCritical ||
+                     importance == RJCaptureImportanceHigh);
+  if (self.internalPerformanceLevel == RJPerformanceLevelPaused &&
+      !isCritical) {
     static NSInteger pauseSkipCount = 0;
     if (++pauseSkipCount % 60 == 0)
       RJLogDebug(@"Skipping capture: Performance Paused");
@@ -1103,18 +1155,30 @@ typedef struct {
   NSTimeInterval now = CACurrentMediaTime();
 
   if (self.pendingCapture) {
+    // If we have a pending capture, force it to resolve now.
+    // If the new request is High importance, we effectively "upgrade" the
+    // current cycle by ensuring it runs immediately.
     self.pendingCapture.deadline = now;
     [self attemptPendingCapture:self.pendingCapture fullScan:NO];
   }
 
   RJCapturePendingCapture *pending = [[RJCapturePendingCapture alloc] init];
   pending.wantedAt = now;
+  pending.importance = importance;
+
   NSTimeInterval grace = self.captureHeuristics.captureGraceSeconds;
   if (self.captureHeuristics.animationBlocking ||
       self.captureHeuristics.scrollActive ||
       self.captureHeuristics.keyboardAnimating) {
     grace = MIN(grace, 0.3);
   }
+
+  // High importance requests should have a shorter grace, forcing faster
+  // resolution
+  if (isCritical) {
+    grace = MIN(grace, 0.1);
+  }
+
   pending.deadline = now + grace;
   pending.timestamp = [self currentTimestamp];
   pending.generation = ++self.pendingCaptureGeneration;
@@ -1207,7 +1271,8 @@ typedef struct {
   RJCaptureHeuristicsDecision *decision = [self.captureHeuristics
       decisionForSignature:pending.layoutSignature
                        now:now
-              hasLastFrame:(self.lastCapturedPixelBuffer != NULL)];
+              hasLastFrame:(self.lastCapturedPixelBuffer != NULL)
+                importance:pending.importance];
 
   if (decision.action == RJCaptureHeuristicsActionRenderNow && !fullScan) {
     RJ_TIME_START_NAMED(viewScan);
@@ -1241,7 +1306,8 @@ typedef struct {
     decision = [self.captureHeuristics
         decisionForSignature:pending.layoutSignature
                          now:now
-                hasLastFrame:(self.lastCapturedPixelBuffer != NULL)];
+                hasLastFrame:(self.lastCapturedPixelBuffer != NULL)
+                  importance:pending.importance];
   }
 
   if (decision.action == RJCaptureHeuristicsActionDefer && fullScan) {
@@ -1342,7 +1408,10 @@ typedef struct {
                    }
                    self.pendingDefensiveCaptureTime = 0;
                    self.lastIntentTime = CACurrentMediaTime();
-                   [self captureVideoFrame];
+                   // Defensive capture triggered by heuristics (e.g.
+                   // navigation) is High importance
+                   [self captureVideoFrameWithImportance:RJCaptureImportanceHigh
+                                                  reason:reason];
                  });
 }
 

package/ios/Capture/RJCaptureHeuristics.h

@@ -10,6 +10,7 @@
 #import <Foundation/Foundation.h>
 #import <UIKit/UIKit.h>
 
+#import "../Core/RJTypes.h"
 #import "RJViewHierarchyScanner.h"
 
 NS_ASSUME_NONNULL_BEGIN
@@ -59,7 +60,7 @@ typedef NS_ENUM(NSInteger, RJCaptureHeuristicsReason) {
 - (void)recordMapInteractionAtTime:(NSTimeInterval)time;
 - (void)recordNavigationEventAtTime:(NSTimeInterval)time;
 - (void)recordRenderedSignature:(nullable NSString *)signature
-                          atTime:(NSTimeInterval)time;
+                         atTime:(NSTimeInterval)time;
 
 - (void)updateWithScanResult:(RJViewHierarchyScanResult *)scanResult
                       window:(UIWindow *)window
@@ -68,10 +69,11 @@ typedef NS_ENUM(NSInteger, RJCaptureHeuristicsReason) {
 - (void)updateWithStabilityProbeForWindow:(UIWindow *)window
                                       now:(NSTimeInterval)now;
 
-- (RJCaptureHeuristicsDecision *)decisionForSignature:
-                                    (nullable NSString *)signature
-                                                 now:(NSTimeInterval)now
-                                         hasLastFrame:(BOOL)hasLastFrame;
+- (RJCaptureHeuristicsDecision *)
+    decisionForSignature:(nullable NSString *)signature
+                     now:(NSTimeInterval)now
+            hasLastFrame:(BOOL)hasLastFrame
+              importance:(RJCaptureImportance)importance;
 
 + (NSString *)stringForReason:(RJCaptureHeuristicsReason)reason;