@rejourneyco/react-native 1.0.0

package/ios/Rejourney.h

@@ -0,0 +1,63 @@
+//  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
+
+//
+//
+//  Rejourney.h
+//  Rejourney
+//
+//  Umbrella header for the Rejourney SDK.
+//  Import this header to access the complete SDK.
+//
+//  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
+//
+
+#ifndef Rejourney_h
+#define Rejourney_h
+
+// Core
+#import "Core/RJConstants.h"
+#import "Core/RJLogger.h"
+#import "Core/RJTypes.h"
+#import "Core/Rejourney.h"
+
+// Capture
+#import "Capture/RJCaptureEngine.h"
+#import "Capture/RJSegmentUploader.h"
+#import "Capture/RJVideoEncoder.h"
+#import "Capture/RJViewSerializer.h"
+
+// Touch
+#import "Touch/RJGestureClassifier.h"
+#import "Touch/RJTouchInterceptor.h"
+
+// Network
+#import "Network/RJUploadManager.h"
+
+// Utils
+#import "Utils/RJWindowUtils.h"
+
+#endif /* Rejourney_h */

package/ios/Touch/RJGestureClassifier.h

@@ -0,0 +1,130 @@
+//
+//  RJGestureClassifier.h
+//  Rejourney
+//
+//  Gesture classification from touch data.
+//
+//  The classifier analyzes touch paths to determine gesture types
+//  including taps, swipes, pinches, rotations, and multi-finger gestures.
+//
+//  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 <Foundation/Foundation.h>
+#import <UIKit/UIKit.h>
+#import "../Core/RJTypes.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+/**
+ * Represents a single touch point in a gesture path.
+ */
+@interface RJTouchPoint : NSObject
+
+/// X coordinate in window space
+@property (nonatomic, assign) CGFloat x;
+
+/// Y coordinate in window space
+@property (nonatomic, assign) CGFloat y;
+
+/// Timestamp in milliseconds
+@property (nonatomic, assign) NSTimeInterval timestamp;
+
+/// Touch force (0.0-1.0, where available)
+@property (nonatomic, assign) CGFloat force;
+
+/// Creates a touch point from coordinates
++ (instancetype)pointWithX:(CGFloat)x y:(CGFloat)y timestamp:(NSTimeInterval)timestamp force:(CGFloat)force;
+
+/// Converts to dictionary for logging
+- (NSDictionary *)toDictionary;
+
+@end
+
+/**
+ * Classifies gestures from touch data.
+ *
+ * The classifier supports:
+ * - Single-finger: tap, double-tap, long-press, force-touch, swipe, scroll
+ * - Two-finger: pinch, rotation, pan, two-finger-tap
+ * - Multi-finger: three-finger gesture, multi-touch
+ *
+ * ## Usage
+ * ```objc
+ * RJGestureClassifier *classifier = [[RJGestureClassifier alloc] init];
+ *
+ * // Single-finger gesture
+ * NSString *gesture = [classifier classifySingleTouchPath:touches duration:500];
+ *
+ * // Multi-finger gesture
+ * NSString *gesture = [classifier classifyMultiTouchPaths:touchPaths
+ *                                                duration:300
+ *                                              touchCount:2];
+ * ```
+ */
+@interface RJGestureClassifier : NSObject
+
+#pragma mark - Double-Tap Detection State
+
+/// Time of last tap for double-tap detection
+@property (nonatomic, assign) NSTimeInterval lastTapTime;
+
+/// Location of last tap for double-tap detection
+@property (nonatomic, assign) CGPoint lastTapPoint;
+
+/// Current tap count for multi-tap detection
+@property (nonatomic, assign) NSInteger tapCount;
+
+/// Maximum force recorded during current gesture
+@property (nonatomic, assign) CGFloat maxForce;
+
+/// Initial pinch distance for pinch detection
+@property (nonatomic, assign) CGFloat initialPinchDistance;
+
+/// Initial rotation angle for rotation detection
+@property (nonatomic, assign) CGFloat initialRotationAngle;
+
+#pragma mark - Classification
+
+/**
+ * Classifies a single-finger gesture from its touch path.
+ *
+ * @param touches Array of touch point dictionaries or RJTouchPoint objects.
+ * @param duration Gesture duration in milliseconds.
+ * @return Gesture type string (see RJGestureType constants).
+ */
+- (RJGestureType)classifySingleTouchPath:(NSArray *)touches
+                                duration:(NSTimeInterval)duration;
+
+/**
+ * Classifies a multi-finger gesture from touch paths.
+ *
+ * @param touchPaths Dictionary mapping touch IDs to arrays of touch points.
+ * @param duration Gesture duration in milliseconds.
+ * @param touchCount Number of fingers involved.
+ * @return Gesture type string (see RJGestureType constants).
+ */
+- (RJGestureType)classifyMultiTouchPaths:(NSDictionary<NSNumber *, NSArray *> *)touchPaths
+                                duration:(NSTimeInterval)duration
+                              touchCount:(NSInteger)touchCount;
+
+/**
+ * Resets the classifier state for a new gesture.
+ */
+- (void)resetState;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/Touch/RJGestureClassifier.m

@@ -0,0 +1,333 @@
+//
+//  RJGestureClassifier.m
+//  Rejourney
+//
+//  Gesture classification implementation.
+//
+//  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 "RJGestureClassifier.h"
+#import "../Core/RJConstants.h"
+
+#pragma mark - RJTouchPoint Implementation
+
+@implementation RJTouchPoint
+
++ (instancetype)pointWithX:(CGFloat)x y:(CGFloat)y timestamp:(NSTimeInterval)timestamp force:(CGFloat)force {
+    RJTouchPoint *point = [[RJTouchPoint alloc] init];
+    point.x = x;
+    point.y = y;
+    point.timestamp = timestamp;
+    point.force = force;
+    return point;
+}
+
+- (NSDictionary *)toDictionary {
+    return @{
+        @"x": @(self.x),
+        @"y": @(self.y),
+        @"timestamp": @(self.timestamp),
+        @"force": @(self.force)
+    };
+}
+
+@end
+
+#pragma mark - RJGestureClassifier Implementation
+
+@implementation RJGestureClassifier
+
+#pragma mark - Initialization
+
+- (instancetype)init {
+    self = [super init];
+    if (self) {
+        [self resetState];
+    }
+    return self;
+}
+
+- (void)resetState {
+    _lastTapTime = 0;
+    _lastTapPoint = CGPointZero;
+    _tapCount = 0;
+    _maxForce = 0;
+    _initialPinchDistance = 0;
+    _initialRotationAngle = 0;
+}
+
+#pragma mark - Single Touch Classification
+
+- (RJGestureType)classifySingleTouchPath:(NSArray *)touches
+                                duration:(NSTimeInterval)duration {
+    if (touches.count < 2) {
+        return [self classifyStationaryGesture:duration];
+    }
+    
+    
+    NSDictionary *first = [self extractPointDict:touches.firstObject];
+    NSDictionary *last = [self extractPointDict:touches.lastObject];
+    
+    if (!first || !last) {
+        return RJGestureTypeTap;
+    }
+    
+    
+    CGFloat dx = [last[@"x"] floatValue] - [first[@"x"] floatValue];
+    CGFloat dy = [last[@"y"] floatValue] - [first[@"y"] floatValue];
+    CGFloat distance = sqrt(dx * dx + dy * dy);
+    
+    
+    if (distance < 10) {
+        return [self classifyStationaryGesture:duration];
+    }
+    
+    
+    return [self classifyMovementGesture:dx dy:dy distance:distance];
+}
+
+- (NSDictionary *)extractPointDict:(id)point {
+    if ([point isKindOfClass:[NSDictionary class]]) {
+        return point;
+    } else if ([point isKindOfClass:[RJTouchPoint class]]) {
+        return [(RJTouchPoint *)point toDictionary];
+    }
+    return nil;
+}
+
+- (RJGestureType)classifyStationaryGesture:(NSTimeInterval)duration {
+    
+    if (self.maxForce > RJForceTouchThreshold) {
+        return RJGestureTypeForceTouch;
+    }
+    
+    
+    NSTimeInterval currentTime = [[NSDate date] timeIntervalSince1970] * 1000;
+    if ([self checkDoubleTap:currentTime]) {
+        return RJGestureTypeDoubleTap;
+    }
+    
+    
+    return duration > RJLongPressMinDuration ? RJGestureTypeLongPress : RJGestureTypeTap;
+}
+
+- (BOOL)checkDoubleTap:(NSTimeInterval)currentTime {
+    if (self.lastTapTime <= 0) {
+        
+        self.tapCount = 1;
+        self.lastTapTime = currentTime;
+        return NO;
+    }
+    
+    
+    if (currentTime - self.lastTapTime >= RJDoubleTapMaxInterval) {
+        
+        self.tapCount = 1;
+        self.lastTapTime = currentTime;
+        return NO;
+    }
+    
+    
+    self.tapCount++;
+    self.lastTapTime = currentTime;
+    
+    if (self.tapCount >= 2) {
+        self.tapCount = 0;
+        self.lastTapTime = 0;
+        return YES;
+    }
+    
+    return NO;
+}
+
+- (RJGestureType)classifyMovementGesture:(CGFloat)dx
+                                      dy:(CGFloat)dy
+                                distance:(CGFloat)distance {
+    
+    if (fabs(dy) > fabs(dx) && fabs(dy) > RJSwipeMinDistance) {
+        return dy > 0 ? RJGestureTypeScrollDown : RJGestureTypeScrollUp;
+    }
+    
+    
+    if (fabs(dx) > fabs(dy)) {
+        return dx > 0 ? RJGestureTypeSwipeRight : RJGestureTypeSwipeLeft;
+    }
+    
+    
+    return dy > 0 ? RJGestureTypeSwipeDown : RJGestureTypeSwipeUp;
+}
+
+#pragma mark - Multi-Touch Classification
+
+- (RJGestureType)classifyMultiTouchPaths:(NSDictionary<NSNumber *, NSArray *> *)touchPaths
+                                duration:(NSTimeInterval)duration
+                              touchCount:(NSInteger)touchCount {
+    
+    if (!touchPaths || touchCount <= 0) {
+        return RJGestureTypeTap;
+    }
+    
+    @try {
+        
+        if (touchCount == 1) {
+            NSArray *path = [[touchPaths allValues] firstObject];
+            return [self classifySingleTouchPath:path duration:duration];
+        }
+        
+        
+        if (touchCount == 2) {
+            return [self classifyTwoFingerGesture:touchPaths];
+        }
+        
+        
+        if (touchCount == 3) {
+            return RJGestureTypeThreeFingerGesture;
+        }
+        
+        
+        return RJGestureTypeMultiTouch;
+    } @catch (NSException *exception) {
+        
+        return RJGestureTypeTap;
+    }
+}
+
+- (RJGestureType)classifyTwoFingerGesture:(NSDictionary<NSNumber *, NSArray *> *)touchPaths {
+    @try {
+        NSArray *touchIds = [touchPaths allKeys];
+        if (touchIds.count < 2) {
+            return RJGestureTypeTap;
+        }
+        
+        NSArray *path1 = touchPaths[touchIds[0]];
+        NSArray *path2 = touchPaths[touchIds[1]];
+        
+        
+        if (!path1 || !path2 || path1.count < 2 || path2.count < 2) {
+            return RJGestureTypeTwoFingerTap;
+        }
+        
+        
+        NSDictionary *start1 = [self extractPointDict:path1.firstObject];
+        NSDictionary *start2 = [self extractPointDict:path2.firstObject];
+        NSDictionary *end1 = [self extractPointDict:path1.lastObject];
+        NSDictionary *end2 = [self extractPointDict:path2.lastObject];
+        
+        if (!start1 || !start2 || !end1 || !end2) {
+            return RJGestureTypeTwoFingerTap;
+        }
+        
+        
+        CGFloat startDx = [start1[@"x"] floatValue] - [start2[@"x"] floatValue];
+        CGFloat startDy = [start1[@"y"] floatValue] - [start2[@"y"] floatValue];
+        
+        
+        if (isnan(startDx) || isnan(startDy) || isinf(startDx) || isinf(startDy)) {
+            return RJGestureTypeMultiTouch;
+        }
+        
+        CGFloat startDistance = sqrt(startDx * startDx + startDy * startDy);
+        
+        
+        if (startDistance < 1.0) {
+            return RJGestureTypeMultiTouch;
+        }
+        
+        CGFloat endDx = [end1[@"x"] floatValue] - [end2[@"x"] floatValue];
+        CGFloat endDy = [end1[@"y"] floatValue] - [end2[@"y"] floatValue];
+        CGFloat endDistance = sqrt(endDx * endDx + endDy * endDy);
+        
+        
+        RJGestureType pinchGesture = [self checkPinchGesture:startDistance endDistance:endDistance];
+        if (pinchGesture) {
+            return pinchGesture;
+        }
+        
+        
+        RJGestureType rotationGesture = [self checkRotationGesture:startDx startDy:startDy
+                                                             endDx:endDx endDy:endDy];
+        if (rotationGesture) {
+            return rotationGesture;
+        }
+        
+        
+        RJGestureType panGesture = [self checkPanGesture:start1 start2:start2 end1:end1 end2:end2];
+        if (panGesture) {
+            return panGesture;
+        }
+        
+        return RJGestureTypeTwoFingerTap;
+    } @catch (NSException *exception) {
+        return RJGestureTypeTwoFingerTap;
+    }
+}
+
+- (RJGestureType)checkPinchGesture:(CGFloat)startDistance endDistance:(CGFloat)endDistance {
+    CGFloat distanceChange = endDistance - startDistance;
+    CGFloat distanceChangePercent = fabs(distanceChange) / startDistance;
+    
+    
+    if (distanceChangePercent > RJPinchMinChangePercent && fabs(distanceChange) > RJPinchMinDistance) {
+        return distanceChange > 0 ? RJGestureTypePinchOut : RJGestureTypePinchIn;
+    }
+    
+    return nil;
+}
+
+- (RJGestureType)checkRotationGesture:(CGFloat)startDx startDy:(CGFloat)startDy
+                                endDx:(CGFloat)endDx endDy:(CGFloat)endDy {
+    CGFloat startAngle = atan2(startDy, startDx);
+    CGFloat endAngle = atan2(endDy, endDx);
+    CGFloat angleDiff = endAngle - startAngle;
+    
+    
+    while (angleDiff > M_PI) angleDiff -= 2 * M_PI;
+    while (angleDiff < -M_PI) angleDiff += 2 * M_PI;
+    
+    CGFloat rotationDegrees = angleDiff * (180.0 / M_PI);
+    
+    if (fabs(rotationDegrees) > RJRotationMinAngle) {
+        return rotationDegrees > 0 ? RJGestureTypeRotateCCW : RJGestureTypeRotateCW;
+    }
+    
+    return nil;
+}
+
+- (RJGestureType)checkPanGesture:(NSDictionary *)start1 start2:(NSDictionary *)start2
+                            end1:(NSDictionary *)end1 end2:(NSDictionary *)end2 {
+    
+    CGFloat centerStartX = ([start1[@"x"] floatValue] + [start2[@"x"] floatValue]) / 2.0;
+    CGFloat centerStartY = ([start1[@"y"] floatValue] + [start2[@"y"] floatValue]) / 2.0;
+    CGFloat centerEndX = ([end1[@"x"] floatValue] + [end2[@"x"] floatValue]) / 2.0;
+    CGFloat centerEndY = ([end1[@"y"] floatValue] + [end2[@"y"] floatValue]) / 2.0;
+    
+    CGFloat centerDx = centerEndX - centerStartX;
+    CGFloat centerDy = centerEndY - centerStartY;
+    CGFloat centerDistance = sqrt(centerDx * centerDx + centerDy * centerDy);
+    
+    
+    if (centerDistance > RJPinchMinDistance) {
+        if (fabs(centerDy) > fabs(centerDx)) {
+            return centerDy > 0 ? RJGestureTypePanDown : RJGestureTypePanUp;
+        } else {
+            return centerDx > 0 ? RJGestureTypePanRight : RJGestureTypePanLeft;
+        }
+    }
+    
+    return nil;
+}
+
+@end

package/ios/Touch/RJTouchInterceptor.h

@@ -0,0 +1,169 @@
+//
+//  RJTouchInterceptor.h
+//  Rejourney
+//
+//  Global touch event interception and gesture detection.
+//
+//  The touch interceptor uses method swizzling to capture all touch
+//  events at the UIApplication level, classify gestures, and notify
+//  the Rejourney module.
+//
+//  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 <Foundation/Foundation.h>
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@class RJGestureClassifier;
+@class RJMotionEvent;
+
+/**
+ * Delegate protocol for receiving gesture and motion notifications.
+ */
+@protocol RJTouchInterceptorDelegate <NSObject>
+
+/**
+ * Called when a gesture is recognized.
+ *
+ * @param gestureType The type of gesture (e.g., "tap", "swipe_left").
+ * @param touches Array of touch point dictionaries.
+ * @param duration Gesture duration in milliseconds.
+ * @param targetLabel Accessibility label of the target view (if available).
+ */
+- (void)touchInterceptorDidRecognizeGesture:(NSString *)gestureType
+                                    touches:(NSArray<NSDictionary *> *)touches
+                                   duration:(NSTimeInterval)duration
+                                targetLabel:(nullable NSString *)targetLabel;
+
+@optional
+
+/**
+ * Called when a gesture is recognized.
+ *
+ * @param gestureType The type of gesture (e.g., "tap", "swipe_left").
+ * @param touches Array of touch point dictionaries.
+ * @param duration Gesture duration in milliseconds.
+ * @param targetLabel Accessibility label of the target view (if available).
+ */
+- (void)touchInterceptorDidRecognizeGesture:(NSString *)gestureType
+                                    touches:(NSArray<NSDictionary *> *)touches
+                                   duration:(NSTimeInterval)duration
+                                targetLabel:(nullable NSString *)targetLabel;
+
+@optional
+
+/**
+ * Called when a motion event is captured (scroll, pan, swipe with velocity).
+ * Used for event-driven replay reconstruction.
+ *
+ * @param motionEvent The motion event with type, displacement, velocity, and
+ * curve.
+ */
+- (void)touchInterceptorDidCaptureMotionEvent:(RJMotionEvent *)motionEvent;
+
+@optional
+
+/**
+ * Called when a touch interaction starts (TouchDown).
+ * Used to trigger "active state" captures to reduce replay lag.
+ */
+- (void)touchInterceptorDidDetectInteractionStart;
+
+@required
+
+/**
+ * Whether recording is currently active.
+ * The interceptor will not process touches when this returns NO.
+ */
+- (BOOL)isCurrentlyRecording;
+
+/**
+ * Whether the keyboard is currently visible.
+ * Used to detect keyboard taps (which are logged without location for privacy).
+ */
+- (BOOL)isKeyboardCurrentlyVisible;
+
+/**
+ * The current keyboard frame.
+ * Used to determine if touches are on the keyboard.
+ */
+- (CGRect)currentKeyboardFrame;
+
+@end
+
+/**
+ * Global touch interceptor that captures all touch events.
+ *
+ * This singleton intercepts UIApplication's sendEvent: method to capture
+ * all touch events before they're processed by the view hierarchy. It
+ * tracks multi-touch paths, classifies gestures, and notifies the delegate.
+ *
+ * ## Privacy
+ * - Keyboard touches are logged as "keyboard_tap" without location
+ * - No key content is captured
+ *
+ * ## Setup
+ * ```objc
+ * // In your module init
+ * [RJTouchInterceptor sharedInstance].delegate = self;
+ * [[RJTouchInterceptor sharedInstance] enableGlobalTracking];
+ * ```
+ *
+ * @note This class uses method swizzling which is performed once and cannot be
+ * undone.
+ */
+@interface RJTouchInterceptor : NSObject
+
+#pragma mark - Singleton
+
+/**
+ * Returns the shared touch interceptor instance.
+ */
++ (instancetype)sharedInstance;
+
+#pragma mark - Configuration
+
+/// Delegate to receive gesture notifications
+@property(nonatomic, weak, nullable) id<RJTouchInterceptorDelegate> delegate;
+
+/// Whether touch tracking is currently enabled
+@property(nonatomic, readonly) BOOL isTrackingEnabled;
+
+#pragma mark - Setup
+
+/**
+ * Enables global touch tracking via method swizzling.
+ *
+ * This method swizzles UIApplication's sendEvent: method to intercept
+ * all touch events. This is called once and cannot be undone.
+ *
+ * @note Safe to call multiple times; swizzling only happens once.
+ */
+- (void)enableGlobalTracking;
+
+#pragma mark - Internal (called by swizzled method)
+
+/**
+ * Handles a touch event. Called by the swizzled sendEvent: method.
+ *
+ * @param event The UIEvent containing touches.
+ */
+- (void)handleTouchEvent:(UIEvent *)event;
+
+@end
+
+NS_ASSUME_NONNULL_END