@truewatchtech/react-native-mobile 0.4.1 → 0.4.3-alpha.2

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

@@ -81,23 +81,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) {

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

@@ -85,12 +85,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);
@@ -67,4 +90,9 @@ public class FTRUMModule extends ReactContextBaseJavaModule {
   public void stopResource(String key, ReadableMap map, Promise promise) {
     impl.stopResource(key, map, promise);
   }
+
+  @ReactMethod
+  public void addResource(String key, ReadableMap resource, ReadableMap metrics, Promise promise) {
+    impl.addResource(key, resource, metrics, 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;
+    }
+  }
+}

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

@@ -0,0 +1,37 @@
+package com.ft.sdk.reactnative;
+
+import android.os.Handler;
+import android.os.Looper;
+
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.queue.MessageQueueThread;
+import com.facebook.react.bridge.queue.MessageQueueThreadImpl;
+import com.facebook.react.bridge.queue.ReactQueueConfiguration;
+
+final class ReactJsThreadExecutor implements JsLongTaskMonitor.Executor {
+  private final ReactApplicationContext reactContext;
+
+  ReactJsThreadExecutor(ReactApplicationContext reactContext) {
+    this.reactContext = reactContext;
+  }
+
+  @Override
+  public boolean runOnJsThread(Runnable runnable) {
+    if (!reactContext.hasActiveCatalystInstance()) {
+      return false;
+    }
+    ReactQueueConfiguration configuration =
+      reactContext.getCatalystInstance().getReactQueueConfiguration();
+    if (configuration == null) {
+      return false;
+    }
+    MessageQueueThread queue = configuration.getJSQueueThread();
+    if (!(queue instanceof MessageQueueThreadImpl)) {
+      return false;
+    }
+    Looper looper = ((MessageQueueThreadImpl) queue).getLooper();
+    // Older RN queue APIs return void. Post SDK work to the same JS looper so
+    // a stopped queue can explicitly reject it, without waiting for a callback.
+    return looper != null && new Handler(looper).post(runnable);
+  }
+}

package/android/src/test/java/com/ft/sdk/reactnative/FTRUMModuleTest.java

@@ -0,0 +1,117 @@
+package com.ft.sdk.reactnative;
+
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+
+import org.junit.Test;
+
+import java.lang.reflect.Method;
+
+import static org.junit.Assume.assumeTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+import static org.mockito.Mockito.when;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+public class FTRUMModuleTest {
+  @Test
+  public void bridgeContextUpdatesDoNotStartOrReviveMonitor() {
+    ReactApplicationContext context = mock(ReactApplicationContext.class);
+    // Exercise the real module forwarding separately: only a snapshot is installed.
+    FTRUMModule module = new FTRUMModule(context);
+    assertTrue(module.setLongTaskContext(null));
+    module.invalidate();
+    assertFalse(module.setLongTaskContext(null));
+  }
+  @Test
+  public void shutdownResolvesWhenJSQueueIsUnavailable() {
+    ReactApplicationContext context = mock(ReactApplicationContext.class);
+    FTRUMModule module = new FTRUMModule(context);
+    Promise promise = mock(Promise.class);
+
+    module.stopLongTaskTracking(promise);
+
+    verify(promise, times(1)).resolve(null);
+    verifyNoMoreInteractions(promise);
+  }
+
+  @Test
+  public void shutdownResolvesWhenRNRejectsDispatch() throws Exception {
+    Method dispatch = ReactApplicationContext.class.getMethod("runOnJSQueueThread", Runnable.class);
+    // RN 0.63 has a void API. Reflection keeps this test compilable on both APIs.
+    assumeTrue(dispatch.getReturnType() == boolean.class);
+    ReactApplicationContext context = mock(ReactApplicationContext.class);
+    when(dispatch.invoke(context, any(Runnable.class))).thenReturn(false);
+    FTRUMModule module = new FTRUMModule(context);
+    Promise promise = mock(Promise.class);
+
+    module.stopLongTaskTracking(promise);
+
+    dispatch.invoke(verify(context, times(1)), any(Runnable.class));
+    verify(promise, times(1)).resolve(null);
+    verifyNoMoreInteractions(promise);
+  }
+
+  @Test
+  public void shutdownResolvesWhenRNQueueIsNotInitialized() throws Exception {
+    Method dispatch = ReactApplicationContext.class.getMethod("runOnJSQueueThread", Runnable.class);
+    assumeTrue(dispatch.getReturnType() == boolean.class);
+    ReactApplicationContext context = mock(ReactApplicationContext.class);
+    when(dispatch.invoke(context, any(Runnable.class))).thenThrow(new AssertionError("JS queue is null"));
+    FTRUMModule module = new FTRUMModule(context);
+    Promise promise = mock(Promise.class);
+
+    module.stopLongTaskTracking(promise);
+
+    verify(promise, times(1)).resolve(null);
+    verifyNoMoreInteractions(promise);
+  }
+
+  @Test
+  public void invalidateAndLegacyDestroyShareOneCleanup() {
+    ReactApplicationContext context = mock(ReactApplicationContext.class);
+    FTRUMModule module = new FTRUMModule(context);
+
+    module.invalidate();
+    module.invalidate();
+    module.onCatalystInstanceDestroy();
+
+    verify(context, times(1)).removeLifecycleEventListener(any(FTRUMImpl.class));
+  }
+
+  @Test
+  public void legacyDestroyThenInvalidateAlsoCleansUpOnce() {
+    ReactApplicationContext context = mock(ReactApplicationContext.class);
+    FTRUMModule module = new FTRUMModule(context);
+
+    module.onCatalystInstanceDestroy();
+    module.invalidate();
+
+    verify(context, times(1)).removeLifecycleEventListener(any(FTRUMImpl.class));
+  }
+
+  @Test
+  public void destroyedRUMDoesNotResumeMonitoring() {
+    ReactApplicationContext context = mock(ReactApplicationContext.class);
+    JsLongTaskMonitor.Executor executor = mock(JsLongTaskMonitor.Executor.class);
+    JsLongTaskMonitor monitor = new JsLongTaskMonitor(
+      executor,
+      mock(JsLongTaskMonitor.FrameSchedulerFactory.class),
+      mock(JsLongTaskMonitor.Reporter.class)
+    );
+    FTRUMImpl rum = new FTRUMImpl(context, monitor);
+
+    rum.destroy();
+    rum.destroy();
+    monitor.setThresholdMilliseconds(100);
+    rum.onHostResume();
+
+    verify(context, times(1)).removeLifecycleEventListener(rum);
+    verify(executor, times(1)).runOnJsThread(any(Runnable.class));
+    verifyNoMoreInteractions(executor);
+  }
+}