@onairos/react-native 3.1.12 → 3.1.13

package/src/services/googleAuthService.ts

@@ -0,0 +1,279 @@
+/**
+ * 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

@@ -0,0 +1,303 @@
+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;
+};