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

package/FTMobileReactNativeSDK.podspec

@@ -12,15 +12,17 @@ Pod::Spec.new do |s|
   s.authors      = package["author"]
 
   s.platforms    = { :ios => "10.0" }
-  s.source       = { :git => "https://github.com/GuanceCloud/datakit-react-native.git", :tag => "#{s.version}" }
+  s.source       = { :git => "https://github.com/TrueWatchTech/datakit-react-native.git", :tag => "agent_#{s.version}" }
 
 
   s.source_files = "ios/**/*.{h,m,mm,swift}"
+  s.private_header_files = "ios/FTJSLongTaskMonitor.h", "ios/FTWebSocketMetadataStore.h", "ios/FTReactNativeWebSocket.h", "ios/FTReactNativeResource.h", "ios/FTWebSocketResourceData.h"
+  s.frameworks = "CFNetwork"
 
 
   s.dependency "React-Core"
-  s.dependency 'FTMobileSDK', '1.6.2'
-  
+  s.dependency 'TrueWatchSDK', '1.6.7'
+
     xcconfig = {
     "HEADER_SEARCH_PATHS" => "$(inherited) " +
       "$(PODS_ROOT)/React-RCTFabric/** " +
@@ -36,7 +38,7 @@ Pod::Spec.new do |s|
 
   if ENV['RCT_NEW_ARCH_ENABLED'] == '1' then
     s.compiler_flags = folly_compiler_flags + " -DRCT_NEW_ARCH_ENABLED=1"
-    
+
     xcconfig.merge!({
       "DEFINES_MODULE" => "YES",
       "CLANG_CXX_LANGUAGE_STANDARD" => "c++17"
@@ -48,5 +50,5 @@ Pod::Spec.new do |s|
    if respond_to?(:install_modules_dependencies, true)
     install_modules_dependencies(s)
   end
-  
+
 end

package/README.md

@@ -28,6 +28,40 @@ import {
 
 ```
 
+## WebSocket handshake tracking
+
+To collect iOS WebSocket handshakes while native Resource auto-collection is disabled:
+
+```ts
+await FTReactNativeRUM.setConfig({
+  androidAppId: 'YOUR_ANDROID_APP_ID',
+  iOSAppId: 'YOUR_IOS_APP_ID',
+  enableNativeUserResource: false,
+  enableIOSWebSocketResource: true,
+});
+```
+
+`enableIOSWebSocketResource` defaults to `false` and is independent of
+`enableNativeUserResource`. It only affects iOS; Android WebSocket collection
+continues through the native SDK under `enableNativeUserResource`.
+When disabled, new iOS connections are not instrumented or injected with
+WebSocket Trace headers. Handshakes already started can finish normally.
+When enabled, Trace injection additionally requires `enableNativeAutoTrace`.
+Only connections created after tracking starts are observed.
+
+iOS starts JS capture and native setup together, without waiting for a native
+readiness reply. JS measures the handshake and injects Trace headers; the native
+bridge handles Resource reporting and optionally adds a response snapshot.
+Missing socket association keeps the native URL filtering, sampling and privacy
+path. Only older native packages without this bridge use the legacy JS route.
+Connections created before the hooks are installed may have no native snapshot.
+
+iOS handshake tracking reads `error.message` first. When it is absent, the SDK
+can use `close.reason` from the immediately following abnormal close (`1006`),
+before the next microtask. The first error still ends handshake timing; normal
+close reasons are not collected. Native HTTP response snapshots take precedence
+over error-text inference.
+
 ## More
 
 [View Doc Here](https://docs.truewatch.com/real-user-monitoring/react-native/app-access/)

package/android/build.gradle

@@ -94,6 +94,12 @@ android {
       }
 
       if (reactNativeMajorVersion == 0) {
+        if (reactNativeMinorVersion >= 70) {
+          java.srcDirs += ['src/rnpost70/java']
+        } else {
+          java.srcDirs += ['src/rnpre70/java']
+        }
+
         if (reactNativeMinorVersion >= 74) {
           java.srcDirs += ['src/rnpost74/java']
         } else {
@@ -179,11 +185,12 @@ repositories {
 dependencies {
   // noinspection GradleDynamicVersion
   implementation 'com.facebook.react:react-native:+'
-  implementation 'com.truewatch.ft.mobile.sdk.tracker.agent:ft-sdk:1.7.0'
+  implementation 'com.truewatch.ft.mobile.sdk.tracker.agent:ft-sdk:1.7.5'
   implementation 'com.truewatch.ft.mobile.sdk.tracker.agent:ft-native:1.1.2'
-
 //   implementation files('../example/android/app/libs/ft-sdk-debug.aar')
 //    implementation files('../example/android/app/libs/ft-session-replay-debug.aar')
 
   implementation 'com.google.code.gson:gson:2.8.5'
+  testImplementation 'junit:junit:4.13.2'
+  testImplementation 'org.mockito:mockito-core:4.11.0'
 }

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

@@ -271,7 +271,8 @@ public class FTMobileImpl {
             return false;
         }
 
-        if (actual instanceof String actualString) {
+        if (actual instanceof String) {
+            String actualString = (String) actual;
             Object normalizedActual = parseJsonStringIfNeeded(actualString);
             if (normalizedActual != actual) {
                 return isEqualValue(normalizedActual, expected);
@@ -298,18 +299,23 @@ public class FTMobileImpl {
     }
 
     private boolean matchesCustomKey(Object actual, Object expected) {
-        if (expected instanceof Map<?, ?> expectedMap && expectedMap.containsKey("contains")) {
-            return containsValue(actual, expectedMap.get("contains"));
+        if (expected instanceof Map) {
+            Map<?, ?> expectedMap = (Map<?, ?>) expected;
+            if (expectedMap.containsKey("contains")) {
+                return containsValue(actual, expectedMap.get("contains"));
+            }
         }
         return isEqualValue(actual, expected);
     }
 
     private boolean containsValue(Object actual, Object expectedValue) {
-        Object normalizedActual = actual instanceof String actualString
-            ? parseJsonStringIfNeeded(actualString)
-            : actual;
+        Object normalizedActual = actual;
+        if (actual instanceof String) {
+            normalizedActual = parseJsonStringIfNeeded((String) actual);
+        }
 
-        if (normalizedActual instanceof JSONArray actualArray) {
+        if (normalizedActual instanceof JSONArray) {
+            JSONArray actualArray = (JSONArray) normalizedActual;
             try {
                 for (int i = 0; i < actualArray.length(); i++) {
                     if (isEqualValue(actualArray.get(i), expectedValue)) {
@@ -338,6 +344,29 @@ public class FTMobileImpl {
         return value;
     }
 
+    @Nullable
+    private HashMap<String, String[]> convertDataFilters(@Nullable Map<String, Object> filters) {
+        if (filters == null) {
+            return null;
+        }
+        HashMap<String, String[]> convertedFilters = new HashMap<>();
+        for (Map.Entry<String, Object> entry : filters.entrySet()) {
+            Object value = entry.getValue();
+            if (!(value instanceof List<?>)) {
+                continue;
+            }
+            List<?> filterList = (List<?>) value;
+            List<String> filterValues = new ArrayList<>();
+            for (Object filter : filterList) {
+                if (filter != null) {
+                    filterValues.add(filter.toString());
+                }
+            }
+            convertedFilters.put(entry.getKey(), filterValues.toArray(new String[0]));
+        }
+        return convertedFilters;
+    }
+
     public void sdkConfig(ReadableMap context, Promise promise) {
         Map<String, Object> map = context.toHashMap();
         String datakitUrl = (String) map.get("datakitUrl");
@@ -349,6 +378,8 @@ public class FTMobileImpl {
         Integer syncSleepTime = ReactNativeUtils.convertToNativeInt(map.get("syncSleepTime"));
         Boolean enableDataIntegerCompatible = (Boolean) map.get("enableDataIntegerCompatible");
         Boolean compressIntakeRequests = (Boolean) map.get("compressIntakeRequests");
+        Boolean enableDataFilter = (Boolean) map.get("enableDataFilter");
+        Map<String, Object> dataFilters = (Map<String, Object>) map.get("dataFilters");
         Integer env = ReactNativeUtils.convertToNativeInt(map.get("envType"));
         String serviceName = (String) map.get("service");
         Map<String, Object> globalContext = (Map<String, Object>) map.get("globalContext");
@@ -404,6 +435,13 @@ public class FTMobileImpl {
         if (compressIntakeRequests != null && compressIntakeRequests) {
             sdkConfig.setCompressIntakeRequests(compressIntakeRequests);
         }
+        if (enableDataFilter != null) {
+            sdkConfig.setEnableDataFilter(enableDataFilter);
+        }
+        HashMap<String, String[]> convertedDataFilters = convertDataFilters(dataFilters);
+        if (convertedDataFilters != null) {
+            sdkConfig.setDataFilters(convertedDataFilters);
+        }
         if (globalContext != null) {
             for (Map.Entry<String, Object> entry : globalContext.entrySet()) {
                 sdkConfig.addGlobalContext(entry.getKey(), entry.getValue().toString());
@@ -617,11 +655,4 @@ public class FTMobileImpl {
         });
     }
 
-    public void addListener(String eventName) {
-        // Required for NativeEventEmitter. No-op because native does not need listener bookkeeping.
-    }
-
-    public void removeListeners(double count) {
-        // Required for NativeEventEmitter. No-op because native does not need listener bookkeeping.
-    }
 }

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

@@ -2,8 +2,11 @@ package com.ft.sdk.reactnative;
 
 import com.ft.sdk.reactnative.BuildConfig;
 import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.LifecycleEventListener;
+import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.bridge.ReactMethod;
 import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.common.LifecycleState;
 import com.ft.sdk.DetectFrequency;
 import com.ft.sdk.FTInTakeUrlHandler;
 import com.ft.sdk.FTRUMConfig;
@@ -18,11 +21,28 @@ import com.ft.sdk.reactnative.utils.ReactNativeUtils;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.Map;
+import java.util.concurrent.atomic.AtomicBoolean;
 
-public class FTRUMImpl {
+public class FTRUMImpl implements LifecycleEventListener {
 
   private static final String DEFAULT_ERROR_TYPE = "reactnative_crash";
   public static final String NAME = "FTReactNativeRUM";
+  private final ReactApplicationContext reactContext;
+  private final JsLongTaskMonitor jsLongTaskMonitor;
+  private final AtomicBoolean destroyed = new AtomicBoolean();
+
+  public FTRUMImpl(ReactApplicationContext reactContext) {
+    this(reactContext, JsLongTaskMonitor.create(reactContext));
+  }
+
+  FTRUMImpl(
+    ReactApplicationContext reactContext,
+    JsLongTaskMonitor jsLongTaskMonitor
+  ) {
+    this.reactContext = reactContext;
+    this.jsLongTaskMonitor = jsLongTaskMonitor;
+    reactContext.addLifecycleEventListener(this);
+  }
 
   @ReactMethod
   public void setConfig(ReadableMap context, Promise promise) {
@@ -39,6 +59,8 @@ public class FTRUMImpl {
     Boolean enableTrackNativeAppANR = (Boolean) map.get("enableTrackNativeAppANR");
     Boolean enableTrackNativeFreeze = (Boolean) map.get("enableTrackNativeFreeze");
     Double nativeFreezeDurationMs = (Double) map.get("nativeFreezeDurationMs");
+    Boolean enableLongTask = (Boolean) map.get("enableLongTask");
+    Double longTaskThresholdMs = (Double) map.get("longTaskThresholdMs");
     Integer monitorType = ReactNativeUtils.convertToNativeInt(map.get("errorMonitorType"));
     Integer deviceMonitorType = ReactNativeUtils.convertToNativeInt(map.get("deviceMonitorType"));
     Integer detectFrequency = ReactNativeUtils.convertToNativeInt(map.get("detectFrequency"));
@@ -131,14 +153,75 @@ public class FTRUMImpl {
     if (allowWebViewHost != null) {
       String[] allowWebViewHostArr = new String[allowWebViewHost.size()];
       allowWebViewHost.toArray(allowWebViewHostArr);
-      rumConfig.setAllowWebViewHost(allowWebViewHostArr);
+      FTSdk ftSdk = FTSdk.get();
+      if (ftSdk != null) {
+        ftSdk.getBaseConfig().setAllowWebViewHost(allowWebViewHostArr);
+      }
     }
 
     FTSdk.initRUMWithConfig(rumConfig);
+    double configuredThresholdMilliseconds = longTaskThresholdMs != null
+      ? longTaskThresholdMs
+      : 100;
+    double thresholdMilliseconds = Boolean.TRUE.equals(enableLongTask)
+      ? configuredThresholdMilliseconds
+      : 0;
+    jsLongTaskMonitor.setThresholdMilliseconds(thresholdMilliseconds);
+    if (
+      thresholdMilliseconds > 0 &&
+      reactContext.getLifecycleState() == LifecycleState.RESUMED
+    ) {
+      jsLongTaskMonitor.start();
+    } else {
+      jsLongTaskMonitor.stop();
+    }
     //LogUtils.d("configCheck","rumConfig:"+new Gson().toJson(rumConfig));
     promise.resolve(null);
   }
 
+  @ReactMethod
+  public void stopLongTaskTracking(final Promise promise) {
+    jsLongTaskMonitor.disable(new Runnable() {
+      @Override
+      public void run() {
+        promise.resolve(null);
+      }
+    });
+  }
+
+  public boolean setLongTaskContext(ReadableMap context) {
+    if (destroyed.get()) {
+      return false;
+    }
+    jsLongTaskMonitor.setBridgeContext(context == null ? null : context.toHashMap());
+    return true;
+  }
+
+  public void destroy() {
+    if (!destroyed.compareAndSet(false, true)) {
+      return;
+    }
+    reactContext.removeLifecycleEventListener(this);
+    jsLongTaskMonitor.disable(null);
+  }
+
+  @Override
+  public void onHostResume() {
+    if (!destroyed.get()) {
+      jsLongTaskMonitor.start();
+    }
+  }
+
+  @Override
+  public void onHostPause() {
+    jsLongTaskMonitor.stop();
+  }
+
+  @Override
+  public void onHostDestroy() {
+    jsLongTaskMonitor.stop();
+  }
+
   @ReactMethod
   public void startAction(String actionName, String actionType, ReadableMap map, Promise promise) {
     if (map != null) {

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

@@ -71,6 +71,10 @@ public class FTTraceImpl {
 
   @ReactMethod
   public void getTraceHeaderFields(String url, String key, Promise promise) {
+    promise.resolve(getTraceHeaderFieldsSync(url, key));
+  }
+
+  public WritableNativeMap getTraceHeaderFieldsSync(String url, String key) {
     HashMap<String, String> hashMap = null;
     if (key == null) {
       hashMap = FTTraceManager.get().getTraceHeader(url);
@@ -84,6 +88,6 @@ public class FTTraceImpl {
         map.putString(entry.getKey(), entry.getValue());
       }
     }
-    promise.resolve(map);
+    return map;
   }
 }

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/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();
     }
 }