react-native-acoustic-connect-beta 18.0.13 → 18.0.15

package/src/utils/DialogDebugger.ts

@@ -0,0 +1,224 @@
+/********************************************************************************************
+* 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 { Alert } from 'react-native';
+import DialogListener from './DialogListener';
+import TLTRN from '../TLTRN';
+
+/**
+ * Debug utility for dialog event tracking
+ * Helps identify issues with dialog event interception and logging
+ */
+export class DialogDebugger {
+    private static instance: DialogDebugger;
+    private isEnabled: boolean = false;
+    private originalAlert: typeof Alert.alert;
+
+    private constructor() {
+        this.originalAlert = Alert.alert;
+    }
+
+    static getInstance(): DialogDebugger {
+        if (!DialogDebugger.instance) {
+            DialogDebugger.instance = new DialogDebugger();
+        }
+        return DialogDebugger.instance;
+    }
+
+    /**
+     * Enable debug mode
+     */
+    enable(): void {
+        this.isEnabled = true;
+        console.log('🔍 DialogDebugger: Debug mode enabled');
+    }
+
+    /**
+     * Disable debug mode
+     */
+    disable(): void {
+        this.isEnabled = false;
+        console.log('🔍 DialogDebugger: Debug mode disabled');
+    }
+
+    /**
+     * Test the complete dialog event flow
+     */
+    testDialogEventFlow(): void {
+        console.log('🔍 DialogDebugger: Testing dialog event flow...');
+        
+        // Test 1: Check if DialogListener is working
+        this.testDialogListener();
+        
+        // Test 2: Check if TLTRN methods are accessible
+        this.testTLTRNMethods();
+        
+        // Test 3: Check if Alert.alert override is working
+        this.testAlertOverride();
+        
+        // Test 4: Test native method calls
+        this.testNativeMethods();
+    }
+
+    /**
+     * Test DialogListener functionality
+     */
+    private testDialogListener(): void {
+        console.log('🔍 DialogDebugger: Testing DialogListener...');
+        
+        try {
+            const dialogListener = DialogListener.getInstance();
+            console.log('✅ DialogListener.getInstance() - SUCCESS');
+            
+            // Test event listener
+            const unsubscribe = dialogListener.addEventListener((event) => {
+                console.log('🔍 DialogDebugger: DialogListener event received:', event);
+            });
+            console.log('✅ DialogListener.addEventListener() - SUCCESS');
+            
+            // Test manual tracking
+            dialogListener.trackCustomDialogShow('test-dialog-id', 'Test Dialog', []);
+            console.log('✅ DialogListener.trackCustomDialogShow() - SUCCESS');
+            
+            unsubscribe();
+        } catch (error) {
+            console.error('❌ DialogDebugger: DialogListener test failed:', error);
+        }
+    }
+
+    /**
+     * Test TLTRN methods
+     */
+    private testTLTRNMethods(): void {
+        console.log('🔍 DialogDebugger: Testing TLTRN methods...');
+        
+        try {
+            // Test if TLTRN methods exist
+            if (typeof TLTRN.logDialogShowEvent === 'function') {
+                console.log('✅ TLTRN.logDialogShowEvent - EXISTS');
+            } else {
+                console.error('❌ TLTRN.logDialogShowEvent - NOT FOUND');
+            }
+            
+            if (typeof TLTRN.interceptDialogEvents === 'function') {
+                console.log('✅ TLTRN.interceptDialogEvents - EXISTS');
+            } else {
+                console.error('❌ TLTRN.interceptDialogEvents - NOT FOUND');
+            }
+            
+            // Test method call
+            TLTRN.logDialogShowEvent('test-dialog-id', 'Test Dialog', 'test');
+            console.log('✅ TLTRN.logDialogShowEvent() - CALLED');
+            
+        } catch (error) {
+            console.error('❌ DialogDebugger: TLTRN test failed:', error);
+        }
+    }
+
+    /**
+     * Test Alert.alert override
+     */
+    private testAlertOverride(): void {
+        console.log('🔍 DialogDebugger: Testing Alert.alert override...');
+        
+        try {
+            // Check if Alert.alert is overridden
+            if (Alert.alert !== this.originalAlert) {
+                console.log('✅ Alert.alert is overridden');
+            } else {
+                console.error('❌ Alert.alert is NOT overridden');
+            }
+            
+            // Test Alert.alert call
+            Alert.alert('Debug Test', 'This is a test alert', [
+                { text: 'OK', onPress: () => console.log('🔍 DialogDebugger: Alert OK pressed') }
+            ]);
+            console.log('✅ Alert.alert() - CALLED');
+            
+        } catch (error) {
+            console.error('❌ DialogDebugger: Alert.alert test failed:', error);
+        }
+    }
+
+    /**
+     * Test native method calls
+     */
+    private testNativeMethods(): void {
+        console.log('🔍 DialogDebugger: Testing native method calls...');
+        
+        try {
+            // Import AcousticConnectRN to test native calls
+            const AcousticConnectRN = require('../index').default;
+            
+            if (AcousticConnectRN && typeof AcousticConnectRN.logDialogShowEvent === 'function') {
+                console.log('✅ AcousticConnectRN.logDialogShowEvent - EXISTS');
+                
+                // Test native call
+                const result = AcousticConnectRN.logDialogShowEvent('test-dialog-id', 'Test Dialog', 'test');
+                console.log('✅ AcousticConnectRN.logDialogShowEvent() - CALLED, result:', result);
+            } else {
+                console.error('❌ AcousticConnectRN.logDialogShowEvent - NOT FOUND');
+            }
+            
+        } catch (error) {
+            console.error('❌ DialogDebugger: Native method test failed:', error);
+        }
+    }
+
+    /**
+     * Check if dialog tracking is properly enabled
+     */
+    checkDialogTrackingStatus(): void {
+        console.log('🔍 DialogDebugger: Checking dialog tracking status...');
+        
+        // Check DialogListener status
+        const dialogListener = DialogListener.getInstance();
+        console.log('DialogListener status:', {
+            isIntercepting: (dialogListener as any).isIntercepting,
+            eventCallbacksCount: (dialogListener as any).eventCallbacks?.length || 0
+        });
+        
+        // Check if Alert.alert is overridden
+        console.log('Alert.alert override status:', {
+            isOverridden: Alert.alert !== this.originalAlert,
+            originalAlert: this.originalAlert,
+            currentAlert: Alert.alert
+        });
+        
+        // Check TLTRN methods
+        console.log('TLTRN methods status:', {
+            logDialogShowEvent: typeof TLTRN.logDialogShowEvent,
+            interceptDialogEvents: typeof TLTRN.interceptDialogEvents
+        });
+    }
+
+    /**
+     * Force enable dialog tracking for testing
+     */
+    forceEnableDialogTracking(): void {
+        console.log('🔍 DialogDebugger: Force enabling dialog tracking...');
+        
+        try {
+            // Force enable DialogListener
+            const dialogListener = DialogListener.getInstance();
+            (dialogListener as any).isIntercepting = true;
+            console.log('✅ DialogListener interception forced enabled');
+            
+            // Force enable TLTRN dialog events
+            TLTRN.interceptDialogEvents(true);
+            console.log('✅ TLTRN dialog events forced enabled');
+            
+        } catch (error) {
+            console.error('❌ DialogDebugger: Force enable failed:', error);
+        }
+    }
+}
+
+export default DialogDebugger; 

package/src/utils/DialogListener.ts

@@ -0,0 +1,238 @@
+/********************************************************************************************
+* 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 { Alert, Platform } from 'react-native';
+import type { AlertButton, AlertOptions } from 'react-native';
+
+export interface DialogEvent {
+    dialogId: string;
+    dialogTitle: string;
+    dialogType: 'alert' | 'custom' | 'modal';
+    timestamp: number;
+    buttons?: AlertButton[];
+}
+
+export interface DialogButtonClickEvent {
+    dialogId: string;
+    buttonText: string;
+    buttonIndex: number;
+    timestamp: number;
+}
+
+export interface DialogDismissEvent {
+    dialogId: string;
+    dialogTitle: string;
+    dialogType: 'alert' | 'custom' | 'modal';
+    dismissReason: string;
+    timestamp: number;
+}
+
+// Simple ID generator
+function generateId(): string {
+    return Math.random().toString(36).substr(2, 9) + Date.now().toString(36);
+}
+
+class DialogListener {
+    private static instance: DialogListener;
+    private activeDialogs: Map<string, DialogEvent> = new Map();
+    private originalAlert: typeof Alert.alert;
+    private isIntercepting: boolean = false;
+    private eventCallbacks: Array<(event: DialogEvent | DialogButtonClickEvent | DialogDismissEvent) => void> = [];
+
+    private constructor() {
+        this.originalAlert = Alert.alert;
+        this.interceptAlertAPI();
+    }
+
+    static getInstance(): DialogListener {
+        if (!DialogListener.instance) {
+            DialogListener.instance = new DialogListener();
+        }
+        return DialogListener.instance;
+    }
+
+    /**
+     * Start intercepting dialog events
+     */
+    startIntercepting(): void {
+        if (this.isIntercepting) return;
+        this.isIntercepting = true;
+        console.log('DialogListener: Started intercepting dialog events');
+    }
+
+    /**
+     * Stop intercepting dialog events
+     */
+    stopIntercepting(): void {
+        if (!this.isIntercepting) return;
+        this.isIntercepting = false;
+        console.log('DialogListener: Stopped intercepting dialog events');
+    }
+
+    /**
+     * Add event callback for dialog events
+     */
+    addEventListener(callback: (event: DialogEvent | DialogButtonClickEvent | DialogDismissEvent) => void): () => void {
+        this.eventCallbacks.push(callback);
+        return () => {
+            const index = this.eventCallbacks.indexOf(callback);
+            if (index > -1) {
+                this.eventCallbacks.splice(index, 1);
+            }
+        };
+    }
+
+    /**
+     * Intercept React Native's Alert.alert API
+     */
+    private interceptAlertAPI(): void {
+        const self = this;
+        Alert.alert = function(
+            title: string,
+            message?: string,
+            buttons?: AlertButton[],
+            options?: AlertOptions
+        ): void {
+            if (self.isIntercepting) {
+                const dialogId = generateId();
+                const dialogEvent: DialogEvent = {
+                    dialogId,
+                    dialogTitle: title,
+                    dialogType: 'alert',
+                    timestamp: Date.now(),
+                    buttons: buttons || []
+                };
+
+                self.activeDialogs.set(dialogId, dialogEvent);
+                self.emitEvent(dialogEvent);
+
+                // Create wrapped buttons that log events
+                const wrappedButtons = buttons?.map((button, index) => ({
+                    ...button,
+                    onPress: () => {
+                        const buttonClickEvent: DialogButtonClickEvent = {
+                            dialogId,
+                            buttonText: button.text || '',
+                            buttonIndex: index,
+                            timestamp: Date.now()
+                        };
+                        self.emitEvent(buttonClickEvent);
+                        self.activeDialogs.delete(dialogId);
+                        
+                        // Call original onPress if it exists
+                        if (button.onPress) {
+                            button.onPress();
+                        }
+                    }
+                }));
+
+                // Call original Alert.alert with wrapped buttons
+                self.originalAlert.call(Alert, title, message, wrappedButtons, options);
+            } else {
+                // Call original Alert.alert without interception
+                self.originalAlert.call(Alert, title, message, buttons, options);
+            }
+        };
+    }
+
+    /**
+     * Manually track custom dialog show event
+     */
+    trackCustomDialogShow(dialogId: string, title: string, buttons?: AlertButton[]): void {
+        if (!this.isIntercepting) return;
+
+        const dialogEvent: DialogEvent = {
+            dialogId,
+            dialogTitle: title,
+            dialogType: 'custom',
+            timestamp: Date.now(),
+            buttons: buttons || []
+        };
+
+        this.activeDialogs.set(dialogId, dialogEvent);
+        this.emitEvent(dialogEvent);
+    }
+
+    /**
+     * Manually track custom dialog dismiss event
+     */
+    trackCustomDialogDismiss(dialogId: string, reason: string = 'manual'): void {
+        if (!this.isIntercepting) return;
+
+        const dialogEvent = this.activeDialogs.get(dialogId);
+        if (dialogEvent) {
+            this.activeDialogs.delete(dialogId);
+            // Emit proper dismiss event
+            const dismissEvent: DialogDismissEvent = {
+                dialogId,
+                dialogTitle: dialogEvent.dialogTitle,
+                dialogType: dialogEvent.dialogType,
+                dismissReason: reason,
+                timestamp: Date.now()
+            };
+            this.emitEvent(dismissEvent);
+            
+            // Log the dismiss reason for debugging
+            console.log(`Dialog ${dialogId} dismissed with reason: ${reason}`);
+        }
+    }
+
+    /**
+     * Manually track custom dialog button click event
+     */
+    trackCustomDialogButtonClick(dialogId: string, buttonText: string, buttonIndex: number): void {
+        if (!this.isIntercepting) return;
+
+        const buttonClickEvent: DialogButtonClickEvent = {
+            dialogId,
+            buttonText,
+            buttonIndex,
+            timestamp: Date.now()
+        };
+
+        this.emitEvent(buttonClickEvent);
+    }
+
+    /**
+     * Get currently active dialogs
+     */
+    getActiveDialogs(): DialogEvent[] {
+        return Array.from(this.activeDialogs.values());
+    }
+
+    /**
+     * Clear all active dialogs
+     */
+    clearActiveDialogs(): void {
+        this.activeDialogs.clear();
+    }
+
+    /**
+     * Emit event to all registered callbacks
+     */
+    private emitEvent(event: DialogEvent | DialogButtonClickEvent | DialogDismissEvent): void {
+        this.eventCallbacks.forEach(callback => {
+            try {
+                callback(event);
+            } catch (error) {
+                console.error('DialogListener: Error in event callback:', error);
+            }
+        });
+    }
+
+    /**
+     * Restore original Alert.alert API
+     */
+    restoreOriginalAlert(): void {
+        Alert.alert = this.originalAlert;
+    }
+}
+
+export default DialogListener; 

package/src/utils/useDialogTracking.ts

@@ -0,0 +1,102 @@
+/********************************************************************************************
+* 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 { useCallback, useRef } from 'react';
+import type { AlertButton } from 'react-native';
+import DialogListener from './DialogListener';
+import TLTRN from '../TLTRN';
+
+/**
+ * React hook for tracking custom dialog events
+ * Provides utilities to track dialog show, dismiss, and button click events
+ */
+export const useDialogTracking = () => {
+    const dialogIds = useRef<Set<string>>(new Set());
+
+    /**
+     * Generate a unique dialog ID
+     */
+    const generateDialogId = useCallback((): string => {
+        const id = Math.random().toString(36).substr(2, 9) + Date.now().toString(36);
+        dialogIds.current.add(id);
+        return id;
+    }, []);
+
+    /**
+     * Track a custom dialog show event
+     */
+    const trackDialogShow = useCallback((dialogId: string, title: string, buttons?: AlertButton[]) => {
+        DialogListener.getInstance().trackCustomDialogShow(dialogId, title, buttons);
+        // Note: The actual native call is handled by the DialogListener event system
+        // No need to call TLTRN.logDialogShowEvent directly here
+    }, []);
+
+    /**
+     * Track a custom dialog dismiss event
+     */
+    const trackDialogDismiss = useCallback((dialogId: string, reason: string = 'manual') => {
+        DialogListener.getInstance().trackCustomDialogDismiss(dialogId, reason);
+        // Note: The actual native call is handled by the DialogListener event system
+        // No need to call TLTRN.logDialogDismissEvent directly here
+    }, []);
+
+    /**
+     * Track a custom dialog button click event
+     */
+    const trackDialogButtonClick = useCallback((dialogId: string, buttonText: string, buttonIndex: number) => {
+        DialogListener.getInstance().trackCustomDialogButtonClick(dialogId, buttonText, buttonIndex);
+        // Note: The actual native call is handled by the DialogListener event system
+        // No need to call TLTRN.logDialogButtonClickEvent directly here
+    }, []);
+
+    /**
+     * Track a custom dialog event
+     */
+    const trackDialogCustomEvent = useCallback((dialogId: string, eventName: string, values: Record<string, string | number | boolean>) => {
+        TLTRN.logDialogCustomEvent(dialogId, eventName, values);
+    }, []);
+
+    /**
+     * Create a wrapped button with automatic tracking
+     */
+    const createTrackedButton = useCallback((dialogId: string, button: AlertButton, buttonIndex: number): AlertButton => {
+        return {
+            ...button,
+            onPress: () => {
+                // Track the button click
+                trackDialogButtonClick(dialogId, button.text || '', buttonIndex);
+                
+                // Call the original onPress if it exists
+                if (button.onPress) {
+                    button.onPress();
+                }
+            }
+        };
+    }, [trackDialogButtonClick]);
+
+    /**
+     * Clean up dialog tracking
+     */
+    const cleanup = useCallback(() => {
+        dialogIds.current.clear();
+    }, []);
+
+    return {
+        generateDialogId,
+        trackDialogShow,
+        trackDialogDismiss,
+        trackDialogButtonClick,
+        trackDialogCustomEvent,
+        createTrackedButton,
+        cleanup
+    };
+};
+
+export default useDialogTracking;