react-native-acoustic-connect 16.0.39 → 19.0.3

package/src/TLTRN.ts

@@ -0,0 +1,382 @@
+/********************************************************************************************
+* Copyright (C) 2025 Acoustic, L.P. All rights reserved.
+*
+* NOTICE: This file contains material that is confidential and proprietary to
+* Acoustic, L.P. and/or other developers. No license is granted under any intellectual or
+* industrial property rights of Acoustic, L.P. except as may be provided in an agreement with
+* Acoustic, L.P. Any unauthorized copying or distribution of content from this file is
+* prohibited.
+********************************************************************************************/
+
+// @ts-ignore
+import MessageQueue from "react-native/Libraries/BatchedBridge/MessageQueue.js";
+import { Platform } from "react-native";
+import KeyboardListener from "./utils/KeyboardListener";
+import DialogListener from "./utils/DialogListener";
+import type { DialogEvent, DialogButtonClickEvent, DialogDismissEvent } from "./utils/DialogListener";
+import AcousticConnectRN from './index'; 
+
+// Preserve any previously-installed handler (e.g. React Native's red-box
+// handler) so we augment rather than replace it.
+// @ts-ignore
+const previousGlobalErrorHandler = global.ErrorUtils?.getGlobalHandler?.();
+
+// @ts-ignore
+global.ErrorUtils?.setGlobalHandler?.((e: any, isFatal: boolean) => {
+  // A global error handler must never throw — otherwise it masks the ORIGINAL
+  // error. `AcousticConnectRN` can be undefined here (e.g. the native module
+  // failed to load, or during the module-load circular import), so guard the
+  // call and always forward to the previous handler so the real error still
+  // surfaces and fatals still crash.
+  try {
+    AcousticConnectRN?.logExceptionEvent?.(
+        JSON.stringify(e),
+        JSON.stringify(e),
+        true
+    );
+  } catch (loggingError: Error | any) {
+    console.warn('TLTRN: failed to log uncaught exception:', loggingError?.message);
+  } finally {
+    previousGlobalErrorHandler?.(e, isFatal);
+  }
+});
+
+class TLTRN {
+  static currentScreen =
+    "***initialCurrentScreen not set in ConnectLogger constructor***";
+  static lastJSBridgeMessageTime = 0;
+  static totalRenderTime = 0;
+  static messageRenderTime = 0;
+  static countMsgs = 0;
+  static messageConsole = 0;
+  static lastMessageConsole = 0;
+  static isLoggingData = 0;
+  static displayDebug = false;
+
+  static myTimer = {
+    handle: null as NodeJS.Timeout | null,
+    started: 0,
+    time: 1000,
+    /**
+     * @type Class
+     */
+    startTimer: function () {
+      this.started = 1;
+      this.handle = setInterval(TLTRN.checkTime, this.time);
+    },
+    /**
+     * @type Class
+     */
+    stopTimer: function () {
+      if (this.handle) {
+        clearInterval(this.handle);
+        this.handle = null;
+        this.started = 0;
+      }
+    },
+  };
+  
+  static init = (initialCurrentScreen: String, showDebugConsoleMessages: boolean) => {
+    TLTRN.currentScreen =
+      initialCurrentScreen === undefined
+        // @ts-ignore:
+        ? currentScreenMsg
+        : initialCurrentScreen;
+    MessageQueue.spy(TLTRN.listenToBridge);
+    TLTRN.displayDebug = showDebugConsoleMessages === undefined ? false : showDebugConsoleMessages;
+  };
+
+  static interceptKeyboardEvents = (enable: boolean) => {
+    keyListener.interceptKeyboardEvents(enable);
+  };
+
+  static logScreenViewPageName = (name: string | undefined) => {
+    let result = false
+    try {
+      result = AcousticConnectRN.setCurrentScreenName(name || '');
+    } catch (error: Error | any) {  
+      console.log('LogScreenViewPageName error: ', error.message);
+    }
+    return result;
+  };
+
+  static logScreenViewContextLoad = (name: string, prevName: string) => {
+    let result = false
+    try {
+      result = AcousticConnectRN.logScreenViewContextLoad(name, prevName);
+    } catch (error: Error | any) {
+      console.log('LogScreenViewContextLoad error: ', error.message);
+    }
+    return result;
+  };
+
+  static logScreenLayout = (name: string | undefined) => {
+    TLTRN.currentScreen = name || '';
+    let result = false
+    try {
+      result = AcousticConnectRN.logScreenLayout(TLTRN.currentScreen, 0);
+    } catch (error: Error | any) {
+      console.log('LogScreenLayout error: ', error.message);
+    }
+    return result;
+  };
+
+  static logClickEvent = async (event: any) => {
+    let result = false
+
+    // Fabric exposes the host tag as `__nativeTag` (double underscore).
+    // Paper used `_nativeTag` (single). Read both for safety.
+    const target = event?.target?.__nativeTag ?? event?.target?._nativeTag;
+    if (target == null) {
+      return result;
+    }
+
+    // controlId comes from the touched view's `id` prop. Fiber internals can
+    // vary across React versions, so guard each access.
+    let controlId = '';
+    try {
+      const fiberId = event?._targetInst?.memoizedProps?.id;
+      if (typeof fiberId === 'string' && fiberId.length > 0) {
+        controlId = fiberId;
+      } else if (Array.isArray(event?._dispatchInstances)) {
+        const found = event._dispatchInstances.find(
+          (node: any) => node?.memoizedProps?.id
+        );
+        if (found) controlId = found.memoizedProps.id;
+      }
+    } catch {}
+
+    try {
+      result = AcousticConnectRN.logClickEvent(target, controlId);
+    } catch (error: Error | any) {
+      console.log('LogClickEvent error: ', error.message);
+    }
+    return result;
+  };
+
+  static logTextChangeEvent = async (target: number, controlId: string, text: string, _ariaLabel: string) => {
+    let result = false
+    try {
+        if (Platform.OS === 'ios') {
+          result = AcousticConnectRN.logTextChangeEvent(target, controlId, text);
+        } else if (Platform.OS === 'android') {
+          AcousticConnectRN.logTextChangeEvent(target, controlId, text);
+        }
+    } catch (error: Error | any) {
+      console.log('LogTextChangeEvent error: ', error.message);
+    }
+    return result;
+  };
+  
+  static logCustomEvent = async (eventName: string, values: Record<string, string | number | boolean>, level: number) => {
+    let result = false
+    try {
+      result = AcousticConnectRN.logCustomEvent(eventName, values, level);
+    } catch (error: Error | any) {
+      console.log('LogCustomEvent error: ', error.message);
+    }
+    return result;
+  };
+
+  // New dialog event logging methods
+  static logDialogShowEvent = async (dialogId: string, dialogTitle: string, dialogType: string) => {
+    let result = false
+    try {
+      result = AcousticConnectRN.logDialogShowEvent(dialogId, dialogTitle, dialogType);
+    } catch (error: Error | any) {
+      console.log('LogDialogShowEvent error: ', error.message);
+    }
+    return result;
+  };
+
+  static logDialogDismissEvent = async (dialogId: string, dismissReason: string) => {
+    let result = false
+    try {
+      result = AcousticConnectRN.logDialogDismissEvent(dialogId, dismissReason);
+    } catch (error: Error | any) {
+      console.log('LogDialogDismissEvent error: ', error.message);
+    }
+    return result;
+  };
+
+  static logDialogButtonClickEvent = async (dialogId: string, buttonText: string, buttonIndex: number) => {
+    let result = false
+    try {
+      result = AcousticConnectRN.logDialogButtonClickEvent(dialogId, buttonText, buttonIndex);
+    } catch (error: Error | any) {
+      console.log('LogDialogButtonClickEvent error: ', error.message);
+    }
+    return result;
+  };
+
+  static logDialogCustomEvent = async (dialogId: string, eventName: string, values: Record<string, string | number | boolean>) => {
+    let result = false
+    try {
+      result = AcousticConnectRN.logDialogCustomEvent(dialogId, eventName, values);
+    } catch (error: Error | any) {
+      console.log('LogDialogCustomEvent error: ', error.message);
+    }
+    return result;
+  };
+
+  // Dialog event interceptor methods
+  static eventListenerRegistered = false;
+  static eventListenerUnsubscribe: (() => void) | null = null;
+  
+  static interceptDialogEvents = (enable: boolean) => {
+    const dialogListener = DialogListener.getInstance();
+    
+    if (enable && !TLTRN.eventListenerRegistered) {
+      dialogListener.startIntercepting();
+      TLTRN.eventListenerUnsubscribe = dialogListener.addEventListener((event: DialogEvent | DialogButtonClickEvent | DialogDismissEvent) => {
+        if ('buttonText' in event) {
+          // This is a button click event
+          TLTRN.logDialogButtonClickEvent(event.dialogId, event.buttonText, event.buttonIndex);
+        } else if ('dismissReason' in event) {
+          // This is a dialog dismiss event
+          TLTRN.logDialogDismissEvent(event.dialogId, event.dismissReason);
+        } else {
+          // This is a dialog show event
+          TLTRN.logDialogShowEvent(event.dialogId, event.dialogTitle, event.dialogType);
+        }
+      });
+      TLTRN.eventListenerRegistered = true;
+    } else if (!enable && TLTRN.eventListenerRegistered) {
+      dialogListener.stopIntercepting();
+      if (TLTRN.eventListenerUnsubscribe) {
+        TLTRN.eventListenerUnsubscribe();
+        TLTRN.eventListenerUnsubscribe = null;
+      }
+      TLTRN.eventListenerRegistered = false;
+    }
+  };
+
+  static listenToBridge = (message: any) => {
+    if (TLTRN.displayDebug) {
+      console.log(
+        "&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&:isLoggingData:" +
+          TLTRN.isLoggingData
+      );
+    }
+    if (TLTRN.isLoggingData == 1) {
+      return;
+    }
+
+    var now = new Date().getTime();
+    if (TLTRN.lastJSBridgeMessageTime === 0) {
+      TLTRN.lastJSBridgeMessageTime = now;
+    }
+
+    if (TLTRN.messageConsole > 0) {
+      TLTRN.lastMessageConsole = TLTRN.messageConsole;
+    }
+    TLTRN.messageConsole = now;
+    TLTRN.countMsgs++;
+
+    if (TLTRN.myTimer.started === 0) {
+      TLTRN.myTimer.startTimer();
+    }
+
+    TLTRN.messageRenderTime = now - TLTRN.lastJSBridgeMessageTime;
+    TLTRN.totalRenderTime = TLTRN.totalRenderTime + TLTRN.messageRenderTime;
+    if (TLTRN.displayDebug) {
+      console.log(
+        "*after:countMsgs: " +
+          TLTRN.countMsgs +
+          ":tTotal:" +
+          TLTRN.totalRenderTime +
+          ":messageDuration:" +
+          TLTRN.messageRenderTime
+      );
+    }
+    TLTRN.lastJSBridgeMessageTime = now;
+
+    const from = message.type === 0 ? "N->JS" : "JS->N";
+    const data =
+      from +
+      " : " +
+      message.module +
+      "." +
+      message.method +
+      "(" +
+      JSON.stringify(message.args) +
+      ")";
+
+    if (TLTRN.displayDebug) {
+      if (message.module !== "UIManager") {
+        console.log("Message", message);
+      }
+      console.log("Message data:", data);
+    }
+
+    if (message.module === "ExceptionsManager") {
+      try {
+        AcousticConnectRN?.logExceptionEvent?.(
+          message.args[0],
+          JSON.stringify(message.args[1]),
+          true
+        );
+      } catch (error: Error | any) {
+        console.log('logExceptionEvent (bridge) error: ', error?.message);
+      }
+    }
+  };
+
+  static checkTime = () => {
+    var now = new Date().getTime();
+    if (TLTRN.displayDebug) {
+      console.log(
+        "======>Done compare total:" +
+          TLTRN.totalRenderTime +
+          " :lastMessageConsole:" +
+          TLTRN.lastMessageConsole +
+          ":now:" +
+          now +
+          ":diff:" +
+          (now - TLTRN.lastMessageConsole) +
+          ":" +
+          (now - TLTRN.lastMessageConsole > 50)
+      );
+    }
+    if (TLTRN.lastMessageConsole == 0) {
+      return;
+    }
+
+    if (now - TLTRN.lastMessageConsole > 20) {
+      if (TLTRN.displayDebug) {
+        console.log("======>Done capture:" + new Date().getTime());
+      }
+      TLTRN.messageConsole = 0;
+      TLTRN.lastMessageConsole = 0;
+      TLTRN.myTimer.stopTimer();
+      this.logTeal();
+    }
+  };
+
+  static logTeal = async () => {
+    try {
+      TLTRN.isLoggingData = 1;
+      var res = await AcousticConnectRN.logScreenLayout(TLTRN.currentScreen, -1);
+      var dict = { ReactLayoutTime: TLTRN.totalRenderTime };
+      var result = await AcousticConnectRN.logCustomEvent("ReactPlugin", dict, 1);
+      if (TLTRN.displayDebug) {
+        console.log(
+          "======>logTeal:" +
+            TLTRN.currentScreen +
+            ":" +
+            res +
+            ":time:" +
+            TLTRN.totalRenderTime
+        );
+      }
+      TLTRN.isLoggingData = 0;
+      TLTRN.lastJSBridgeMessageTime = 0;
+      TLTRN.totalRenderTime = 0;
+    } catch (e) {
+      console.error(e);
+    }
+  };
+}
+const keyListener = KeyboardListener._instance(TLTRN);
+
+export default TLTRN;

package/src/components/Connect.tsx

@@ -0,0 +1,208 @@
+/********************************************************************************************
+* Copyright (C) 2025 Acoustic, L.P. All rights reserved.
+*
+* NOTICE: This file contains material that is confidential and proprietary to
+* Acoustic, L.P. and/or other developers. No license is granted under any intellectual or
+* industrial property rights of Acoustic, L.P. except as may be provided in an agreement with
+* Acoustic, L.P. Any unauthorized copying or distribution of content from this file is
+* prohibited.
+********************************************************************************************/
+import React, { useCallback, useEffect, useRef, useState } from "react";
+import { View, StyleSheet, Platform } from "react-native";
+import type { LayoutChangeEvent } from "react-native"; // Use type-only import for LayoutChangeEvent
+import TLTRN from '../TLTRN';
+
+interface ConnectProps {
+    children: React.ReactNode;
+    captureKeyboardEvents: boolean;
+    captureDialogEvents?: boolean; // New prop for dialog event capture
+    /**
+     * Preferred: an explicit NavigationContainer ref obtained from
+     * `useNavigationContainerRef()`. Using this prop decouples <Connect> from
+     * any assumption about the children structure and is the recommended
+     * integration path.
+     *
+     * If omitted, <Connect> falls back to (a) inspecting the direct child's
+     * own ref, then (b) auto-injecting an internal ref via cloneElement.
+     * Every path degrades gracefully — if no usable ref is resolved,
+     * screen-name tracking is disabled but touches still reach host components.
+     */
+    navigationRef?: React.RefObject<any>;
+}
+
+const Connect: React.FC<ConnectProps> = ({
+    children,
+    captureKeyboardEvents,
+    captureDialogEvents = false,
+    navigationRef,
+}) => {
+    const child = children as any;
+    // React 19 moved the ref off `element.ref` onto `element.props.ref`.
+    // Read `props.ref` first; the legacy `child.ref` fallback is a defensive
+    // guard from the React 18 era — kept to avoid a behavioural change.
+    const childProvidedRef = child?.props?.ref ?? child?.ref;
+    const internalRef = useRef<any>(null);
+
+    // Resolution order (explicit → legacy child ref → auto-injected fallback).
+    // The chosen ref flows through the same mount-effect / touch / layout
+    // guards, so any path that fails to resolve a usable navigation container
+    // simply disables tracking rather than breaking host-app gestures.
+    const navigation = navigationRef ?? childProvidedRef ?? internalRef;
+    const shouldInjectRef =
+        !navigationRef && !childProvidedRef && React.isValidElement(child);
+
+    const currentRoute = useRef<string | undefined>(undefined);
+    const initial = useRef<boolean>(false);
+    // Tracks whether the resolved navigation ref has actually attached. See the
+    // readiness effect below for why a one-shot mount check is insufficient.
+    const [navReady, setNavReady] = useState<boolean>(false);
+
+    useEffect(() => {
+        TLTRN.interceptKeyboardEvents(captureKeyboardEvents);
+    }, [captureKeyboardEvents]);
+
+    useEffect(() => {
+        TLTRN.interceptDialogEvents(captureDialogEvents);
+    }, [captureDialogEvents]);
+
+    // Wait for the NavigationContainer ref to actually attach before declaring
+    // it usable. When <Connect> wraps the container indirectly — intermediate
+    // providers (AppProvider, SafeAreaProvider, …), or any provider that defers
+    // rendering its subtree (async init, splash gate) — the container mounts
+    // AFTER <Connect>'s effects run, so `navigation.current` is still null at
+    // first paint. A one-shot mount check would warn and permanently disable
+    // tracking, because the effect's only dependency is the stable ref object
+    // and `.current` mutations don't retrigger effects. So we poll until the
+    // ref is usable, then flip `navReady` to subscribe. The direct-child case
+    // resolves on the first synchronous check (no polling, no warning). If the
+    // ref never attaches within the grace window we warn once, as before.
+    // See CA-144314.
+    useEffect(() => {
+        // Reset readiness whenever the resolved ref changes. Without this, a
+        // `navigationRef` prop swap leaves `navReady` stale-true, so the
+        // subscription effect below re-runs and attaches `addListener` to the
+        // old container (whose `.current` is still non-null mid-transition)
+        // before the new ref is validated. Resetting forces re-validation
+        // through `isUsable()` before tracking re-enables. See CA-144314.
+        setNavReady(false);
+
+        const isUsable = () =>
+            !!navigation &&
+            !!navigation.current &&
+            typeof navigation.current.addListener === "function" &&
+            typeof navigation.current.getCurrentRoute === "function";
+
+        if (isUsable()) {
+            setNavReady(true);
+            return;
+        }
+
+        let attempts = 0;
+        const POLL_INTERVAL_MS = 100;
+        const MAX_ATTEMPTS = 100; // ~10s grace for deferred/async provider init
+        let timer: ReturnType<typeof setTimeout> | undefined;
+
+        const poll = () => {
+            if (isUsable()) {
+                setNavReady(true);
+                return;
+            }
+            if (attempts++ >= MAX_ATTEMPTS) {
+                console.warn(
+                    "Connect: navigation tracking disabled — no usable NavigationContainer ref resolved. " +
+                    "Pass `navigationRef` (from useNavigationContainerRef()) or ensure a NavigationContainer is rendered under <Connect>."
+                );
+                return;
+            }
+            timer = setTimeout(poll, POLL_INTERVAL_MS);
+        };
+        timer = setTimeout(poll, POLL_INTERVAL_MS);
+
+        return () => {
+            if (timer) {
+                clearTimeout(timer);
+            }
+        };
+    }, [navigation]);
+
+    useEffect(() => {
+        if (!navReady || !navigation?.current) {
+            return;
+        }
+
+        // Listen for the 'state' event to track navigation state changes
+        const unsubscribeState = navigation.current.addListener("state", () => {
+            currentRoute.current = extractName(navigation) || navigation.current.getCurrentRoute()?.name;
+
+            if (Platform.OS === "ios" && currentRoute && currentRoute.current) {
+                TLTRN.logScreenViewPageName(currentRoute.current);
+            } else if (Platform.OS === "android") {
+                TLTRN.logScreenViewPageName(currentRoute.current);
+                TLTRN.logScreenLayout(currentRoute.current);
+            }
+        });
+
+        // Cleanup listeners when the component unmounts or dependencies change
+        return () => {
+            unsubscribeState();
+        };
+    }, [navReady, navigation]);
+
+    const onStartShouldSetResponderCapture = useCallback((event: any) => {
+        if (navigation?.current?.getCurrentRoute) {
+            currentRoute.current =
+                extractName(navigation) || navigation.current.getCurrentRoute()?.name;
+            if (currentRoute.current) {
+                TLTRN.logScreenViewPageName(currentRoute.current);
+            }
+        }
+        TLTRN.logClickEvent(event);
+        return false; // Must remain false so events bubble to the host app's handlers
+    }, [navigation]);
+
+    const onLayout = useCallback((_event: LayoutChangeEvent) => {
+        if (initial.current) {
+            return false;
+        }
+        initial.current = true;
+
+        if (navigation?.current?.getCurrentRoute) {
+            currentRoute.current = navigation.current.getCurrentRoute()?.name;
+            if (Platform.OS === "ios" && currentRoute.current) {
+                TLTRN.logScreenViewPageName(currentRoute.current);
+            } else if (Platform.OS === "android") {
+                TLTRN.logScreenLayout(currentRoute.current);
+            }
+        }
+        return true;
+    }, [navigation]);
+
+    return (
+        <View
+            style={styles.connect_main}
+            onLayout={onLayout}
+            onStartShouldSetResponderCapture={onStartShouldSetResponderCapture}
+        >
+            {shouldInjectRef
+                ? React.cloneElement(child as React.ReactElement<any>, { ref: internalRef })
+                : children}
+        </View>
+    );
+};
+
+function extractName(navigation: any): string {
+    const routeParams = navigation?.current?.getCurrentRoute?.()?.params;
+    if (routeParams) {
+        const { name } = routeParams;
+        return name ? name : navigation.current?.getCurrentRoute()?.name || "";
+    }
+    return "";
+}
+
+export default Connect;
+
+const styles = StyleSheet.create({
+    connect_main: {
+        flex: 1,
+    },
+});

package/src/components/ConnectProfiler.ts

@@ -0,0 +1,43 @@
+/********************************************************************************************
+* Copyright (C) 2025 Acoustic, L.P. All rights reserved.
+*
+* NOTICE: This file contains material that is confidential and proprietary to
+* Acoustic, L.P. and/or other developers. No license is granted under any intellectual or
+* industrial property rights of Acoustic, L.P. except as may be provided in an agreement with
+* Acoustic, L.P. Any unauthorized copying or distribution of content from this file is
+* prohibited.
+********************************************************************************************/
+
+import React, { Component } from "react";
+import TLTRN from "../TLTRN";
+
+interface ConnectProfilerProps {
+  profileName?: string; // Optional property
+  children?: React.ReactNode; // For rendering child components
+}
+
+class ConnectProfiler extends Component<ConnectProfilerProps> {
+  startTime = 0;
+  endTime = 0;
+
+  constructor(props: ConnectProfilerProps) {
+    super(props);
+    this.startTime = new Date().getTime();
+  }
+
+  componentDidMount() {
+    this.endTime = new Date().getTime();
+    const pageLoadTime = this.endTime - this.startTime;
+    const { profileName } = this.props;
+
+    if (profileName) {
+      TLTRN.logCustomEvent("Load Time", { profileName, pageLoadTime }, 1);
+    }
+  }
+
+  render() {
+    return this.props.children;
+  }
+}
+
+export default ConnectProfiler;