@onairos/react-native 3.1.18 → 3.2.1

package/src/hooks/useConnections.ts

@@ -1,161 +1,163 @@
-import { useState, useCallback } from 'react';
-import { initiateOAuth, initiateNativeAuth, exchangeCodeForToken } from '../services/platformAuthService';
-import AsyncStorage from '@react-native-async-storage/async-storage';
-import { getOnairosUsername } from '../services/authService';
-
-export interface ConnectionStatus {
-  [key: string]: {
-    userName: string;
-    connected: boolean;
-  };
-}
-
-export const useConnections = () => {
-  const [connections, setConnections] = useState<ConnectionStatus>({});
-  const [isConnecting, setIsConnecting] = useState(false);
-
-  /**
-   * Connect a platform using OAuth or native SDK
-   */
-  const connectPlatform = useCallback(async (platform: string, username: string): Promise<boolean> => {
-    try {
-      setIsConnecting(true);
-
-      // Determine if we should use native SDK or OAuth
-      const useNativeSDK = platform === 'youtube' || platform === 'instagram';
-
-      let success = false;
-      
-      if (useNativeSDK) {
-        // Use native SDK
-        success = await initiateNativeAuth(platform, username);
-      } else {
-        // For demo purposes, we'll simulate a successful connection
-        await new Promise(resolve => setTimeout(() => resolve(undefined), 1000));
-        success = true;
-      }
-      
-      if (success) {
-        // Update connections state locally
-        setConnections(prev => ({
-          ...prev,
-          [platform]: { userName: username, connected: true }
-        }));
-        
-        // Update user account info via API
-        try {
-          const token = await AsyncStorage.getItem('auth_token');
-          // Get the stored Onairos username for API calls
-          const storedUsername = await getOnairosUsername();
-          const apiUsername = storedUsername || username;
-          
-          console.log(`🔗 Using username for ${platform} API call:`, {
-            providedUsername: username,
-            storedUsername,
-            finalApiUsername: apiUsername
-          });
-          
-          if (token) {
-            const response = await fetch('https://api2.onairos.uk/enoch/users/update', {
-              method: 'POST',
-              headers: {
-                'Content-Type': 'application/json',
-                'Authorization': token
-              },
-              body: JSON.stringify({
-                UpdateType: 'connection',
-                updateType: 'Add',
-                connection: platform,
-                username: apiUsername // Use stored Onairos username
-              })
-            });
-            
-            console.log(`Platform connection update response for ${platform}:`, response.status);
-          }
-        } catch (apiError) {
-          console.warn(`Error updating user connections for ${platform}, but continuing:`, apiError);
-          // Continue even if the API call fails
-        }
-        
-        return true;
-      }
-      
-      return false;
-    } catch (error) {
-      console.error(`Error connecting platform ${platform}:`, error);
-      return false;
-    } finally {
-      setIsConnecting(false);
-    }
-  }, []);
-
-  /**
-   * Disconnect a platform
-   */
-  const disconnectPlatform = useCallback(async (platform: string, username?: string): Promise<boolean> => {
-    try {
-      // Update local state
-      setConnections(prev => {
-        const newConnections = { ...prev };
-        delete newConnections[platform];
-        return newConnections;
-      });
-      
-      // Update user account info via API
-      try {
-        const token = await AsyncStorage.getItem('auth_token');
-        // Get the stored Onairos username for API calls
-        const storedUsername = await getOnairosUsername();
-        const apiUsername = storedUsername || username || 'user';
-        
-        console.log(`🔗 Using username for ${platform} disconnect API call:`, {
-          providedUsername: username,
-          storedUsername,
-          finalApiUsername: apiUsername
-        });
-        
-        if (token) {
-          const response = await fetch('https://api2.onairos.uk/enoch/users/update', {
-            method: 'POST',
-            headers: {
-              'Content-Type': 'application/json',
-              'Authorization': token
-            },
-            body: JSON.stringify({
-              UpdateType: 'connection',
-              updateType: 'Remove',
-              connection: platform,
-              username: apiUsername // Use stored Onairos username
-            })
-          });
-          
-          console.log(`Platform disconnection update response for ${platform}:`, response.status);
-        }
-      } catch (apiError) {
-        console.warn(`Error updating user connections for ${platform}, but continuing:`, apiError);
-        // Continue even if the API call fails
-      }
-      
-      return true;
-    } catch (error) {
-      console.error(`Error disconnecting platform ${platform}:`, error);
-      return false;
-    }
-  }, []);
-
-  /**
-   * Get current connection status
-   */
-  const getConnectionStatus = useCallback(async (): Promise<ConnectionStatus> => {
-    // In a real app, you might fetch this from storage or API
-    return connections;
-  }, [connections]);
-
-  return {
-    connections,
-    connectPlatform,
-    disconnectPlatform,
-    getConnectionStatus,
-    isConnecting
-  };
-};
+import { useState, useCallback } from 'react';
+import { Platform } from 'react-native';
+import { STORAGE_KEYS } from '../constants';
+import type { ConnectionStatus } from '../types';
+
+// Create a mock storage for environments without Keychain access (like Expo Go)
+const mockConnectionStorage: Record<string, ConnectionStatus> = {};
+
+// Try to import Keychain, but provide fallbacks if not available
+let Keychain: any = null;
+try {
+  // This import might fail in Expo Go or environments without native modules
+  Keychain = require('react-native-keychain');
+} catch (error) {
+  console.warn('react-native-keychain module not available in useConnections, using mock storage');
+}
+
+// Check if Keychain is properly initialized and available
+const isKeychainAvailable = () => {
+  try {
+    return Keychain && typeof Keychain.getGenericPassword === 'function';
+  } catch (e) {
+    return false;
+  }
+};
+
+export const useConnections = () => {
+  const [isConnecting, setIsConnecting] = useState(false);
+
+  const getConnectionStatus = useCallback(async (): Promise<ConnectionStatus> => {
+    try {
+      if (isKeychainAvailable()) {
+        try {
+          const stored = await Keychain.getGenericPassword({
+            service: STORAGE_KEYS.connections
+          });
+          if (stored && stored.password) {
+            const parsed = JSON.parse(stored.password);
+            // Validate the parsed data structure
+            if (parsed && typeof parsed === 'object') {
+              return parsed;
+            }
+          }
+        } catch (keychainError) {
+          console.warn('Keychain access failed, using fallback:', keychainError);
+          // Clear corrupted data
+          try {
+            await Keychain.resetGenericPassword({ service: STORAGE_KEYS.connections });
+          } catch (resetError) {
+            console.warn('Failed to reset keychain:', resetError);
+          }
+        }
+      }
+      
+      // Use in-memory mock storage if Keychain is not available or failed
+      const mockData = mockConnectionStorage[STORAGE_KEYS.connections] || {};
+      console.log('Using mock connection storage:', mockData);
+      return mockData;
+    } catch (error) {
+      console.error('Error getting connection status:', error);
+      
+      // Always return empty object as safe fallback
+      console.log('Returning empty connections due to error');
+      return {};
+    }
+  }, []);
+
+  const saveConnectionStatus = useCallback(async (status: ConnectionStatus) => {
+    try {
+      if (isKeychainAvailable()) {
+        await Keychain.setGenericPassword(
+          'connections',
+          JSON.stringify(status),
+          { service: STORAGE_KEYS.connections }
+        );
+      } else {
+        // Use in-memory mock storage if Keychain is not available
+        mockConnectionStorage[STORAGE_KEYS.connections] = status;
+      }
+    } catch (error) {
+      console.error('Error saving connection status:', error);
+      // Save to mock storage as fallback
+      mockConnectionStorage[STORAGE_KEYS.connections] = status;
+    }
+  }, []);
+
+  const connectPlatform = useCallback(async (platform: string) => {
+    setIsConnecting(true);
+    try {
+      console.log(`[Mock] Connecting to ${platform}`);
+      
+      // Simulate connection delay
+      await new Promise<void>((resolve) => {
+        setTimeout(() => resolve(), 1000);
+      });
+      
+      const status = await getConnectionStatus();
+      status[platform] = {
+        userName: `Mock User (${platform})`,
+        connected: true
+      };
+      await saveConnectionStatus(status);
+      
+      console.log(`[Mock] Successfully connected to ${platform}`);
+    } catch (error) {
+      console.error(`Error connecting to ${platform}:`, error);
+      // In development, provide mock data even on error
+      if (__DEV__) {
+        const status = {
+          [platform]: {
+            userName: `Fallback User (${platform})`,
+            connected: true
+          }
+        };
+        await saveConnectionStatus(status);
+      } else {
+        throw error;
+      }
+    } finally {
+      setIsConnecting(false);
+    }
+  }, [getConnectionStatus, saveConnectionStatus]);
+
+  const disconnectPlatform = useCallback(async (platform: string) => {
+    try {
+      const status = await getConnectionStatus();
+      if (status && platform in status) {
+        delete status[platform];
+        await saveConnectionStatus(status);
+      }
+    } catch (error) {
+      console.error(`Error disconnecting ${platform}:`, error);
+      // Don't throw in development mode
+      if (!__DEV__) {
+        throw error;
+      }
+    }
+  }, [getConnectionStatus, saveConnectionStatus]);
+
+  const handleOAuthCallback = useCallback(async (platform: string, data: any) => {
+    try {
+      console.log(`[Mock] Handling callback for ${platform}`);
+      const status = await getConnectionStatus();
+      status[platform] = {
+        userName: data.userName || `Mock User (${platform})`,
+        connected: true
+      };
+      await saveConnectionStatus(status);
+      return true;
+    } catch (error) {
+      console.error('Error handling callback:', error);
+      return false;
+    }
+  }, [getConnectionStatus, saveConnectionStatus]);
+
+  return {
+    isConnecting,
+    connectPlatform,
+    disconnectPlatform,
+    getConnectionStatus,
+    handleOAuthCallback,
+  };
+};