Firebase Storage Setup

dependencies:
  firebase_storage: any
  firebase_auth: any
  image_picker: any  # For selecting images
  logger: any        # For logging

import 'dart:io';
import 'package:firebase_storage/firebase_storage.dart';
import 'package:cloud_firestore/cloud_firestore.dart';
import 'package:logger/logger.dart';

class AuthService {
  final FirebaseStorage _storage = FirebaseStorage.instance;
  final FirebaseFirestore _firestore = FirebaseFirestore.instance;
  final Logger _logger = Logger();

  /// Save user profile with optional profile image
  Future<void> saveUserProfile(
    String uid, 
    String name, 
    String surname, 
    File? profileImage
  ) async {
    try {
      String? photoUrl;
      
      // Upload profile image if provided
      if (profileImage != null) {
        // Create storage reference with user ID
        final storageRef = _storage.ref().child('profileImages/$uid.jpg');
        
        // Upload file to Firebase Storage
        await storageRef.putFile(profileImage);
        
        // Get download URL for the uploaded file
        photoUrl = await storageRef.getDownloadURL();
        
        _logger.i('Profile image uploaded successfully: $photoUrl');
      }

      // Save user profile to Firestore
      await _firestore.collection('users').doc(uid).set({
        'name': name,
        'surname': surname,
        'photoUrl': photoUrl,
        'createdAt': FieldValue.serverTimestamp(),
      });
      
      _logger.i('User profile saved successfully');
    } catch (e) {
      _logger.e('Error saving user profile: $e');
      rethrow;
    }
  }
}

import 'dart:io';
import 'package:flutter/material.dart';
import 'package:firebase_auth/firebase_auth.dart';
import 'package:firebase_storage/firebase_storage.dart';
import 'package:cloud_firestore/cloud_firestore.dart';
import 'package:image_picker/image_picker.dart';
import 'package:logger/logger.dart';

class EditProfileScreenState extends State<EditProfileScreen> {
  final FirebaseAuth _auth = FirebaseAuth.instance;
  final FirebaseStorage _storage = FirebaseStorage.instance;
  final FirebaseFirestore _firestore = FirebaseFirestore.instance;
  final Logger logger = Logger();
  
  File? _profileImage;
  String? _photoUrl;

  /// Pick image from gallery
  Future<void> _pickImage() async {
    final picker = ImagePicker();
    final pickedFile = await picker.pickImage(
      source: ImageSource.gallery,
      maxWidth: 1024,  // Limit image width
      maxHeight: 1024, // Limit image height
      imageQuality: 85, // Compress image (0-100)
    );
    
    if (pickedFile != null) {
      setState(() {
        _profileImage = File(pickedFile.path);
      });
    }
  }

  /// Update user profile with new image
  void _updateProfile() async {
    User? user = _auth.currentUser;
    if (user == null) return;
    
    try {
      // Upload new profile image if selected
      if (_profileImage != null) {
        // Create storage reference
        final ref = _storage.ref().child('profile_images/${user.uid}');
        
        // Upload file with progress tracking
        final uploadTask = ref.putFile(_profileImage!);
        
        // Optional: Listen to upload progress
        uploadTask.snapshotEvents.listen((TaskSnapshot snapshot) {
          final progress = snapshot.bytesTransferred / snapshot.totalBytes;
          logger.i('Upload progress: ${(progress * 100).toStringAsFixed(2)}%');
        });
        
        // Wait for upload to complete
        await uploadTask;
        
        // Get download URL
        _photoUrl = await ref.getDownloadURL();
        
        // Update Firestore with new photo URL
        await _firestore.collection('users').doc(user.uid).update({
          'photoUrl': _photoUrl,
          'updatedAt': FieldValue.serverTimestamp(),
        });
        
        logger.i('Profile image updated successfully');
      }
      
      if (mounted) {
        ScaffoldMessenger.of(context).showSnackBar(
          const SnackBar(content: Text('Profile updated successfully')),
        );
        Navigator.pop(context);
      }
    } catch (e) {
      logger.e('Error updating profile: $e');
      
      if (mounted) {
        ScaffoldMessenger.of(context).showSnackBar(
          SnackBar(content: Text('Error updating profile: $e')),
        );
      }
    }
  }
}

rules_version = '2';

service firebase.storage {
  match /b/{bucket}/o {
    // Helper function to check if user is authenticated
    function isAuthenticated() {
      return request.auth != null;
    }
    
    // Helper function to check if user owns the resource
    function isOwner(userId) {
      return request.auth.uid == userId;
    }
    
    // Helper function to validate file size (5MB max)
    function isValidSize() {
      return request.resource.size < 5 * 1024 * 1024;
    }
    
    // Helper function to validate image type
    function isImage() {
      return request.resource.contentType.matches('image/.*');
    }
    
    // Profile images from registration (profileImages/{userId}.jpg)
    match /profileImages/{userId}.jpg {
      // Anyone authenticated can read
      allow read: if isAuthenticated();
      
      // Only owner can write, with validation
      allow write: if isOwner(userId) 
                   && isImage() 
                   && isValidSize();
    }
    
    // Profile images from editor (profile_images/{userId})
    match /profile_images/{userId} {
      // Anyone authenticated can read
      allow read: if isAuthenticated();
      
      // Only owner can write, with validation
      allow write: if isOwner(userId) 
                   && isImage() 
                   && isValidSize();
    }
    
    // Fallback: deny all other access
    match /{allPaths=**} {
      allow read, write: if false;
    }
  }
}

rules_version = '2';

service firebase.storage {
  match /b/{bucket}/o {
    match /{allPaths=**} {
      // Allow authenticated users during development
      allow read, write: if request.auth != null;
    }
  }
}