@onairos/react-native 3.1.18 → 3.2.1

package/src/services/googleAuthService.ts

@@ -1,279 +0,0 @@
-/**
- * Google Authentication Service
- * Handles Google Sign-In for user authentication and account creation
- */
-
-import { GoogleSignin, statusCodes } from '@react-native-google-signin/google-signin';
-import AsyncStorage from '@react-native-async-storage/async-storage';
-
-// 🔑 Using the same client ID configuration as platform auth
-let WEB_CLIENT_ID = '1030678346906-lovkuds2ouqmoc8eu5qpo98spa6edv4o.apps.googleusercontent.com';
-let IOS_CLIENT_ID = '1030678346906-lovkuds2ouqmoc8eu5qpo98spa6edv4o.apps.googleusercontent.com';
-
-/**
- * Update Google OAuth client IDs for custom configurations
- */
-export const updateGoogleClientIds = (config: {
-  webClientId?: string;
-  iosClientId?: string;
-}) => {
-  if (config.webClientId) {
-    WEB_CLIENT_ID = config.webClientId;
-  }
-  if (config.iosClientId) {
-    IOS_CLIENT_ID = config.iosClientId;
-  }
-  
-  console.log('✅ Google client IDs updated:', {
-    webClientId: WEB_CLIENT_ID,
-    iosClientId: IOS_CLIENT_ID
-  });
-};
-
-/**
- * Initialize Google Sign-In for user authentication
- */
-const initializeGoogleAuth = () => {
-  GoogleSignin.configure({
-    webClientId: WEB_CLIENT_ID,
-    iosClientId: IOS_CLIENT_ID,
-    
-    // Basic scopes for user authentication
-    scopes: [
-      'openid',
-      'profile',
-      'email'
-    ],
-    
-    // Enable offline access for refresh tokens
-    offlineAccess: true,
-    forceCodeForRefreshToken: true,
-    
-    // Clear settings to avoid conflicts
-    hostedDomain: '',
-    accountName: '',
-  });
-};
-
-/**
- * Sign in with Google and create/authenticate user account
- */
-export const signInWithGoogle = async () => {
-  try {
-    console.log('🔗 Initiating Google Sign-In for user authentication');
-    
-    // Initialize Google Sign-In
-    initializeGoogleAuth();
-    
-    // Check if Google Play Services are available
-    await GoogleSignin.hasPlayServices();
-    
-    // Sign out first to ensure fresh consent
-    try {
-      await GoogleSignin.signOut();
-      console.log('🔄 Signed out to ensure fresh consent');
-    } catch (signOutError) {
-      console.log('ℹ️ Sign out not needed or failed:', signOutError);
-    }
-    
-    // Sign in with Google
-    const userInfo = await GoogleSignin.signIn();
-    console.log('✅ Google Sign-In successful:', userInfo.data?.user?.email);
-    
-    const googleUser = userInfo.data?.user;
-    if (!googleUser || !googleUser.email) {
-      throw new Error('No user data received from Google');
-    }
-    
-    console.log('👤 Google user data:', {
-      email: googleUser.email,
-      name: googleUser.name,
-      photo: googleUser.photo,
-      id: googleUser.id
-    });
-    
-    // Get tokens for account creation
-    const tokens = await GoogleSignin.getTokens();
-    console.log('🔑 Got Google tokens');
-    
-    // Create user account on backend
-    const accountResult = await createUserAccount({
-      email: googleUser.email,
-      name: googleUser.name || googleUser.email.split('@')[0],
-      photoUrl: googleUser.photo || '',
-      googleId: googleUser.id,
-      accessToken: tokens.accessToken,
-      idToken: tokens.idToken
-    });
-    
-    if (accountResult.success) {
-      console.log('✅ User account created/authenticated successfully');
-      
-      // Store authentication data
-      await AsyncStorage.setItem('user_email', googleUser.email);
-      await AsyncStorage.setItem('user_name', googleUser.name || '');
-      await AsyncStorage.setItem('user_photo', googleUser.photo || '');
-      await AsyncStorage.setItem('auth_method', 'google');
-      
-      if (accountResult.token) {
-        await AsyncStorage.setItem('onairos_jwt_token', accountResult.token);
-        await AsyncStorage.setItem('auth_token', accountResult.token);
-      }
-      
-      return {
-        success: true,
-        user: {
-          email: googleUser.email,
-          name: googleUser.name,
-          photo: googleUser.photo,
-          id: googleUser.id
-        },
-        token: accountResult.token,
-        existingUser: accountResult.existingUser
-      };
-    } else {
-      throw new Error(accountResult.message || 'Failed to create user account');
-    }
-    
-  } catch (error: any) {
-    console.error('❌ Google Sign-In error:', error);
-    
-    // Handle specific Google Sign-In errors
-    if (error.code === statusCodes.SIGN_IN_CANCELLED) {
-      return {
-        success: false,
-        message: 'Google Sign-In was cancelled',
-        cancelled: true
-      };
-    } else if (error.code === statusCodes.IN_PROGRESS) {
-      return {
-        success: false,
-        message: 'Google Sign-In is already in progress'
-      };
-    } else if (error.code === statusCodes.PLAY_SERVICES_NOT_AVAILABLE) {
-      return {
-        success: false,
-        message: 'Google Play Services not available'
-      };
-    } else {
-      return {
-        success: false,
-        message: error.message || 'Google Sign-In failed'
-      };
-    }
-  }
-};
-
-/**
- * Create or authenticate user account on backend
- */
-const createUserAccount = async (userData: {
-  email: string;
-  name: string;
-  photoUrl: string;
-  googleId: string;
-  accessToken: string;
-  idToken: string;
-}) => {
-  try {
-    console.log('🔐 Creating/authenticating user account for:', userData.email);
-    
-    // Step 1: Create Enoch user first
-    console.log('🔐 Step 1: Creating Enoch user...');
-    try {
-      const enochRegisterResponse = await fetch('https://api2.onairos.uk/enoch/users/register', {
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/json'
-        },
-        body: JSON.stringify({
-          email: userData.email,
-          name: userData.name,
-          photoUrl: userData.photoUrl
-        })
-      });
-      
-      console.log('📡 Enoch register response status:', enochRegisterResponse.status);
-      const enochResponseData = await enochRegisterResponse.json();
-      console.log('🔗 Enoch user creation response:', enochResponseData);
-    } catch (enochError) {
-      console.warn('⚠️ Enoch user creation failed (continuing):', enochError);
-    }
-    
-    // Step 2: Create Onairos account to get JWT token
-    console.log('🔐 Step 2: Creating Onairos account...');
-    const onairosSignupResponse = await fetch('https://api2.onairos.uk/register/enoch', {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json'
-      },
-      body: JSON.stringify({
-        email: userData.email,
-        username: userData.name,
-        name: userData.name,
-        googleAuth: true, // Flag to indicate Google authentication
-        googleId: userData.googleId,
-        photoUrl: userData.photoUrl
-      })
-    });
-    
-    console.log('📡 Onairos register response status:', onairosSignupResponse.status);
-    const onairosResponseData = await onairosSignupResponse.json();
-    console.log('🔗 Onairos account creation response:', onairosResponseData);
-    
-    if (onairosSignupResponse.ok && onairosResponseData.token) {
-      return {
-        success: true,
-        token: onairosResponseData.token,
-        existingUser: onairosResponseData.existingUser || false,
-        message: 'Account created/authenticated successfully'
-      };
-    } else {
-      return {
-        success: false,
-        message: onairosResponseData.message || 'Failed to create account'
-      };
-    }
-    
-  } catch (error: any) {
-    console.error('❌ Error creating user account:', error);
-    return {
-      success: false,
-      message: error.message || 'Failed to create user account'
-    };
-  }
-};
-
-/**
- * Check if user is already signed in with Google
- */
-export const isGoogleSignedIn = async () => {
-  try {
-    const currentUser = await GoogleSignin.getCurrentUser();
-    const isSignedIn = currentUser !== null;
-    if (isSignedIn) {
-      return {
-        isSignedIn: true,
-        user: currentUser?.user
-      };
-    }
-    return { isSignedIn: false };
-  } catch (error) {
-    console.error('❌ Error checking Google sign-in status:', error);
-    return { isSignedIn: false };
-  }
-};
-
-/**
- * Sign out from Google
- */
-export const signOutFromGoogle = async () => {
-  try {
-    await GoogleSignin.signOut();
-    console.log('✅ Google sign-out successful');
-    return true;
-  } catch (error) {
-    console.error('❌ Google sign-out error:', error);
-    return false;
-  }
-};

package/src/services/imageCompressionService.ts

@@ -1,303 +0,0 @@
-import ImageResizer from '@bam.tech/react-native-image-resizer';
-
-/**
- * Comprehensive image compression service for React Native
- * Supports iterative compression to meet specific size targets
- */
-
-interface CompressionOptions {
-  maxSizeKB?: number;
-  maxWidth?: number;
-  maxHeight?: number;
-  quality?: number;
-  format?: 'JPEG' | 'PNG' | 'WEBP';
-}
-
-interface CompressionResult {
-  success: boolean;
-  base64?: string;
-  sizeKB?: number;
-  originalSizeKB?: number;
-  compressionRatio?: number;
-  error?: string;
-}
-
-/**
- * Get file size from URI (React Native compatible)
- */
-const getFileSizeFromUri = async (uri: string): Promise<number> => {
-  try {
-    const response = await fetch(uri);
-    const blob = await response.blob();
-    return blob.size;
-  } catch (error) {
-    console.error('Error getting file size:', error);
-    return 0;
-  }
-};
-
-/**
- * Convert image to base64 string
- */
-const imageToBase64 = async (uri: string): Promise<string | null> => {
-  try {
-    const response = await fetch(uri);
-    const blob = await response.blob();
-    
-    return new Promise((resolve, reject) => {
-      const reader = new FileReader();
-      reader.onloadend = () => {
-        try {
-          const base64data = reader.result as string;
-          // Remove the data:image/jpeg;base64, prefix
-          const base64 = base64data.split(',')[1];
-          resolve(base64);
-        } catch (error) {
-          reject(error);
-        }
-      };
-      reader.onerror = reject;
-      reader.readAsDataURL(blob);
-    });
-  } catch (error) {
-    console.error('Error converting image to base64:', error);
-    return null;
-  }
-};
-
-/**
- * Compress image with iterative quality reduction to meet size target
- */
-export const compressImageToTarget = async (
-  imageUri: string,
-  options: CompressionOptions = {}
-): Promise<CompressionResult> => {
-  const {
-    maxSizeKB = 300,
-    maxWidth = 1200,
-    maxHeight = 1200,
-    quality = 0.8,
-    format = 'JPEG'
-  } = options;
-
-  try {
-    console.log('🖼️ [COMPRESSION] Starting compression for:', imageUri);
-    
-    // Get original file size
-    const originalSize = await getFileSizeFromUri(imageUri);
-    const originalSizeKB = Math.round(originalSize / 1024);
-    
-    console.log('📊 [COMPRESSION] Original size:', originalSizeKB, 'KB');
-    
-    // If already under target, just convert to base64
-    if (originalSizeKB <= maxSizeKB) {
-      console.log('✅ [COMPRESSION] Image already under target size');
-      const base64 = await imageToBase64(imageUri);
-      
-      if (base64) {
-        return {
-          success: true,
-          base64,
-          sizeKB: originalSizeKB,
-          originalSizeKB,
-          compressionRatio: 1.0
-        };
-      }
-    }
-
-    // Start with initial compression parameters
-    let currentQuality = quality;
-    let currentWidth = maxWidth;
-    let currentHeight = maxHeight;
-    let attempts = 0;
-    const maxAttempts = 8;
-
-    while (attempts < maxAttempts) {
-      attempts++;
-      
-      console.log(`🔄 [COMPRESSION] Attempt ${attempts}: quality=${currentQuality}, size=${currentWidth}x${currentHeight}`);
-      
-      try {
-        // Resize and compress the image
-        const resizedImage = await ImageResizer.createResizedImage(
-          imageUri,
-          currentWidth,
-          currentHeight,
-          format,
-          Math.round(currentQuality * 100), // Convert to percentage
-          0, // rotation
-          undefined, // outputPath
-          false, // keepMeta
-          {
-            mode: 'contain', // Maintain aspect ratio
-            onlyScaleDown: true, // Don't upscale
-          }
-        );
-
-        // Check the size of the compressed image
-        const compressedSize = await getFileSizeFromUri(resizedImage.uri);
-        const compressedSizeKB = Math.round(compressedSize / 1024);
-        
-        console.log(`📊 [COMPRESSION] Attempt ${attempts} result: ${compressedSizeKB} KB`);
-
-        // If we've hit our target, convert to base64 and return
-        if (compressedSizeKB <= maxSizeKB) {
-          console.log('✅ [COMPRESSION] Target size achieved!');
-          
-          const base64 = await imageToBase64(resizedImage.uri);
-          
-          if (base64) {
-            const compressionRatio = originalSizeKB / compressedSizeKB;
-            
-            console.log('🎯 [COMPRESSION] Success:', {
-              originalSizeKB,
-              finalSizeKB: compressedSizeKB,
-              compressionRatio: compressionRatio.toFixed(2) + 'x',
-              attempts
-            });
-            
-            return {
-              success: true,
-              base64,
-              sizeKB: compressedSizeKB,
-              originalSizeKB,
-              compressionRatio
-            };
-          }
-        }
-
-        // If still too large, adjust parameters for next attempt
-        if (compressedSizeKB > maxSizeKB) {
-          // Reduce quality more aggressively if we're way over
-          const sizeRatio = compressedSizeKB / maxSizeKB;
-          
-          if (sizeRatio > 2.0) {
-            // Way too big - reduce quality and dimensions significantly
-            currentQuality *= 0.6;
-            currentWidth = Math.round(currentWidth * 0.8);
-            currentHeight = Math.round(currentHeight * 0.8);
-          } else if (sizeRatio > 1.5) {
-            // Moderately too big - reduce quality more
-            currentQuality *= 0.75;
-            currentWidth = Math.round(currentWidth * 0.9);
-            currentHeight = Math.round(currentHeight * 0.9);
-          } else {
-            // Close to target - fine-tune quality
-            currentQuality *= 0.85;
-          }
-          
-          // Ensure we don't go below minimum thresholds
-          currentQuality = Math.max(0.1, currentQuality);
-          currentWidth = Math.max(400, currentWidth);
-          currentHeight = Math.max(400, currentHeight);
-        }
-        
-      } catch (resizeError) {
-        console.error(`❌ [COMPRESSION] Resize attempt ${attempts} failed:`, resizeError);
-        
-        // Try with more aggressive settings
-        currentQuality *= 0.7;
-        currentWidth = Math.round(currentWidth * 0.8);
-        currentHeight = Math.round(currentHeight * 0.8);
-        
-        if (currentQuality < 0.1 || currentWidth < 200 || currentHeight < 200) {
-          break;
-        }
-      }
-    }
-
-    // If we've exhausted all attempts, return the best effort
-    console.log('⚠️ [COMPRESSION] Max attempts reached, using best effort');
-    
-    try {
-      const finalImage = await ImageResizer.createResizedImage(
-        imageUri,
-        Math.max(400, currentWidth),
-        Math.max(400, currentHeight),
-        format,
-        30, // Very low quality as last resort
-        0,
-        undefined,
-        false,
-        { mode: 'contain', onlyScaleDown: true }
-      );
-
-      const finalSize = await getFileSizeFromUri(finalImage.uri);
-      const finalSizeKB = Math.round(finalSize / 1024);
-      const base64 = await imageToBase64(finalImage.uri);
-
-      if (base64) {
-        console.log('📤 [COMPRESSION] Final result (best effort):', finalSizeKB, 'KB');
-        
-        return {
-          success: true,
-          base64,
-          sizeKB: finalSizeKB,
-          originalSizeKB,
-          compressionRatio: originalSizeKB / finalSizeKB
-        };
-      }
-    } catch (finalError) {
-      console.error('❌ [COMPRESSION] Final compression attempt failed:', finalError);
-    }
-
-    return {
-      success: false,
-      error: `Failed to compress image to ${maxSizeKB}KB after ${maxAttempts} attempts`,
-      originalSizeKB
-    };
-
-  } catch (error) {
-    console.error('❌ [COMPRESSION] Compression service error:', error);
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : 'Unknown compression error',
-      originalSizeKB: 0
-    };
-  }
-};
-
-/**
- * Quick compression for profile pictures (300KB target)
- */
-export const compressProfilePicture = async (imageUri: string): Promise<CompressionResult> => {
-  return compressImageToTarget(imageUri, {
-    maxSizeKB: 300,
-    maxWidth: 1200,
-    maxHeight: 1200,
-    quality: 0.8,
-    format: 'JPEG'
-  });
-};
-
-/**
- * Compress image for upload with custom settings
- */
-export const compressForUpload = async (
-  imageUri: string,
-  maxSizeKB: number = 300
-): Promise<CompressionResult> => {
-  return compressImageToTarget(imageUri, {
-    maxSizeKB,
-    maxWidth: 1200,
-    maxHeight: 1200,
-    quality: 0.8,
-    format: 'JPEG'
-  });
-};
-
-/**
- * Legacy function for backward compatibility
- */
-export const convertImageToOptimizedBase64 = async (
-  imageUri: string,
-  quality: number = 0.8
-): Promise<string | null> => {
-  const result = await compressImageToTarget(imageUri, {
-    maxSizeKB: 300,
-    quality,
-    format: 'JPEG'
-  });
-  
-  return result.success ? result.base64 || null : null;
-};