@truewatchtech/react-native-mobile 0.4.2 → 0.4.3

package/android/src/main/java/com/ft/sdk/reactnative/JsLongTaskMonitor.java

@@ -0,0 +1,281 @@
+package com.ft.sdk.reactnative;
+
+import android.view.Choreographer;
+
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.ft.sdk.FTRUMGlobalManager;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Collections;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+final class JsLongTaskMonitor {
+
+  private static final double NANOS_PER_MILLISECOND = 1_000_000d;
+
+  interface Executor {
+    boolean runOnJsThread(Runnable runnable);
+  }
+
+  interface FrameCallback {
+    void doFrame(long frameTimeNanos);
+  }
+
+  interface FrameScheduler {
+    void postFrameCallback();
+
+    void removeFrameCallback();
+  }
+
+  interface FrameSchedulerFactory {
+    FrameScheduler create(FrameCallback callback);
+  }
+
+  interface Reporter {
+    void reportLongTask(long durationNanos, Map<String, Object> property);
+  }
+
+  private final Executor executor;
+  private final FrameSchedulerFactory schedulerFactory;
+  private final Reporter reporter;
+  private final Object stateLock = new Object();
+  private final FrameCallback frameCallback;
+
+  private volatile long thresholdNanos;
+  private volatile int generation;
+  private volatile boolean requestedRunning;
+  private volatile Map<String, Object> bridgeContext = Collections.emptyMap();
+
+  // Accessed only on the React Native JavaScript thread.
+  private FrameScheduler scheduler;
+  private int activeGeneration;
+  private long lastFrameTimeNanos;
+
+  static JsLongTaskMonitor create(ReactApplicationContext reactContext) {
+    return new JsLongTaskMonitor(
+      new ReactJsThreadExecutor(reactContext),
+      new ChoreographerSchedulerFactory(),
+      new NativeLongTaskReporter()
+    );
+  }
+
+  JsLongTaskMonitor(
+    Executor executor,
+    FrameSchedulerFactory schedulerFactory,
+    Reporter reporter
+  ) {
+    this.executor = executor;
+    this.schedulerFactory = schedulerFactory;
+    this.reporter = reporter;
+    this.frameCallback = new FrameCallback() {
+      @Override
+      public void doFrame(long frameTimeNanos) {
+        handleFrame(frameTimeNanos);
+      }
+    };
+  }
+
+  void setThresholdMilliseconds(double thresholdMilliseconds) {
+    thresholdNanos = thresholdMilliseconds <= 0
+      ? 0
+      : (long) (thresholdMilliseconds * NANOS_PER_MILLISECOND);
+    if (thresholdNanos == 0) {
+      stop();
+    }
+  }
+
+  void setBridgeContext(Map<String, Object> context) {
+    bridgeContext = context == null
+      ? Collections.<String, Object>emptyMap()
+      : new HashMap<>(context);
+  }
+
+  void start() {
+    final int startGeneration;
+    synchronized (stateLock) {
+      if (thresholdNanos == 0) {
+        return;
+      }
+      requestedRunning = true;
+      startGeneration = ++generation;
+    }
+    try {
+      boolean accepted = executor.runOnJsThread(new Runnable() {
+        @Override
+        public void run() {
+          if (!isCurrentRequest(startGeneration, true)) {
+            return;
+          }
+          try {
+            if (scheduler != null) {
+              scheduler.removeFrameCallback();
+            }
+            scheduler = schedulerFactory.create(frameCallback);
+            activeGeneration = startGeneration;
+            lastFrameTimeNanos = 0;
+            scheduler.postFrameCallback();
+          } catch (IllegalStateException ignored) {
+            disableRequestOnJsThread(startGeneration);
+          }
+        }
+      });
+      if (!accepted) {
+        markRequestDisabled(startGeneration);
+      }
+    } catch (IllegalStateException ignored) {
+      markRequestDisabled(startGeneration);
+    }
+  }
+
+  void stop() {
+    stop(null);
+  }
+
+  // Unlike a lifecycle pause, SDK shutdown must prevent automatic restarts.
+  void disable(final Runnable completion) {
+    thresholdNanos = 0;
+    stop(completion);
+  }
+
+  void stop(final Runnable completion) {
+    final Runnable completeOnce = once(completion);
+    final int stopGeneration;
+    synchronized (stateLock) {
+      requestedRunning = false;
+      stopGeneration = ++generation;
+    }
+    try {
+      boolean accepted = executor.runOnJsThread(new Runnable() {
+        @Override
+        public void run() {
+          if (isCurrentRequest(stopGeneration, false)) {
+            try {
+              if (scheduler != null) {
+                scheduler.removeFrameCallback();
+              }
+            } catch (IllegalStateException ignored) {
+              // The request is already disabled, so only local state needs clearing.
+            }
+            scheduler = null;
+            activeGeneration = 0;
+            lastFrameTimeNanos = 0;
+          }
+          completeOnce.run();
+        }
+      });
+      if (!accepted) {
+        completeOnce.run();
+      }
+    } catch (IllegalStateException ignored) {
+      // The JavaScript queue may already be unavailable during teardown.
+      completeOnce.run();
+    }
+  }
+
+  private boolean isCurrentRequest(int requestGeneration, boolean running) {
+    synchronized (stateLock) {
+      return generation == requestGeneration && requestedRunning == running;
+    }
+  }
+
+  private void markRequestDisabled(int requestGeneration) {
+    synchronized (stateLock) {
+      if (generation == requestGeneration) {
+        requestedRunning = false;
+      }
+    }
+  }
+
+  private void disableRequestOnJsThread(int requestGeneration) {
+    markRequestDisabled(requestGeneration);
+    scheduler = null;
+    activeGeneration = 0;
+    lastFrameTimeNanos = 0;
+  }
+
+  private static Runnable once(final Runnable completion) {
+    final AtomicBoolean completed = new AtomicBoolean();
+    return new Runnable() {
+      @Override
+      public void run() {
+        if (completed.compareAndSet(false, true) && completion != null) {
+          completion.run();
+        }
+      }
+    };
+  }
+
+  private void handleFrame(long frameTimeNanos) {
+    if (!isCurrentRequest(activeGeneration, true) || scheduler == null) {
+      return;
+    }
+
+    if (lastFrameTimeNanos != 0) {
+      long durationNanos = frameTimeNanos - lastFrameTimeNanos;
+      if (durationNanos > thresholdNanos) {
+        try {
+          // Take a detection-time snapshot before handing the event to the SDK.
+          reporter.reportLongTask(durationNanos, new HashMap<>(bridgeContext));
+        } catch (RuntimeException ignored) {
+          // Reporting must not interrupt the JavaScript frame callback loop.
+        }
+      }
+    }
+    lastFrameTimeNanos = frameTimeNanos;
+
+    if (isCurrentRequest(activeGeneration, true) && scheduler != null) {
+      try {
+        scheduler.postFrameCallback();
+      } catch (IllegalStateException ignored) {
+        disableRequestOnJsThread(activeGeneration);
+      }
+    }
+  }
+
+  private static final class ChoreographerSchedulerFactory implements FrameSchedulerFactory {
+    @Override
+    public FrameScheduler create(FrameCallback callback) {
+      return new ChoreographerScheduler(Choreographer.getInstance(), callback);
+    }
+  }
+
+  private static final class ChoreographerScheduler implements FrameScheduler {
+    private final Choreographer choreographer;
+    private final Choreographer.FrameCallback callback;
+
+    private ChoreographerScheduler(
+      Choreographer choreographer,
+      final FrameCallback callback
+    ) {
+      this.choreographer = choreographer;
+      this.callback = new Choreographer.FrameCallback() {
+        @Override
+        public void doFrame(long frameTimeNanos) {
+          callback.doFrame(frameTimeNanos);
+        }
+      };
+    }
+
+    @Override
+    public void postFrameCallback() {
+      choreographer.postFrameCallback(callback);
+    }
+
+    @Override
+    public void removeFrameCallback() {
+      choreographer.removeFrameCallback(callback);
+    }
+  }
+
+  private static final class NativeLongTaskReporter implements Reporter {
+    @Override
+    public void reportLongTask(long durationNanos, Map<String, Object> property) {
+      FTRUMGlobalManager.get().addLongTask(
+        "",
+        durationNanos,
+        new HashMap<>(property)
+      );
+    }
+  }
+}

package/android/src/main/java/com/ft/sdk/reactnative/ViewTiming.java

@@ -0,0 +1,17 @@
+package com.ft.sdk.reactnative;
+
+final class ViewTiming {
+  private ViewTiming() {}
+
+  static long durationNanoseconds(double value) {
+    return (!Double.isNaN(value) && !Double.isInfinite(value)) && value > 0 && value < 0x1p63 ? (long) value : 0;
+  }
+
+  static long epochNanoseconds(double milliseconds) {
+    if ((Double.isNaN(milliseconds) || Double.isInfinite(milliseconds)) || milliseconds <= 0 || milliseconds >= 0x1p63 / 1000000.0) return 0;
+    long whole = (long) milliseconds;
+    long fraction = (long) ((milliseconds - whole) * 1000000.0);
+    if (whole > Long.MAX_VALUE / 1000000 || fraction > Long.MAX_VALUE - whole * 1000000) return 0;
+    return whole * 1000000 + fraction;
+  }
+}

package/android/src/main/java/com/ft/sdk/reactnative/VisitorIdConfigMapper.java

@@ -0,0 +1,50 @@
+package com.ft.sdk.reactnative;
+
+import com.ft.sdk.FTVisitorIdConfig;
+import java.net.URI;
+import java.util.List;
+import java.util.Map;
+import java.util.regex.Pattern;
+
+final class VisitorIdConfigMapper {
+  private VisitorIdConfigMapper() {}
+
+  static FTVisitorIdConfig fromMap(Object value) {
+    if (value == null) return null;
+    if (!(value instanceof Map)) throw new IllegalArgumentException("visitorIdConfig must be an object");
+    Map<?, ?> map = (Map<?, ?>) value;
+    if (!(map.get("header") instanceof String)) throw new IllegalArgumentException("Visitor ID header is required");
+    FTVisitorIdConfig config = new FTVisitorIdConfig().setHeader((String) map.get("header"));
+    if (map.containsKey("ttlHours")) {
+      if (!(map.get("ttlHours") instanceof Number)) throw new IllegalArgumentException("Visitor ID TTL must be numeric");
+      double hours = ((Number) map.get("ttlHours")).doubleValue();
+      double milliseconds = hours * 3600000;
+      if (Double.isNaN(hours) || Double.isInfinite(hours) || milliseconds < 1 || milliseconds >= Long.MAX_VALUE) {
+        throw new IllegalArgumentException("Visitor ID TTL is out of range");
+      }
+      config.setTtlHours(hours);
+    }
+    int rules = 0;
+    for (String key : new String[]{"urlPrefixes", "regularExpressions"}) {
+      Object values = map.get(key);
+      if (values == null && !map.containsKey(key)) continue;
+      if (!(values instanceof List)) throw new IllegalArgumentException(key + " must be an array");
+      for (Object item : (List<?>) values) {
+        if (!(item instanceof String) || ((String) item).isEmpty()) throw new IllegalArgumentException("Invalid Visitor ID rule");
+        String rule = (String) item;
+        if ("urlPrefixes".equals(key)) {
+          URI uri = URI.create(rule);
+          if (uri.getHost() == null || !("http".equalsIgnoreCase(uri.getScheme()) || "https".equalsIgnoreCase(uri.getScheme()))) {
+            throw new IllegalArgumentException("Visitor ID prefix must be an HTTP(S) URL");
+          }
+          config.addMatch(rule);
+        } else {
+          config.addMatch(Pattern.compile(rule));
+        }
+        rules++;
+      }
+    }
+    if (rules == 0) throw new IllegalArgumentException("Visitor ID requires URL matching rules");
+    return config;
+  }
+}

package/android/src/main/java/com/ft/sdk/reactnative/utils/ReactNativeUtils.java

@@ -1,14 +1,13 @@
 package com.ft.sdk.reactnative.utils;
 
 import java.util.regex.Pattern;
-import java.util.regex.Matcher;
 
 public class ReactNativeUtils {
 
-    private static final Pattern[] RN_DEV_INNER_URL_REGEX = {
-        Pattern.compile("^http://((10|172|192).[0-9]+.[0-9]+.[0-9]+|localhost|127.0.0.1):808[0-9]/logs$"), // expo
-        Pattern.compile("^http://localhost:808[0-9]/(hot|symbolicate|message|inspector).*$") // rn
-    };
+    private static final Pattern RN_DEV_INNER_URL_PATTERN = Pattern.compile(
+        "^(?:https?|wss?)://(?:(?:10|172|192)(?:\\.[0-9]+){3}|localhost|127\\.0\\.0\\.1|\\[::1\\]):808[0-9]/(?:hot|symbolicate|message|inspector|status|assets|logs|debugger-proxy)(?:[/?#].*)?$",
+        Pattern.CASE_INSENSITIVE
+    );
 
     private ReactNativeUtils() {
         // Private constructor to prevent instantiation
@@ -48,12 +47,6 @@ public class ReactNativeUtils {
      * @return
      */
     public static boolean isReactNativeDevUrl(String url) {
-        for (Pattern pattern : RN_DEV_INNER_URL_REGEX) {
-            Matcher matcher = pattern.matcher(url);
-            if (matcher.matches()) {
-                return true;
-            }
-        }
-        return false;
+        return url != null && RN_DEV_INNER_URL_PATTERN.matcher(url).matches();
     }
 }

package/android/src/newarch/java/com/ft/sdk/reactnative/FTMobileModule.java

@@ -39,6 +39,11 @@ public class FTMobileModule extends NativeFTMobileReactNativeSpec {
     impl.bindRUMUserData(userId, userName, userEmail, extra, promise);
   }
 
+  @ReactMethod
+  public void resetVisitorId(Promise promise) {
+    impl.resetVisitorId(promise);
+  }
+
   @ReactMethod
   public void unbindRUMUserData(Promise promise) {
     impl.unbindRUMUserData(promise);
@@ -81,23 +86,27 @@ public class FTMobileModule extends NativeFTMobileReactNativeSpec {
   }
 
   @ReactMethod
+  @Override
   public void updateRemoteConfig(Promise promise) {
-    impl.updateRemoteConfig(promise); 
+    impl.updateRemoteConfig(promise);
   }
 
   @ReactMethod
-  public void updateRemoteConfigWithMiniUpdateInterval(int interval, @Nullable ReadableArray rules, Promise promise) {
-    impl.updateRemoteConfigWithMiniUpdateInterval(interval, rules, promise);
+  @Override
+  public void updateRemoteConfigWithMiniUpdateInterval(double interval, @Nullable ReadableArray rules, Promise promise) {
+    impl.updateRemoteConfigWithMiniUpdateInterval((int) interval, rules, promise);
   }
 
   @ReactMethod
+  @Override
   public void addListener(String eventName) {
-    impl.addListener(eventName);
+    // Required by NativeEventEmitter; Android does not need listener bookkeeping.
   }
 
   @ReactMethod
+  @Override
   public void removeListeners(double count) {
-    impl.removeListeners(count);
+    // Required by NativeEventEmitter; Android does not need listener bookkeeping.
   }
 
 }

package/android/src/newarch/java/com/ft/sdk/reactnative/FTRUMModule.java

@@ -9,10 +9,11 @@ import com.facebook.react.bridge.ReadableMap;
 
 public class FTRUMModule extends NativeFTReactNativeRUMSpec {
 
-  private final FTRUMImpl impl = new FTRUMImpl();
+  private final FTRUMImpl impl;
 
   public FTRUMModule(ReactApplicationContext reactContext) {
     super(reactContext);
+    impl = new FTRUMImpl(reactContext);
   }
 
   @Override
@@ -21,6 +22,30 @@ public class FTRUMModule extends NativeFTReactNativeRUMSpec {
     impl.setConfig(context, promise);
   }
 
+  @Override
+  @ReactMethod
+  public void stopLongTaskTracking(Promise promise) {
+    impl.stopLongTaskTracking(promise);
+  }
+
+  @Override
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  public boolean setLongTaskContext(ReadableMap context) {
+    return impl.setLongTaskContext(context);
+  }
+
+  @Override
+  public void invalidate() {
+    impl.destroy();
+    super.invalidate();
+  }
+
+  @Override
+  public void onCatalystInstanceDestroy() {
+    impl.destroy();
+    super.onCatalystInstanceDestroy();
+  }
+
   @Override
   @ReactMethod
   public void startAction(String actionName, String actionType, ReadableMap map, Promise promise) {
@@ -33,6 +58,24 @@ public class FTRUMModule extends NativeFTReactNativeRUMSpec {
     impl.addAction(actionName, actionType, map, promise);
   }
 
+  @Override
+  @ReactMethod
+  public void onCreateViewWithLoadStart(String viewName, double duration, double loadStartEpochMs, Promise promise) {
+    impl.onCreateViewWithLoadStart(viewName, duration, loadStartEpochMs, promise);
+  }
+
+  @Override
+  @ReactMethod
+  public void startViewWithTrackingType(String viewName, ReadableMap map, double trackingType, Promise promise) {
+    impl.startViewWithTrackingType(viewName, map, trackingType, promise);
+  }
+
+  @Override
+  @ReactMethod
+  public void updateViewLoadingTime(double duration, Promise promise) {
+    impl.updateViewLoadingTime(duration, promise);
+  }
+
   @Override
   @ReactMethod
   public void onCreateView(String viewName, double duration, Promise promise) {

package/android/src/newarch/java/com/ft/sdk/reactnative/FTTraceModule.java

@@ -4,6 +4,7 @@ import com.facebook.react.bridge.Promise;
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.bridge.ReactMethod;
 import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.WritableMap;
 
 public class FTTraceModule extends NativeFTReactNativeTraceSpec {
   private final FTTraceImpl impl = new FTTraceImpl();
@@ -29,4 +30,17 @@ public class FTTraceModule extends NativeFTReactNativeTraceSpec {
   public void getTraceHeaderFields(String url, String key, Promise promise) {
     impl.getTraceHeaderFields(url, key, promise);
   }
+
+  @Override
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  public WritableMap getTraceHeaderFieldsSync(String url, String key) {
+    return impl.getTraceHeaderFieldsSync(url, key);
+  }
+
+  @Override
+  @ReactMethod
+  public void cancelWebSocketTrace(String key, Promise promise) {
+    // JS WebSocket observation is iOS-only; Android owns its native lifecycle.
+    promise.resolve(null);
+  }
 }

package/android/src/oldarch/java/com/ft/sdk/reactnative/FTMobileModule.java

@@ -38,6 +38,11 @@ public class FTMobileModule extends ReactContextBaseJavaModule {
     impl.bindRUMUserData(userId, userName, userEmail, extra, promise);
   }
 
+  @ReactMethod
+  public void resetVisitorId(Promise promise) {
+    impl.resetVisitorId(promise);
+  }
+
   @ReactMethod
   public void unbindRUMUserData(Promise promise) {
     impl.unbindRUMUserData(promise);
@@ -85,12 +90,12 @@ public class FTMobileModule extends ReactContextBaseJavaModule {
 
   @ReactMethod
   public void addListener(String eventName) {
-    impl.addListener(eventName);
+    // Required by NativeEventEmitter; Android does not need listener bookkeeping.
   }
 
   @ReactMethod
   public void removeListeners(double count) {
-    impl.removeListeners(count);
+    // Required by NativeEventEmitter; Android does not need listener bookkeeping.
   }
 
   @NonNull

package/android/src/oldarch/java/com/ft/sdk/reactnative/FTRUMModule.java

@@ -7,10 +7,11 @@ import com.facebook.react.bridge.ReactMethod;
 import com.facebook.react.bridge.ReadableMap;
 
 public class FTRUMModule extends ReactContextBaseJavaModule {
-  private final FTRUMImpl impl = new FTRUMImpl();
+  private final FTRUMImpl impl;
 
   public FTRUMModule(ReactApplicationContext reactContext) {
     super(reactContext);
+    impl = new FTRUMImpl(reactContext);
   }
 
   @Override
@@ -23,6 +24,28 @@ public class FTRUMModule extends ReactContextBaseJavaModule {
     impl.setConfig(context, promise);
   }
 
+  @ReactMethod
+  public void stopLongTaskTracking(Promise promise) {
+    impl.stopLongTaskTracking(promise);
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  public boolean setLongTaskContext(ReadableMap context) {
+    return impl.setLongTaskContext(context);
+  }
+
+  @Override
+  public void invalidate() {
+    impl.destroy();
+    super.invalidate();
+  }
+
+  @Override
+  public void onCatalystInstanceDestroy() {
+    impl.destroy();
+    super.onCatalystInstanceDestroy();
+  }
+
   @ReactMethod
   public void startAction(String actionName, String actionType, ReadableMap map, Promise promise) {
     impl.startAction(actionName, actionType, map, promise);
@@ -33,6 +56,21 @@ public class FTRUMModule extends ReactContextBaseJavaModule {
     impl.addAction(actionName, actionType, map, promise);
   }
 
+  @ReactMethod
+  public void onCreateViewWithLoadStart(String viewName, double duration, double loadStartEpochMs, Promise promise) {
+    impl.onCreateViewWithLoadStart(viewName, duration, loadStartEpochMs, promise);
+  }
+
+  @ReactMethod
+  public void startViewWithTrackingType(String viewName, ReadableMap map, double trackingType, Promise promise) {
+    impl.startViewWithTrackingType(viewName, map, trackingType, promise);
+  }
+
+  @ReactMethod
+  public void updateViewLoadingTime(double duration, Promise promise) {
+    impl.updateViewLoadingTime(duration, promise);
+  }
+
   @ReactMethod
   public void onCreateView(String viewName, Double duration, Promise promise) {
     impl.onCreateView(viewName, duration, promise);

package/android/src/oldarch/java/com/ft/sdk/reactnative/FTTraceModule.java

@@ -5,6 +5,7 @@ import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.bridge.ReactContextBaseJavaModule;
 import com.facebook.react.bridge.ReactMethod;
 import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.WritableMap;
 
 public class FTTraceModule extends ReactContextBaseJavaModule {
   private final FTTraceImpl impl = new FTTraceImpl();
@@ -27,4 +28,15 @@ public class FTTraceModule extends ReactContextBaseJavaModule {
   public void getTraceHeaderFields(String url, String key, Promise promise) {
     impl.getTraceHeaderFields(url, key, promise);
   }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  public WritableMap getTraceHeaderFieldsSync(String url, String key) {
+    return impl.getTraceHeaderFieldsSync(url, key);
+  }
+
+  @ReactMethod
+  public void cancelWebSocketTrace(String key, Promise promise) {
+    // JS WebSocket observation is iOS-only; Android owns its native lifecycle.
+    promise.resolve(null);
+  }
 }

package/android/src/rnpost70/java/com/ft/sdk/reactnative/ReactJsThreadExecutor.java

@@ -0,0 +1,21 @@
+package com.ft.sdk.reactnative;
+
+import com.facebook.react.bridge.ReactApplicationContext;
+
+final class ReactJsThreadExecutor implements JsLongTaskMonitor.Executor {
+  private final ReactApplicationContext reactContext;
+
+  ReactJsThreadExecutor(ReactApplicationContext reactContext) {
+    this.reactContext = reactContext;
+  }
+
+  @Override
+  public boolean runOnJsThread(Runnable runnable) {
+    try {
+      return reactContext.runOnJSQueueThread(runnable);
+    } catch (AssertionError ignored) {
+      // ReactContext asserts if its JS queue has not been initialized yet.
+      return false;
+    }
+  }
+}