@rejourneyco/react-native 1.0.0

package/ios/Capture/RJCrashHandler.h

@@ -0,0 +1,46 @@
+//
+//  RJCrashHandler.h
+//  Rejourney
+//
+//  Handles uncaught exceptions and signals to generate crash reports.
+//
+
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/**
+ * Block type for pre-crash callbacks.
+ * These are called synchronously before the crash report is written.
+ * Use sparingly - only for critical cleanup like flushing video segments.
+ */
+typedef void (^RJPreCrashCallback)(void);
+
+@interface RJCrashHandler : NSObject
+
++ (instancetype)sharedInstance;
+
+/// Starts monitoring for crashes
+- (void)startMonitoring;
+
+/// Checks if there is a pending crash report from a previous launch
+- (BOOL)hasPendingCrashReport;
+
+/// Loads the pending crash report and clears it from disk
+- (nullable NSDictionary *)loadAndPurgePendingCrashReport;
+
+/**
+ * Registers a callback to be invoked immediately when a crash is detected,
+ * before the crash report is written. This allows critical cleanup operations
+ * like flushing video segments.
+ * 
+ * @warning Callbacks must be extremely fast and async-signal-safe for signal handlers.
+ *          Exception handlers have more flexibility but should still be quick.
+ *
+ * @param callback The callback block to invoke on crash.
+ */
+- (void)registerPreCrashCallback:(RJPreCrashCallback)callback;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/Capture/RJCrashHandler.m

@@ -0,0 +1,313 @@
+//
+//  RJCrashHandler.m
+//  Rejourney
+//
+//  Industry-standard crash handling with proper signal handling and
+//  fingerprinting.
+//
+
+#import "RJCrashHandler.h"
+#import "../Core/RJLogger.h"
+#import <CommonCrypto/CommonDigest.h>
+#import <UIKit/UIKit.h>
+#include <execinfo.h>
+#include <signal.h>
+
+static NSUncaughtExceptionHandler *originalExceptionHandler = NULL;
+static NSString *const kRJCrashReportFileName = @"rj_crash_report.json";
+static NSString *const kRJCurrentSessionIdKey = @"rj_current_session_id";
+
+static struct sigaction originalSigActions[32];
+static volatile sig_atomic_t handlingSignal = 0;
+
+static RJPreCrashCallback rj_preCrashCallback = nil;
+
+static void rj_invokePreCrashCallback(void);
+
+@implementation RJCrashHandler
+
++ (instancetype)sharedInstance {
+  static RJCrashHandler *sharedInstance = nil;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    sharedInstance = [[self alloc] init];
+  });
+  return sharedInstance;
+}
+
+- (void)registerPreCrashCallback:(RJPreCrashCallback)callback {
+  rj_preCrashCallback = [callback copy];
+  RJLogDebug(@"Registered pre-crash callback for video segment recovery");
+}
+
+- (void)startMonitoring {
+  
+  originalExceptionHandler = NSGetUncaughtExceptionHandler();
+  NSSetUncaughtExceptionHandler(&rj_uncaughtExceptionHandler);
+
+  
+  
+  int signals[] = {SIGABRT, SIGILL, SIGSEGV, SIGFPE, SIGBUS, SIGPIPE, SIGTRAP};
+  int numSignals = sizeof(signals) / sizeof(signals[0]);
+
+  for (int i = 0; i < numSignals; i++) {
+    struct sigaction action;
+    memset(&action, 0, sizeof(action));
+    action.sa_sigaction = rj_signalActionHandler;
+    action.sa_flags = SA_SIGINFO | SA_ONSTACK;
+    sigemptyset(&action.sa_mask);
+
+    
+    sigaction(signals[i], &action, &originalSigActions[signals[i]]);
+  }
+
+  RJLogDebug(@"RJCrashHandler started monitoring (using sigaction)");
+}
+
+static void rj_invokePreCrashCallback(void) {
+  if (rj_preCrashCallback) {
+    @try {
+      rj_preCrashCallback();
+    } @catch (NSException *e) {
+      
+    }
+  }
+}
+
+- (BOOL)hasPendingCrashReport {
+  NSString *path = [self crashReportPath];
+  return [[NSFileManager defaultManager] fileExistsAtPath:path];
+}
+
+- (NSDictionary *)loadAndPurgePendingCrashReport {
+  NSString *path = [self crashReportPath];
+  if (![[NSFileManager defaultManager] fileExistsAtPath:path]) {
+    return nil;
+  }
+
+  NSData *data = [NSData dataWithContentsOfFile:path];
+  if (!data)
+    return nil;
+
+  NSDictionary *report = [NSJSONSerialization JSONObjectWithData:data
+                                                         options:0
+                                                           error:nil];
+
+  
+  [[NSFileManager defaultManager] removeItemAtPath:path error:nil];
+
+  return report;
+}
+
+#pragma mark - Private Methods
+
+- (NSString *)crashReportPath {
+  NSArray *paths = NSSearchPathForDirectoriesInDomains(NSCachesDirectory,
+                                                       NSUserDomainMask, YES);
+  NSString *cacheDir = [paths objectAtIndex:0];
+  return [cacheDir stringByAppendingPathComponent:kRJCrashReportFileName];
+}
+
+#pragma mark - Fingerprinting
+
++ (NSString *)generateFingerprintForException:(NSString *)exceptionName
+                                   stackTrace:(NSArray *)stackTrace {
+  NSMutableString *input =
+      [NSMutableString stringWithString:exceptionName ?: @""];
+
+  
+  NSInteger frameCount = MIN(5, stackTrace.count);
+  for (NSInteger i = 0; i < frameCount; i++) {
+    NSString *frame = stackTrace[i];
+    
+    NSString *cleaned = [frame
+        stringByReplacingOccurrencesOfString:@"0x[0-9a-fA-F]+"
+                                  withString:@""
+                                     options:NSRegularExpressionSearch
+                                       range:NSMakeRange(0, frame.length)];
+    [input appendString:cleaned];
+  }
+
+  
+  const char *cStr = [input UTF8String];
+  unsigned char digest[CC_SHA256_DIGEST_LENGTH];
+  CC_SHA256(cStr, (CC_LONG)strlen(cStr), digest);
+
+  NSMutableString *fingerprint =
+      [NSMutableString stringWithCapacity:CC_SHA256_DIGEST_LENGTH * 2];
+  for (int i = 0; i < 8; i++) { 
+    [fingerprint appendFormat:@"%02x", digest[i]];
+  }
+
+  return fingerprint;
+}
+
+#pragma mark - Handlers
+
+void rj_uncaughtExceptionHandler(NSException *exception) {
+  RJLogDebug(@"[CRASH] EXCEPTION DETECTED: %@ - %@", exception.name,
+             exception.reason);
+
+  
+  
+  rj_invokePreCrashCallback();
+
+  NSString *sessionId = [[NSUserDefaults standardUserDefaults]
+      stringForKey:kRJCurrentSessionIdKey];
+
+  NSMutableDictionary *report = [NSMutableDictionary new];
+  report[@"timestamp"] = @([[NSDate date] timeIntervalSince1970] * 1000);
+  report[@"exceptionName"] = exception.name;
+  report[@"reason"] = exception.reason ?: @"";
+
+  
+  
+  NSArray *stackSymbols = exception.callStackSymbols;
+  if (!stackSymbols || stackSymbols.count == 0) {
+    
+    void *callstack[128];
+    int frames = backtrace(callstack, 128);
+    char **strs = backtrace_symbols(callstack, frames);
+    NSMutableArray *stack = [NSMutableArray arrayWithCapacity:frames];
+    for (int i = 0; i < frames; i++) {
+      [stack addObject:[NSString stringWithUTF8String:strs[i]]];
+    }
+    free(strs);
+    stackSymbols = stack;
+    RJLogDebug(@"[CRASH] Used backtrace() fallback for stack trace (%d frames)",
+               frames);
+  } else {
+    RJLogDebug(@"[CRASH] Using exception.callStackSymbols (%lu frames)",
+               (unsigned long)stackSymbols.count);
+  }
+
+  report[@"stackTrace"] = stackSymbols ?: @[];
+
+  if (sessionId) {
+    report[@"sessionId"] = sessionId;
+  }
+
+  
+  report[@"fingerprint"] =
+      [RJCrashHandler generateFingerprintForException:exception.name
+                                           stackTrace:stackSymbols ?: @[]];
+
+  UIDevice *device = [UIDevice currentDevice];
+  report[@"deviceMetadata"] = @{
+    @"model" : device.model,
+    @"systemName" : device.systemName,
+    @"systemVersion" : device.systemVersion,
+    @"identifierForVendor" : device.identifierForVendor.UUIDString ?: @"unknown"
+  };
+
+  NSData *jsonData =
+      [NSJSONSerialization dataWithJSONObject:report
+                                      options:NSJSONWritingPrettyPrinted
+                                        error:nil];
+
+  NSString *path = [[RJCrashHandler sharedInstance] crashReportPath];
+  [jsonData writeToFile:path atomically:YES];
+
+  RJLogDebug(@"[CRASH] Crash report saved to %@", path);
+
+  if (originalExceptionHandler) {
+    originalExceptionHandler(exception);
+  }
+}
+
+void rj_signalActionHandler(int signal, siginfo_t *info, void *context) {
+  
+  if (handlingSignal) {
+    return;
+  }
+  handlingSignal = 1;
+
+  RJLogDebug(@"[CRASH] SIGNAL DETECTED: %d at address %p", signal,
+             info->si_addr);
+
+  
+  
+  
+  
+  
+  rj_invokePreCrashCallback();
+
+  NSString *sessionId = [[NSUserDefaults standardUserDefaults]
+      stringForKey:kRJCurrentSessionIdKey];
+
+  NSMutableDictionary *report = [NSMutableDictionary new];
+  report[@"timestamp"] = @([[NSDate date] timeIntervalSince1970] * 1000);
+
+  
+  NSString *signalName;
+  switch (signal) {
+  case SIGABRT:
+    signalName = @"SIGABRT (Abort)";
+    break;
+  case SIGSEGV:
+    signalName = @"SIGSEGV (Segmentation Fault)";
+    break;
+  case SIGBUS:
+    signalName = @"SIGBUS (Bus Error)";
+    break;
+  case SIGFPE:
+    signalName = @"SIGFPE (Floating Point Exception)";
+    break;
+  case SIGILL:
+    signalName = @"SIGILL (Illegal Instruction)";
+    break;
+  case SIGPIPE:
+    signalName = @"SIGPIPE (Broken Pipe)";
+    break;
+  case SIGTRAP:
+    signalName = @"SIGTRAP (Trace Trap)";
+    break;
+  default:
+    signalName = [NSString stringWithFormat:@"Signal %d", signal];
+    break;
+  }
+
+  report[@"exceptionName"] = signalName;
+  report[@"reason"] = [NSString
+      stringWithFormat:@"%@ at address %p", signalName, info->si_addr];
+  if (sessionId) {
+    report[@"sessionId"] = sessionId;
+  }
+
+  
+  void *callstack[128];
+  int frames = backtrace(callstack, 128);
+  char **strs = backtrace_symbols(callstack, frames);
+  NSMutableArray *stack = [NSMutableArray arrayWithCapacity:frames];
+  for (int i = 0; i < frames; i++) {
+    [stack addObject:[NSString stringWithUTF8String:strs[i]]];
+  }
+  free(strs);
+  report[@"stackTrace"] = stack;
+
+  
+  report[@"fingerprint"] =
+      [RJCrashHandler generateFingerprintForException:signalName
+                                           stackTrace:stack];
+
+  UIDevice *device = [UIDevice currentDevice];
+  report[@"deviceMetadata"] = @{
+    @"model" : device.model,
+    @"systemName" : device.systemName,
+    @"systemVersion" : device.systemVersion
+  };
+
+  NSData *jsonData =
+      [NSJSONSerialization dataWithJSONObject:report
+                                      options:NSJSONWritingPrettyPrinted
+                                        error:nil];
+  NSString *path = [[RJCrashHandler sharedInstance] crashReportPath];
+  [jsonData writeToFile:path atomically:YES];
+
+  
+  struct sigaction *original = &originalSigActions[signal];
+  sigaction(signal, original, NULL);
+  raise(signal);
+}
+
+@end

package/ios/Capture/RJMotionEvent.h

@@ -0,0 +1,183 @@
+//
+//  RJMotionEvent.h
+//  Rejourney
+//
+//  Motion event data structure for gesture replay reconstruction.
+//  Motion events capture scroll/pan/swipe dynamics for timeline events.
+//
+//  Licensed under the Apache License, Version 2.0 (the "License");
+//  you may not use this file except in compliance with the License.
+//  You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//  Unless required by applicable law or agreed to in writing, software
+//  distributed under the License is distributed on an "AS IS" BASIS,
+//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//  See the License for the specific language governing permissions and
+//  limitations under the License.
+//
+//  Copyright (c) 2026 Rejourney
+//
+
+#import <CoreGraphics/CoreGraphics.h>
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/**
+ * Motion curve types for animation reconstruction.
+ */
+typedef NS_ENUM(NSInteger, RJMotionCurve) {
+  /// Linear motion (constant velocity)
+  RJMotionCurveLinear = 0,
+
+  /// Exponential decay (iOS scroll deceleration)
+  RJMotionCurveExponentialDecay = 1,
+
+  /// Ease out (quick start, slow end)
+  RJMotionCurveEaseOut = 2,
+
+  /// Bounce (overshoots then settles)
+  RJMotionCurveBounce = 3,
+
+  /// Spring (elastic oscillation)
+  RJMotionCurveSpring = 4
+};
+
+/**
+ * Motion event types.
+ */
+typedef NS_ENUM(NSInteger, RJMotionType) {
+  /// Scroll gesture motion
+  RJMotionTypeScroll = 0,
+
+  /// Pan gesture motion
+  RJMotionTypePan = 1,
+
+  /// Swipe gesture motion
+  RJMotionTypeSwipe = 2,
+
+  /// Fling (momentum) motion
+  RJMotionTypeFling = 3
+};
+
+/**
+ * Represents a motion event for replay reconstruction.
+ *
+ * Motion events capture the dynamics of scroll/pan/swipe gestures
+ * so that the player can reconstruct smooth motion between sparse keyframes.
+ *
+ * ## Usage
+ * @code
+ * RJMotionEvent *event = [[RJMotionEvent alloc] init];
+ * event.type = RJMotionTypeScroll;
+ * event.t0 = 1234.0;  // start time in ms
+ * event.t1 = 1560.0;  // end time in ms
+ * event.dx = 0;       // horizontal displacement
+ * event.dy = -820;    // vertical displacement
+ * event.v0 = 2.1;     // initial velocity
+ * event.curve = RJMotionCurveExponentialDecay;
+ *
+ * NSDictionary *dict = [event toDictionary];
+ * @endcode
+ */
+@interface RJMotionEvent : NSObject
+
+#pragma mark - Motion Properties
+
+/// Type of motion (scroll, pan, swipe, fling)
+@property(nonatomic, assign) RJMotionType type;
+
+/// Start timestamp in milliseconds
+@property(nonatomic, assign) NSTimeInterval t0;
+
+/// End timestamp in milliseconds
+@property(nonatomic, assign) NSTimeInterval t1;
+
+/// Horizontal displacement in points
+@property(nonatomic, assign) CGFloat dx;
+
+/// Vertical displacement in points
+@property(nonatomic, assign) CGFloat dy;
+
+/// Initial velocity in points per second
+@property(nonatomic, assign) CGFloat v0;
+
+/// Final velocity in points per second (usually 0 for deceleration)
+@property(nonatomic, assign) CGFloat v1;
+
+/// Motion curve for interpolation
+@property(nonatomic, assign) RJMotionCurve curve;
+
+/// Target view identifier (optional)
+@property(nonatomic, copy, nullable) NSString *targetId;
+
+#pragma mark - Computed Properties
+
+/// Duration in milliseconds
+@property(nonatomic, readonly) NSTimeInterval duration;
+
+/// Total distance traveled
+@property(nonatomic, readonly) CGFloat distance;
+
+/// Average velocity
+@property(nonatomic, readonly) CGFloat averageVelocity;
+
+/// Direction angle in radians
+@property(nonatomic, readonly) CGFloat direction;
+
+#pragma mark - Serialization
+
+/**
+ * Converts the motion event to a dictionary for JSON serialization.
+ *
+ * @return Dictionary with all motion event properties.
+ */
+- (NSDictionary *)toDictionary;
+
+/**
+ * Creates a motion event from a dictionary.
+ *
+ * @param dict Dictionary with motion event properties.
+ * @return Motion event or nil if dictionary is invalid.
+ */
++ (nullable instancetype)eventFromDictionary:(NSDictionary *)dict;
+
+#pragma mark - Curve Helpers
+
+/**
+ * Returns the string name for a motion curve.
+ */
++ (NSString *)curveNameForType:(RJMotionCurve)curve;
+
+/**
+ * Parses a curve name string to enum value.
+ */
++ (RJMotionCurve)curveTypeFromName:(NSString *)name;
+
+/**
+ * Returns the string name for a motion type.
+ */
++ (NSString *)motionTypeName:(RJMotionType)type;
+
+/**
+ * Parses a motion type name string to enum value.
+ */
++ (RJMotionType)motionTypeFromName:(NSString *)name;
+
+#pragma mark - Instance Convenience Methods
+
+/**
+ * Returns the string name for this event's motion type.
+ */
+- (NSString *)typeName;
+
+/**
+ * Returns the string name for this event's curve type.
+ */
+- (NSString *)curveName;
+
+@end
+
+NS_ASSUME_NONNULL_END