@truewatchtech/react-native-mobile 0.4.2 → 0.4.3

package/ios/FTJSLongTaskMonitor.h

@@ -0,0 +1,51 @@
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+typedef void (^FTJSLongTaskFrameCallback)(CFTimeInterval timestamp);
+
+@protocol FTJSLongTaskQueue <NSObject>
+- (BOOL)dispatchBlock:(dispatch_block_t)block;
+@end
+
+@protocol FTJSLongTaskFrameScheduler <NSObject>
+// The monitor serializes start/stop; start runs on the JS thread, while stop
+// must release resources synchronously even when that thread is unavailable.
+- (void)start;
+- (void)stop;
+@end
+
+@protocol FTJSLongTaskFrameSchedulerFactory <NSObject>
+- (id<FTJSLongTaskFrameScheduler>)createSchedulerWithCallback:(FTJSLongTaskFrameCallback)callback;
+@end
+
+@protocol FTJSLongTaskReporter <NSObject>
+- (void)reportLongTaskWithDurationNanoseconds:(int64_t)durationNanoseconds property:(NSDictionary *)property;
+@end
+
+@interface FTJSLongTaskMonitor : NSObject
+
+- (instancetype)initWithQueue:(id<FTJSLongTaskQueue>)queue
+              schedulerFactory:(id<FTJSLongTaskFrameSchedulerFactory>)schedulerFactory
+                       reporter:(id<FTJSLongTaskReporter>)reporter NS_DESIGNATED_INITIALIZER;
+- (instancetype)init NS_UNAVAILABLE;
+
+- (void)setThresholdMilliseconds:(double)thresholdMilliseconds;
+// Replaces the snapshot for future detections; does not change monitor lifecycle.
+- (void)setBridgeContext:(NSDictionary *)context;
+- (void)start;
+- (void)stop;
+// Completion runs on the calling thread after resources have been released.
+- (void)stopWithCompletion:(nullable dispatch_block_t)completion;
+// Prevents automatic restarts until a nonzero threshold is configured again.
+- (void)disableWithCompletion:(nullable dispatch_block_t)completion;
+
+@end
+
+@class RCTBridge;
+
+@interface FTJSLongTaskMonitor (Production)
++ (instancetype)monitorWithBridge:(RCTBridge *)bridge;
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/FTJSLongTaskMonitor.m

@@ -0,0 +1,250 @@
+#import "FTJSLongTaskMonitor.h"
+
+#import <QuartzCore/CADisplayLink.h>
+#import <TrueWatchSDK/FTExternalDataManager.h>
+#import <React/RCTBridge.h>
+#import <React/RCTBridge+Private.h>
+#import <React/RCTJSThread.h>
+
+static const double FTNanosecondsPerSecond = 1000000000.0;
+
+@interface FTReactBridgeJSQueue : NSObject <FTJSLongTaskQueue>
+@property (nonatomic, weak) RCTBridge *bridge;
+- (instancetype)initWithBridge:(RCTBridge *)bridge;
+@end
+
+@implementation FTReactBridgeJSQueue
+- (instancetype)initWithBridge:(RCTBridge *)bridge {
+  self = [super init];
+  if (self) {
+    _bridge = bridge;
+  }
+  return self;
+}
+
+- (BOOL)dispatchBlock:(dispatch_block_t)block {
+  RCTBridge *bridge = self.bridge;
+  if (bridge == nil) {
+    return NO;
+  }
+  @try {
+    // RCTBridgeProxy.valid is always NO, including while bridgeless RN is active.
+    [bridge dispatchBlock:block queue:RCTJSThread];
+    return YES;
+  } @catch (NSException *exception) {
+    // Bridge teardown may race a start request. Monitoring must not take down the host.
+    return NO;
+  }
+}
+@end
+
+// The display link retains this callback target, not the scheduler that owns it.
+@interface FTJSLongTaskDisplayLinkTarget : NSObject
+@property (nonatomic, copy) FTJSLongTaskFrameCallback callback;
+@end
+
+@implementation FTJSLongTaskDisplayLinkTarget
+- (void)displayLinkDidFire:(CADisplayLink *)displayLink {
+  self.callback(displayLink.timestamp);
+}
+@end
+
+@interface FTCADisplayLinkScheduler : NSObject <FTJSLongTaskFrameScheduler>
+@property (nonatomic, copy) FTJSLongTaskFrameCallback callback;
+@property (nonatomic, strong, nullable) CADisplayLink *displayLink;
+- (instancetype)initWithCallback:(FTJSLongTaskFrameCallback)callback;
+@end
+
+@implementation FTCADisplayLinkScheduler
+- (instancetype)initWithCallback:(FTJSLongTaskFrameCallback)callback {
+  self = [super init];
+  if (self) {
+    _callback = [callback copy];
+  }
+  return self;
+}
+
+- (void)start {
+  [self stop];
+  FTJSLongTaskDisplayLinkTarget *target = [FTJSLongTaskDisplayLinkTarget new];
+  target.callback = self.callback;
+  self.displayLink = [CADisplayLink displayLinkWithTarget:target selector:@selector(displayLinkDidFire:)];
+  [self.displayLink addToRunLoop:[NSRunLoop currentRunLoop] forMode:NSRunLoopCommonModes];
+}
+
+- (void)stop {
+  // CADisplayLink.invalidate is thread safe and releases its run loop and target
+  // references without requiring a live JS queue.
+  [self.displayLink invalidate];
+  self.displayLink = nil;
+}
+
+- (void)dealloc {
+  [_displayLink invalidate];
+}
+@end
+
+@interface FTCADisplayLinkSchedulerFactory : NSObject <FTJSLongTaskFrameSchedulerFactory>
+@end
+
+@implementation FTCADisplayLinkSchedulerFactory
+- (id<FTJSLongTaskFrameScheduler>)createSchedulerWithCallback:(FTJSLongTaskFrameCallback)callback {
+  return [[FTCADisplayLinkScheduler alloc] initWithCallback:callback];
+}
+@end
+
+@interface FTNativeLongTaskReporter : NSObject <FTJSLongTaskReporter>
+@end
+
+@implementation FTNativeLongTaskReporter
+- (void)reportLongTaskWithDurationNanoseconds:(int64_t)durationNanoseconds property:(NSDictionary *)property {
+  [[FTExternalDataManager sharedManager]
+    addLongTaskWithStack:@""
+    duration:@(durationNanoseconds)
+    property:property];
+}
+@end
+
+@interface FTJSLongTaskMonitor ()
+@property (nonatomic, strong) id<FTJSLongTaskQueue> queue;
+@property (nonatomic, strong) id<FTJSLongTaskFrameSchedulerFactory> schedulerFactory;
+@property (nonatomic, strong) id<FTJSLongTaskReporter> reporter;
+@property (nonatomic, strong) NSObject *stateLock;
+@property (nonatomic, assign) NSTimeInterval thresholdSeconds;
+@property (nonatomic, assign) NSUInteger generation;
+@property (nonatomic, assign) BOOL requestedRunning;
+@property (nonatomic, strong, nullable) id<FTJSLongTaskFrameScheduler> scheduler;
+@property (nonatomic, assign) NSUInteger activeGeneration;
+@property (nonatomic, assign) CFTimeInterval lastFrameTimestamp;
+@property (atomic, copy) NSDictionary *bridgeContext;
+@end
+
+@implementation FTJSLongTaskMonitor
+
++ (instancetype)monitorWithBridge:(RCTBridge *)bridge {
+  return [[self alloc]
+    initWithQueue:[[FTReactBridgeJSQueue alloc] initWithBridge:bridge]
+    schedulerFactory:[FTCADisplayLinkSchedulerFactory new]
+    reporter:[FTNativeLongTaskReporter new]];
+}
+
+- (instancetype)initWithQueue:(id<FTJSLongTaskQueue>)queue
+              schedulerFactory:(id<FTJSLongTaskFrameSchedulerFactory>)schedulerFactory
+                       reporter:(id<FTJSLongTaskReporter>)reporter {
+  self = [super init];
+  if (self) {
+    _queue = queue;
+    _schedulerFactory = schedulerFactory;
+    _reporter = reporter;
+    _stateLock = [NSObject new];
+    _bridgeContext = @{};
+  }
+  return self;
+}
+
+- (void)setThresholdMilliseconds:(double)thresholdMilliseconds {
+  @synchronized (self.stateLock) {
+    self.thresholdSeconds = thresholdMilliseconds <= 0 ? 0 : thresholdMilliseconds / 1000.0;
+    if (thresholdMilliseconds <= 0) {
+      [self stopLocked];
+    }
+  }
+}
+
+- (void)start {
+  NSUInteger startGeneration;
+  @synchronized (self.stateLock) {
+    if (self.thresholdSeconds == 0) {
+      return;
+    }
+    self.requestedRunning = YES;
+    startGeneration = ++self.generation;
+  }
+
+  __weak typeof(self) weakSelf = self;
+  BOOL dispatched = [self.queue dispatchBlock:^{
+    // A pending block must not keep a destroyed monitor (and its queue) alive.
+    typeof(self) strongSelf = weakSelf;
+    if (strongSelf == nil) {
+      return;
+    }
+    @synchronized (strongSelf.stateLock) {
+      if (strongSelf.generation != startGeneration || !strongSelf.requestedRunning) {
+        return;
+      }
+      [strongSelf.scheduler stop];
+      strongSelf.scheduler = [strongSelf.schedulerFactory createSchedulerWithCallback:^(CFTimeInterval timestamp) {
+        [weakSelf handleFrameTimestamp:timestamp generation:startGeneration];
+      }];
+      strongSelf.activeGeneration = startGeneration;
+      strongSelf.lastFrameTimestamp = 0;
+      [strongSelf.scheduler start];
+    }
+  }];
+  if (!dispatched) {
+    @synchronized (self.stateLock) {
+      if (self.generation == startGeneration) {
+        [self stopLocked];
+      }
+    }
+  }
+}
+
+- (void)stop {
+  [self stopWithCompletion:nil];
+}
+
+- (void)disableWithCompletion:(dispatch_block_t)completion {
+  @synchronized (self.stateLock) {
+    self.thresholdSeconds = 0;
+    [self stopLocked];
+  }
+  if (completion != nil) {
+    completion();
+  }
+}
+
+- (void)stopWithCompletion:(dispatch_block_t)completion {
+  @synchronized (self.stateLock) {
+    [self stopLocked];
+  }
+  if (completion != nil) {
+    completion();
+  }
+}
+
+// Caller holds stateLock, also used by scheduler installation and frame callbacks.
+// Cleanup deliberately never dispatches to RN: an invalid proxy may silently drop it.
+- (void)stopLocked {
+  self.requestedRunning = NO;
+  self.generation++;
+  [self.scheduler stop];
+  self.scheduler = nil;
+  self.activeGeneration = 0;
+  self.lastFrameTimestamp = 0;
+}
+
+- (void)handleFrameTimestamp:(CFTimeInterval)timestamp generation:(NSUInteger)generation {
+  @synchronized (self.stateLock) {
+    if (!self.requestedRunning || self.generation != generation ||
+        self.activeGeneration != generation || self.scheduler == nil) {
+      return;
+    }
+    if (self.lastFrameTimestamp != 0) {
+      NSTimeInterval duration = timestamp - self.lastFrameTimestamp;
+      if (duration > self.thresholdSeconds) {
+        int64_t durationNanoseconds = (int64_t)(duration * FTNanosecondsPerSecond);
+        // Capture at detection; later updates must not change an already reported event.
+        NSDictionary *property = self.bridgeContext;
+        [self.reporter reportLongTaskWithDurationNanoseconds:durationNanoseconds property:property];
+      }
+    }
+    self.lastFrameTimestamp = timestamp;
+  }
+}
+
+- (void)dealloc {
+  [_scheduler stop];
+}
+
+@end

package/ios/FTMobileReactNative.mm

@@ -7,13 +7,15 @@
 //
 
 #import "FTMobileReactNative.h"
+#import <TrueWatchSDK/FTSDKAgent.h>
 #import <React/RCTConvert.h>
-#import <FTMobileSDK/FTMobileAgent.h>
-#import <FTMobileSDK/FTMobileConfig+Private.h>
-#import <FTMobileSDK/FTThreadDispatchManager.h>
-#import <FTMobileSDK/FTConstants.h>
-#import <FTMobileSDK/FTJSONUtil.h>
-#import <FTMobileSDK/FTRemoteConfigModel+Private.h>
+#import <TrueWatchSDK/FTMobileAgent.h>
+#import <TrueWatchSDK/FTSDKConfig+Private.h>
+#import <TrueWatchSDK/FTThreadDispatchManager.h>
+#import <TrueWatchSDK/FTConstants.h>
+#import <TrueWatchSDK/FTJSONUtil.h>
+#import <TrueWatchSDK/FTRemoteConfigModel+Private.h>
+#import "FTWebSocketMetadataStore.h"
 
 static NSString *const FTRemoteConfigCallbackEvent = @"ft_remote_config_callback";
 
@@ -274,12 +276,33 @@ RCT_EXPORT_MODULE()
     if ([override.allKeys containsObject:@"logSampleRate"]) {
       model.logSampleRate = @([RCTConvert double:override[@"logSampleRate"]]);
     }
+    if ([override.allKeys containsObject:@"sessionSamplingRate"]) {
+      model.sessionSamplingRate = @([RCTConvert double:override[@"sessionSamplingRate"]]);
+    }
+    if ([override.allKeys containsObject:@"sessionOnErrorSamplingRate"]) {
+      model.sessionOnErrorSamplingRate = @([RCTConvert double:override[@"sessionOnErrorSamplingRate"]]);
+    }
+    if ([override.allKeys containsObject:@"traceSamplingRate"]) {
+      model.traceSamplingRate = @([RCTConvert double:override[@"traceSamplingRate"]]);
+    }
+    if ([override.allKeys containsObject:@"logSamplingRate"]) {
+      model.logSamplingRate = @([RCTConvert double:override[@"logSamplingRate"]]);
+    }
+    if ([override.allKeys containsObject:@"sessionReplaySamplingRate"]) {
+      model.sessionReplaySamplingRate = @([RCTConvert double:override[@"sessionReplaySamplingRate"]]);
+    }
+    if ([override.allKeys containsObject:@"sessionReplayOnErrorSamplingRate"]) {
+      model.sessionReplayOnErrorSamplingRate = @([RCTConvert double:override[@"sessionReplayOnErrorSamplingRate"]]);
+    }
     if ([override.allKeys containsObject:@"logLevelFilters"]) {
       model.logLevelFilters = [RCTConvert NSArray:override[@"logLevelFilters"]];
     }
     if ([override.allKeys containsObject:@"logEnableCustomLog"]) {
       model.logEnableCustomLog = @([RCTConvert double:override[@"logEnableCustomLog"]]);
     }
+    if ([override.allKeys containsObject:@"logEnableWebViewLog"] && override[@"logEnableWebViewLog"] != [NSNull null]) {
+      model.logEnableWebViewLog = @([RCTConvert BOOL:override[@"logEnableWebViewLog"]]);
+    }
     
     NSString *ruleId = [RCTConvert NSString:rule[@"id"]];
     [appliedRuleIds addObject:ruleId.length > 0 ? ruleId : [NSString stringWithFormat:@"rule_%lu", (unsigned long)idx]];
@@ -319,6 +342,12 @@ RCT_REMAP_METHOD(bindRUMUserData,
   [self bindRUMUserData:userId userName:userName userEmail:userName extra:extra resolve:resolve reject:reject];
 }
 
+RCT_REMAP_METHOD(resetVisitorId,
+                 resetVisitorIdResolver:(RCTPromiseResolveBlock)resolve
+                 rejecter:(RCTPromiseRejectBlock)reject) {
+  [self resetVisitorId:resolve reject:reject];
+}
+
 RCT_REMAP_METHOD(unbindRUMUserData,
                  unbindRUMUserData_Resolver:(RCTPromiseResolveBlock)resolve
                  rejecter:(RCTPromiseRejectBlock)reject
@@ -373,17 +402,16 @@ RCT_REMAP_METHOD(clearAllData,
 #endif
 - (void)sdkConfig:(NSDictionary *)context resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject {
   [FTThreadDispatchManager performBlockDispatchMainSyncSafe:^{
-    FTMobileConfig *config;
+    FTSDKConfig *config;
     NSString *datakitUrl = [RCTConvert NSString:context[@"datakitUrl"]];
     NSString *dataWayUrl = [RCTConvert NSString:context[@"datawayUrl"]];
     NSString *clientToken = [RCTConvert NSString:context[@"clientToken"]];
     if(dataWayUrl && dataWayUrl.length>0 && clientToken && clientToken.length>0){
-      config = [[FTMobileConfig alloc]initWithDatawayUrl:dataWayUrl clientToken:clientToken];
+      config = [[FTSDKConfig alloc]initWithDatawayUrl:dataWayUrl clientToken:clientToken];
     }else if(datakitUrl && datakitUrl.length>0){
-      config = [[FTMobileConfig alloc]initWithDatakitUrl:datakitUrl];
+      config = [[FTSDKConfig alloc]initWithDatakitUrl:datakitUrl];
     }else{
-      resolve(nil);
-      return;
+      config = [[FTSDKConfig alloc]init];
     }
     if ([context.allKeys containsObject:@"debug"]) {
       config.enableSDKDebugLog = [RCTConvert BOOL:context[@"debug"]];
@@ -427,6 +455,9 @@ RCT_REMAP_METHOD(clearAllData,
     if ([context.allKeys containsObject:@"dataFilters"]) {
       config.dataFilters = [RCTConvert NSDictionary:context[@"dataFilters"]];
     }
+    if ([context.allKeys containsObject:@"allowWebViewHost"]) {
+      config.allowWebViewHost = [RCTConvert NSArray:context[@"allowWebViewHost"]];
+    }
     if ([context.allKeys containsObject:@"globalContext"]) {
       config.globalContext = [RCTConvert NSDictionary:context[@"globalContext"]];
     }
@@ -490,6 +521,7 @@ RCT_REMAP_METHOD(clearAllData,
       };
     }
     [FTMobileAgent startWithConfigOptions:config];
+    [FTWebSocketMetadataStore sdkDidStart];
     resolve(nil);
   }];
 }
@@ -526,6 +558,11 @@ RCT_REMAP_METHOD(clearAllData,
   [[FTMobileAgent sharedInstance] unbindUser];
   resolve(nil);
 }
+- (void)resetVisitorId:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject {
+  [FTSDKAgent resetVisitorID];
+  resolve(nil);
+}
+
 - (void)clearAllData:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject {
   [FTMobileAgent clearAllData];
   resolve(nil);
@@ -537,6 +574,7 @@ RCT_REMAP_METHOD(clearAllData,
 }
 
 - (void)shutDown:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject { 
+  [FTWebSocketMetadataStore shutDown];
   [FTMobileAgent shutDown];
   resolve(nil);
 }
@@ -553,9 +591,8 @@ RCT_REMAP_METHOD(clearAllData,
 
   }];
 }
-RCT_REMAP_METHOD(updateRemoteConfig,
-                 updateRemoteConfig_findEventsWithResolver:(RCTPromiseResolveBlock)resolve
-                 rejecter:(RCTPromiseRejectBlock)reject){
+RCT_EXPORT_METHOD(updateRemoteConfig:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject){
     if (!_remoteConfigurationEnabled) {
       reject(@"E_REMOTE_CONFIG_DISABLED", @"Remote configuration is not enabled.", nil);
       return;
@@ -580,11 +617,10 @@ RCT_REMAP_METHOD(updateRemoteConfig,
       return nil;
     }];
 }
-RCT_REMAP_METHOD(updateRemoteConfigWithMiniUpdateInterval,
-                  interval:(int)interval
+RCT_EXPORT_METHOD(updateRemoteConfigWithMiniUpdateInterval:(double)interval
                   rules:(NSArray *)rules
-                  findEventsWithResolver:(RCTPromiseResolveBlock)resolve
-                  rejecter:(RCTPromiseRejectBlock)reject){
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject){
   if (!_remoteConfigurationEnabled) {
     reject(@"E_REMOTE_CONFIG_DISABLED", @"Remote configuration is not enabled.", nil);
     return;

package/ios/FTReactNativeLog.mm

@@ -7,9 +7,9 @@
 //
 
 #import "FTReactNativeLog.h"
-#import <FTMobileSDK/FTMobileAgent.h>
+#import <TrueWatchSDK/FTMobileAgent.h>
 #import <React/RCTConvert.h>
-#import <FTMobileSDK/FTLogger+Private.h>
+#import <TrueWatchSDK/FTLogger+Private.h>
 @implementation FTReactNativeLog
 RCT_EXPORT_MODULE()
 
@@ -42,8 +42,13 @@ RCT_REMAP_METHOD(logWithStatusString,
 
 - (void)logConfig:(NSDictionary *)context resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject {
   FTLoggerConfig *logger = [[FTLoggerConfig alloc]init];
-  if ([context.allKeys containsObject:@"sampleRate"]) {
-      logger.samplerate  = [RCTConvert double:context[@"sampleRate"]]*100;
+  if ([context.allKeys containsObject:@"logSamplingRate"]) {
+    logger.logSamplingRate = [RCTConvert double:context[@"logSamplingRate"]];
+  } else if ([context.allKeys containsObject:@"sampleRate"]) {
+    logger.logSamplingRate = [RCTConvert double:context[@"sampleRate"]] * 100;
+  }
+  if ([context.allKeys containsObject:@"enableWebViewLog"]) {
+      logger.enableWebViewLog = [RCTConvert BOOL:context[@"enableWebViewLog"]];
   }
   NSArray<NSNumber *>*filters = [RCTConvert NSNumberArray:context[@"logLevelFilters"]];
   if (filters) {
@@ -76,4 +81,3 @@ RCT_REMAP_METHOD(logWithStatusString,
 }
 
 @end
-