@rejourneyco/react-native 1.0.0

package/ios/Core/RJConstants.h

@@ -0,0 +1,124 @@
+//
+//  RJConstants.h
+//  Rejourney
+//
+//  SDK-wide constants and configuration defaults.
+//  This file contains all magic numbers and configuration values
+//  used throughout the Rejourney SDK.
+//
+//  Video Capture Model:
+//  - H.264 video segments at 1 FPS
+//  - JSON view hierarchy snapshots
+//  - Motion events for gesture reconstruction
+//
+//  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>
+
+NS_ASSUME_NONNULL_BEGIN
+
+#pragma mark - SDK Version
+
+/// Current SDK version string
+FOUNDATION_EXTERN NSString *const RJSDKVersion;
+
+#pragma mark - Capture Configuration (Video Model)
+
+/// Default capture scale factor (0.35 = 35% of original size for video)
+FOUNDATION_EXTERN const CGFloat RJDefaultCaptureScale;
+
+#pragma mark - Motion Event Configuration
+
+/// Minimum interval between motion events (0.016 = 60 FPS motion capture)
+FOUNDATION_EXTERN const NSTimeInterval RJDefaultMotionEventInterval;
+
+/// Minimum velocity to record scroll motion (points/second)
+FOUNDATION_EXTERN const CGFloat RJMotionVelocityThreshold;
+
+/// Scroll distance threshold for motion events (points)
+FOUNDATION_EXTERN const CGFloat RJDefaultScrollThreshold;
+
+/// Time after last scroll event to consider scroll ended (seconds)
+FOUNDATION_EXTERN const NSTimeInterval RJScrollEndDelay;
+
+#pragma mark - Memory Thresholds
+
+/// Memory warning threshold in bytes (100MB)
+FOUNDATION_EXTERN const NSUInteger RJMemoryWarningThresholdBytes;
+
+/// Maximum frame data bytes to keep in memory (2MB)
+FOUNDATION_EXTERN const NSUInteger RJMaxFrameBytesInMemory;
+
+/// Default maximum frames to keep in memory
+FOUNDATION_EXTERN const NSInteger RJDefaultMaxFramesInMemory;
+
+#pragma mark - Performance Thresholds
+
+/// Battery level threshold for low-power mode (15%)
+FOUNDATION_EXTERN const float RJLowBatteryThreshold;
+
+/// Maximum consecutive captures before cooldown
+FOUNDATION_EXTERN const NSInteger RJMaxConsecutiveCaptures;
+
+/// Cooldown duration after max consecutive captures (seconds)
+FOUNDATION_EXTERN const NSTimeInterval RJCaptureCooldownSeconds;
+
+#pragma mark - Upload Configuration
+
+/// Batch upload interval in seconds
+FOUNDATION_EXTERN const NSTimeInterval RJBatchUploadInterval;
+
+/// Initial upload delay for short sessions (seconds)
+FOUNDATION_EXTERN const NSTimeInterval RJInitialUploadDelay;
+
+/// Network request timeout (seconds)
+FOUNDATION_EXTERN const NSTimeInterval RJNetworkRequestTimeout;
+
+/// Network resource timeout (seconds)
+FOUNDATION_EXTERN const NSTimeInterval RJNetworkResourceTimeout;
+
+#pragma mark - Session Configuration
+
+/// Background duration threshold for new session (seconds)
+FOUNDATION_EXTERN const NSTimeInterval RJBackgroundSessionTimeout;
+
+#pragma mark - Gesture Detection
+
+/// Maximum time between taps for double-tap detection (milliseconds)
+FOUNDATION_EXTERN const NSTimeInterval RJDoubleTapMaxInterval;
+
+/// Maximum distance between taps for double-tap detection (points)
+FOUNDATION_EXTERN const CGFloat RJDoubleTapMaxDistance;
+
+/// Minimum duration for long press detection (milliseconds)
+FOUNDATION_EXTERN const NSTimeInterval RJLongPressMinDuration;
+
+/// Force touch threshold (normalized force value)
+FOUNDATION_EXTERN const CGFloat RJForceTouchThreshold;
+
+/// Minimum distance for swipe gesture detection (points)
+FOUNDATION_EXTERN const CGFloat RJSwipeMinDistance;
+
+/// Minimum distance for pinch gesture detection (points)
+FOUNDATION_EXTERN const CGFloat RJPinchMinDistance;
+
+/// Minimum distance change percentage for pinch detection
+FOUNDATION_EXTERN const CGFloat RJPinchMinChangePercent;
+
+/// Minimum rotation angle for rotation gesture detection (degrees)
+FOUNDATION_EXTERN const CGFloat RJRotationMinAngle;
+
+NS_ASSUME_NONNULL_END

package/ios/Core/RJConstants.m

@@ -0,0 +1,88 @@
+//
+//  RJConstants.m
+//  Rejourney
+//
+//  SDK-wide constants 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 "RJConstants.h"
+
+#pragma mark - SDK Version
+
+NSString *const RJSDKVersion = @"1.0.0";
+
+#pragma mark - Capture Configuration Defaults (Video Model)
+
+const CGFloat RJDefaultCaptureScale = 0.35;
+
+#pragma mark - Motion Event Configuration
+
+const NSTimeInterval RJDefaultMotionEventInterval = 0.016;
+
+const CGFloat RJMotionVelocityThreshold = 10.0;
+
+const CGFloat RJDefaultScrollThreshold = 5.0;
+
+const NSTimeInterval RJScrollEndDelay = 0.15;
+
+#pragma mark - Memory Thresholds
+
+const NSUInteger RJMemoryWarningThresholdBytes = 100 * 1024 * 1024;
+
+const NSUInteger RJMaxFrameBytesInMemory = 4 * 1024 * 1024;
+
+const NSInteger RJDefaultMaxFramesInMemory = 20;
+
+#pragma mark - Performance Thresholds
+
+const float RJLowBatteryThreshold = 0.15f;
+
+const NSInteger RJMaxConsecutiveCaptures = 5;
+
+const NSTimeInterval RJCaptureCooldownSeconds = 1.0;
+
+#pragma mark - Upload Configuration
+
+const NSTimeInterval RJBatchUploadInterval = 5.0;
+
+const NSTimeInterval RJInitialUploadDelay = 1.0;
+
+const NSTimeInterval RJNetworkRequestTimeout = 60.0;
+
+const NSTimeInterval RJNetworkResourceTimeout = 120.0;
+
+#pragma mark - Session Configuration
+
+const NSTimeInterval RJBackgroundSessionTimeout = 60.0;
+
+#pragma mark - Gesture Detection
+
+const NSTimeInterval RJDoubleTapMaxInterval = 300.0;
+
+const CGFloat RJDoubleTapMaxDistance = 50.0;
+
+const NSTimeInterval RJLongPressMinDuration = 500.0;
+
+const CGFloat RJForceTouchThreshold = 2.0;
+
+const CGFloat RJSwipeMinDistance = 50.0;
+
+const CGFloat RJPinchMinDistance = 30.0;
+
+const CGFloat RJPinchMinChangePercent = 0.20;
+
+const CGFloat RJRotationMinAngle = 15.0;

package/ios/Core/RJLifecycleManager.h

@@ -0,0 +1,85 @@
+//
+//  RJLifecycleManager.h
+//  Rejourney
+//
+//  App lifecycle and keyboard event handling.
+//
+//  Copyright (c) 2026 Rejourney
+//
+
+#import <Foundation/Foundation.h>
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// Delegate for lifecycle events
+@protocol RJLifecycleManagerDelegate <NSObject>
+@optional
+- (void)lifecycleManagerDidEnterBackground;
+- (void)lifecycleManagerWillTerminate;
+- (void)lifecycleManagerDidBecomeActive;
+- (void)lifecycleManagerDidResignActive;
+- (void)lifecycleManagerKeyboardDidShow:(CGRect)keyboardFrame;
+- (void)lifecycleManagerKeyboardWillHide:(NSInteger)keyPressCount;
+- (void)lifecycleManagerTextDidChange;
+- (void)lifecycleManagerSessionDidTimeout:(NSTimeInterval)backgroundDuration;
+@end
+
+/**
+ * Manages app lifecycle events and keyboard notifications.
+ */
+@interface RJLifecycleManager : NSObject
+
+/// Delegate for lifecycle events
+@property(nonatomic, weak, nullable) id<RJLifecycleManagerDelegate> delegate;
+
+/// Whether the keyboard is currently visible
+@property(nonatomic, readonly) BOOL isKeyboardVisible;
+
+/// Current keyboard frame
+@property(nonatomic, readonly) CGRect keyboardFrame;
+
+/// Whether recording is currently active (set by owner)
+@property(nonatomic, assign) BOOL isRecording;
+
+/// Whether the app is currently in background
+@property(nonatomic, readonly) BOOL isInBackground;
+
+/// Time when app entered background (epoch seconds), 0 if not in background
+@property(nonatomic, readonly) NSTimeInterval backgroundEntryTime;
+
+/// Total background time in milliseconds for the current session
+@property(nonatomic, readonly) NSTimeInterval totalBackgroundTimeMs;
+
+/// Background session timeout threshold in seconds
+@property(nonatomic, assign) NSTimeInterval backgroundTimeoutThreshold;
+
+/**
+ * Start observing lifecycle and keyboard notifications.
+ */
+- (void)startObserving;
+
+/**
+ * Stop observing notifications.
+ */
+- (void)stopObserving;
+
+/**
+ * Reset background time tracking for a new session.
+ */
+- (void)resetBackgroundTime;
+
+/**
+ * Mark that an external URL was opened.
+ */
+- (void)markExternalURLOpened:(NSString *)urlScheme;
+
+/**
+ * Check and clear external URL opened flag.
+ */
+- (BOOL)consumeExternalURLOpenedWithScheme:
+    (NSString *_Nullable *_Nullable)scheme;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/Core/RJLifecycleManager.m

@@ -0,0 +1,308 @@
+//
+//  RJLifecycleManager.m
+//  Rejourney
+//
+//  App lifecycle and keyboard event handling implementation.
+//  
+//  BACKGROUND TIMEOUT LOGIC:
+//  -------------------------
+//  When app returns from background:
+//  1. Calculate how long we were in background
+//  2. If < 60s: Add to accumulated background time, resume session normally
+//  3. If >= 60s: Signal timeout to delegate with the background duration
+//     The delegate (Rejourney.mm) will:
+//     a) End the old session with total background time (including this period)
+//     b) Start a new session with fresh state
+//
+//  Copyright (c) 2026 Rejourney
+//
+
+#import "RJLifecycleManager.h"
+#import "RJConstants.h"
+#import "RJLogger.h"
+
+#pragma mark - Private Interface
+
+@interface RJLifecycleManager ()
+
+@property(nonatomic, assign) BOOL keyboardVisible;
+@property(nonatomic, assign) CGRect currentKeyboardFrame;
+@property(nonatomic, assign) NSInteger keyPressCount;
+
+@property(nonatomic, assign) BOOL inBackground;
+@property(nonatomic, assign) NSTimeInterval backgroundEntryTime;
+@property(nonatomic, assign) NSTimeInterval accumulatedBackgroundTimeMs;
+
+@property(nonatomic, assign) BOOL didOpenExternalURL;
+@property(nonatomic, copy, nullable) NSString *lastOpenedURLScheme;
+
+@end
+
+#pragma mark - Implementation
+
+@implementation RJLifecycleManager
+
+#pragma mark - Initialization
+
+- (instancetype)init {
+  self = [super init];
+  if (self) {
+    _keyboardVisible = NO;
+    _currentKeyboardFrame = CGRectZero;
+    _keyPressCount = 0;
+    _inBackground = NO;
+    _backgroundEntryTime = 0;
+    _accumulatedBackgroundTimeMs = 0;
+    _backgroundTimeoutThreshold = RJBackgroundSessionTimeout;
+    _isRecording = NO;
+    _didOpenExternalURL = NO;
+  }
+  return self;
+}
+
+- (void)dealloc {
+  [self stopObserving];
+}
+
+#pragma mark - Public Properties
+
+- (BOOL)isKeyboardVisible {
+  return _keyboardVisible;
+}
+
+- (CGRect)keyboardFrame {
+  return _currentKeyboardFrame;
+}
+
+- (BOOL)isInBackground {
+  return _inBackground;
+}
+
+- (NSTimeInterval)backgroundEntryTime {
+  return _backgroundEntryTime;
+}
+
+- (NSTimeInterval)totalBackgroundTimeMs {
+  return _accumulatedBackgroundTimeMs;
+}
+
+#pragma mark - Observation Lifecycle
+
+- (void)startObserving {
+  RJLogInfo(@"[RJ-LIFECYCLE] startObserving called (isRecording=%@)",
+             self.isRecording ? @"YES" : @"NO");
+  NSNotificationCenter *center = [NSNotificationCenter defaultCenter];
+
+  // Keyboard notifications
+  [center addObserver:self
+             selector:@selector(keyboardWillShow:)
+                 name:UIKeyboardWillShowNotification
+               object:nil];
+  [center addObserver:self
+             selector:@selector(keyboardWillHide:)
+                 name:UIKeyboardWillHideNotification
+               object:nil];
+
+  // App lifecycle notifications
+  [center addObserver:self
+             selector:@selector(appDidEnterBackground:)
+                 name:UIApplicationDidEnterBackgroundNotification
+               object:nil];
+  [center addObserver:self
+             selector:@selector(appWillTerminate:)
+                 name:UIApplicationWillTerminateNotification
+               object:nil];
+  [center addObserver:self
+             selector:@selector(appWillResignActive:)
+                 name:UIApplicationWillResignActiveNotification
+               object:nil];
+  [center addObserver:self
+             selector:@selector(appDidBecomeActive:)
+                 name:UIApplicationDidBecomeActiveNotification
+               object:nil];
+
+  // Text change notifications
+  [center addObserver:self
+             selector:@selector(textDidChange:)
+                 name:UITextFieldTextDidChangeNotification
+               object:nil];
+  [center addObserver:self
+             selector:@selector(textDidChange:)
+                 name:UITextViewTextDidChangeNotification
+               object:nil];
+
+  RJLogInfo(@"[RJ-LIFECYCLE] Lifecycle manager started observing all notifications");
+}
+
+- (void)stopObserving {
+  [[NSNotificationCenter defaultCenter] removeObserver:self];
+  RJLogDebug(@"Lifecycle manager stopped observing");
+}
+
+#pragma mark - State Management
+
+- (void)resetBackgroundTime {
+  RJLogInfo(@"[RJ-LIFECYCLE] resetBackgroundTime called (was %.0fms)", self.accumulatedBackgroundTimeMs);
+  self.accumulatedBackgroundTimeMs = 0;
+  self.inBackground = NO;
+  self.backgroundEntryTime = 0;
+}
+
+- (void)markExternalURLOpened:(NSString *)urlScheme {
+  self.didOpenExternalURL = YES;
+  self.lastOpenedURLScheme = urlScheme;
+}
+
+- (BOOL)consumeExternalURLOpenedWithScheme:(NSString *_Nullable *_Nullable)scheme {
+  if (!self.didOpenExternalURL) {
+    return NO;
+  }
+
+  if (scheme) {
+    *scheme = self.lastOpenedURLScheme;
+  }
+
+  self.didOpenExternalURL = NO;
+  self.lastOpenedURLScheme = nil;
+  return YES;
+}
+
+#pragma mark - Keyboard Handling
+
+- (void)keyboardWillShow:(NSNotification *)notification {
+  self.keyboardVisible = YES;
+  self.currentKeyboardFrame =
+      [notification.userInfo[UIKeyboardFrameEndUserInfoKey] CGRectValue];
+
+  if (self.isRecording) {
+    if ([self.delegate
+            respondsToSelector:@selector(lifecycleManagerKeyboardDidShow:)]) {
+      [self.delegate lifecycleManagerKeyboardDidShow:self.currentKeyboardFrame];
+    }
+  }
+}
+
+- (void)keyboardWillHide:(NSNotification *)notification {
+  if (self.isRecording && self.keyPressCount > 0) {
+    if ([self.delegate
+            respondsToSelector:@selector(lifecycleManagerKeyboardWillHide:)]) {
+      [self.delegate lifecycleManagerKeyboardWillHide:self.keyPressCount];
+    }
+    self.keyPressCount = 0;
+  }
+
+  self.keyboardVisible = NO;
+  self.currentKeyboardFrame = CGRectZero;
+}
+
+- (void)textDidChange:(NSNotification *)notification {
+  if (self.isRecording) {
+    self.keyPressCount++;
+    if ([self.delegate
+            respondsToSelector:@selector(lifecycleManagerTextDidChange)]) {
+      [self.delegate lifecycleManagerTextDidChange];
+    }
+  }
+}
+
+#pragma mark - App Lifecycle
+
+- (void)appWillResignActive:(NSNotification *)notification {
+  if (self.isRecording) {
+    if ([self.delegate
+            respondsToSelector:@selector(lifecycleManagerDidResignActive)]) {
+      [self.delegate lifecycleManagerDidResignActive];
+    }
+  }
+}
+
+- (void)appDidEnterBackground:(NSNotification *)notification {
+  RJLogInfo(@"[RJ-LIFECYCLE] appDidEnterBackground (isRecording=%@)",
+             self.isRecording ? @"YES" : @"NO");
+
+  // Always track background entry time, even if not recording
+  // This allows us to detect timeout when session was ended while in background
+  self.inBackground = YES;
+  self.backgroundEntryTime = [[NSDate date] timeIntervalSince1970];
+
+  if (!self.isRecording) {
+    RJLogInfo(@"[RJ-LIFECYCLE] Not recording - just tracking background time");
+    return;
+  }
+
+  RJLogInfo(@"[RJ-LIFECYCLE] Calling lifecycleManagerDidEnterBackground delegate");
+  if ([self.delegate
+          respondsToSelector:@selector(lifecycleManagerDidEnterBackground)]) {
+    [self.delegate lifecycleManagerDidEnterBackground];
+  }
+}
+
+- (void)appWillTerminate:(NSNotification *)notification {
+  if ([self.delegate
+          respondsToSelector:@selector(lifecycleManagerWillTerminate)]) {
+    [self.delegate lifecycleManagerWillTerminate];
+  }
+}
+
+- (void)appDidBecomeActive:(NSNotification *)notification {
+  NSTimeInterval currentTime = [[NSDate date] timeIntervalSince1970];
+  BOOL wasInBackground = self.inBackground && self.backgroundEntryTime > 0;
+  NSTimeInterval backgroundDurationSec = 0;
+  
+  if (wasInBackground) {
+    backgroundDurationSec = currentTime - self.backgroundEntryTime;
+    RJLogInfo(@"[RJ-LIFECYCLE] Returned from background after %.1fs (isRecording=%@)", 
+               backgroundDurationSec, self.isRecording ? @"YES" : @"NO");
+  } else {
+    RJLogInfo(@"[RJ-LIFECYCLE] appDidBecomeActive - was NOT in background");
+  }
+  
+  // Reset background tracking state
+  self.inBackground = NO;
+  self.backgroundEntryTime = 0;
+  
+  // Handle the case where we weren't recording (session already ended)
+  if (!self.isRecording) {
+    // If we were in background long enough, signal that a new session should start
+    if (wasInBackground && backgroundDurationSec >= self.backgroundTimeoutThreshold) {
+      RJLogInfo(@"[RJ-LIFECYCLE] Was not recording, background >= %.0fs - signaling for new session start",
+            self.backgroundTimeoutThreshold);
+      if ([self.delegate respondsToSelector:@selector(lifecycleManagerSessionDidTimeout:)]) {
+        [self.delegate lifecycleManagerSessionDidTimeout:backgroundDurationSec];
+      }
+    }
+    return;
+  }
+
+  // We ARE recording - handle background return
+  if (wasInBackground) {
+    NSTimeInterval bgDurationMs = backgroundDurationSec * 1000;
+    
+    if (backgroundDurationSec >= self.backgroundTimeoutThreshold) {
+      // TIMEOUT CASE: End old session, start new one
+      // Add this background duration to accumulated time BEFORE signaling timeout
+      // so the old session gets the correct total background time
+      self.accumulatedBackgroundTimeMs += bgDurationMs;
+      RJLogInfo(@"[RJ-LIFECYCLE] TIMEOUT: Added %.0fms, total background=%.0fms - signaling session restart",
+            bgDurationMs, self.accumulatedBackgroundTimeMs);
+      
+      if ([self.delegate respondsToSelector:@selector(lifecycleManagerSessionDidTimeout:)]) {
+        [self.delegate lifecycleManagerSessionDidTimeout:backgroundDurationSec];
+      }
+      // Note: The delegate's handleSessionTimeout will read totalBackgroundTimeMs
+      // and then call resetBackgroundTime for the new session
+    } else {
+      // SHORT BACKGROUND: Just accumulate and resume
+      self.accumulatedBackgroundTimeMs += bgDurationMs;
+      RJLogInfo(@"[RJ-LIFECYCLE] Short background: Added %.0fms, total=%.0fms - resuming session",
+            bgDurationMs, self.accumulatedBackgroundTimeMs);
+    }
+  }
+
+  // Call didBecomeActive for normal resume handling (video capture, etc.)
+  if ([self.delegate respondsToSelector:@selector(lifecycleManagerDidBecomeActive)]) {
+    [self.delegate lifecycleManagerDidBecomeActive];
+  }
+}
+
+@end

package/ios/Core/RJLogger.h

@@ -0,0 +1,61 @@
+//
+//  RJLogger.h
+//  Rejourney
+//
+//  Centralized logging utility for the Rejourney SDK.
+//  Provides consistent log formatting and level-based filtering.
+//
+//  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>
+
+NS_ASSUME_NONNULL_BEGIN
+
+typedef NS_ENUM(NSInteger, RJLogLevel) {
+  RJLogLevelDebug = 0,
+  RJLogLevelInfo = 1,
+  RJLogLevelWarning = 2,
+  RJLogLevelError = 3,
+  RJLogLevelSilent = 4
+};
+
+@interface RJLogger : NSObject
+
+@property(class, nonatomic, assign) RJLogLevel minimumLogLevel;
+@property(class, nonatomic, assign) BOOL includeTimestamps;
+@property(class, nonatomic, assign) BOOL debugMode;
+
++ (void)debug:(NSString *)format, ... NS_FORMAT_FUNCTION(1, 2);
++ (void)info:(NSString *)format, ... NS_FORMAT_FUNCTION(1, 2);
++ (void)warning:(NSString *)format, ... NS_FORMAT_FUNCTION(1, 2);
++ (void)error:(NSString *)format, ... NS_FORMAT_FUNCTION(1, 2);
++ (void)logWithLevel:(RJLogLevel)level
+              format:(NSString *)format, ... NS_FORMAT_FUNCTION(2, 3);
++ (void)logInitSuccess:(NSString *)version;
++ (void)logInitFailure:(NSString *)reason;
++ (void)logSessionStart:(NSString *)sessionId;
++ (void)logSessionEnd:(NSString *)sessionId;
++ (void)setDebugMode:(BOOL)enabled;
+
+@end
+
+#define RJLogDebug(fmt, ...) [RJLogger debug:fmt, ##__VA_ARGS__]
+#define RJLogInfo(fmt, ...) [RJLogger info:fmt, ##__VA_ARGS__]
+#define RJLogWarning(fmt, ...) [RJLogger warning:fmt, ##__VA_ARGS__]
+#define RJLogError(fmt, ...) [RJLogger error:fmt, ##__VA_ARGS__]
+#define RJLogPerf(fmt, ...) [RJLogger info:fmt, ##__VA_ARGS__]
+
+NS_ASSUME_NONNULL_END