feat: Enhance gallery creation with image upload and resizing functionality

lib/api.dart

···
 import 'package:http/http.dart' as http;
 import 'dart:convert';
 import 'package:grain/dpop_client.dart';
+import 'dart:io';
+import 'package:mime/mime.dart';
 
 class ApiService {
   String? _accessToken;
···
     final record = await xrpc.query(
       service: _apiUrl.replaceFirst(RegExp(r'^https?://'), ''),
       xrpc.NSID.create('notification.grain.social', 'getNotifications'),
-      headers: {'Authorization': "Bearer \\$_accessToken"},
+      headers: {'Authorization': "Bearer $_accessToken"},
       to: (json) =>
           (json['notifications'] as List<dynamic>?)
               ?.map(
···
       method: 'POST',
       url: url,
       accessToken: session.accessToken,
+      headers: {'Content-Type': 'application/json'},
       body: jsonEncode(record),
     );
     if (response.statusCode != 200 && response.statusCode != 201) {
       appLogger.w(
-        'Failed to create gallery: ${response.statusCode} ${response.body}',
+        'Failed to create gallery: \\${response.statusCode} \\${response.body}',
       );
-      throw Exception('Failed to create gallery: ${response.statusCode}');
+      throw Exception('Failed to create gallery: \\${response.statusCode}');
     }
     final result = jsonDecode(response.body) as Map<String, dynamic>;
     appLogger.i('Created gallery result: $result');
-    return result['uri'];
+    final uri = result['uri'] as String?;
+    return uri;
+  }
+
+  /// Polls the gallery until the number of items matches [expectedCount] or timeout.
+  /// Returns the Gallery if successful, or null if timeout.
+  Future<Gallery?> pollGalleryItems({
+    required String galleryUri,
+    required int expectedCount,
+    Duration pollDelay = const Duration(seconds: 2),
+    int maxAttempts = 20,
+  }) async {
+    int attempts = 0;
+    Gallery? gallery;
+    while (attempts < maxAttempts) {
+      gallery = await getGallery(uri: galleryUri);
+      if (gallery != null && gallery.items.length == expectedCount) {
+        appLogger.i(
+          'Gallery $galleryUri has expected number of items: $expectedCount',
+        );
+        return gallery;
+      }
+      await Future.delayed(pollDelay);
+      attempts++;
+    }
+    appLogger.w(
+      'Gallery $galleryUri did not reach expected items count ($expectedCount) after polling.',
+    );
+    return null;
+  }
+
+  /// Uploads a blob (file) to the atproto uploadBlob endpoint using DPoP authentication.
+  /// Returns the blob reference map on success, or null on failure.
+  Future<Map<String, dynamic>?> uploadBlob(File file) async {
+    final session = await auth.getValidSession();
+    if (session == null) {
+      appLogger.w('No valid session for uploadBlob');
+      return null;
+    }
+    final dpopClient = DpopHttpClient(dpopKey: session.dpopJwk);
+    final issuer = session.issuer;
+    final url = Uri.parse('$issuer/xrpc/com.atproto.repo.uploadBlob');
+
+    // Detect MIME type, fallback to application/octet-stream if unknown
+    String? mimeType = lookupMimeType(file.path);
+    final contentType = mimeType ?? 'application/octet-stream';
+
+    appLogger.i('Uploading blob: ${file.path} (MIME: $mimeType)');
+
+    final bytes = await file.readAsBytes();
+
+    final response = await dpopClient.send(
+      method: 'POST',
+      url: url,
+      accessToken: session.accessToken,
+      headers: {'Content-Type': contentType},
+      body: bytes,
+    );
+
+    if (response.statusCode != 200 && response.statusCode != 201) {
+      appLogger.w(
+        'Failed to upload blob: \\${response.statusCode} \\${response.body} (File: \\${file.path}, MIME: \\${mimeType})',
+      );
+      return null;
+    }
+
+    try {
+      final result = jsonDecode(response.body) as Map<String, dynamic>;
+      appLogger.i('Uploaded blob result: $result');
+      return result;
+    } catch (e, st) {
+      appLogger.e('Failed to parse uploadBlob response: $e', stackTrace: st);
+      return null;
+    }
+  }
+
+  Future<String?> createPhoto({
+    required Map<String, dynamic> blob,
+    required int width,
+    required int height,
+    String alt = '',
+  }) async {
+    final session = await auth.getValidSession();
+    if (session == null) {
+      appLogger.w('No valid session for createPhotoRecord');
+      return null;
+    }
+    final dpopClient = DpopHttpClient(dpopKey: session.dpopJwk);
+    final issuer = session.issuer;
+    final did = session.subject;
+    final url = Uri.parse('$issuer/xrpc/com.atproto.repo.createRecord');
+    final record = {
+      'collection': 'social.grain.photo',
+      'repo': did,
+      'record': {
+        'photo': blob['blob'],
+        'aspectRatio': {'width': width, 'height': height},
+        'alt': "",
+        'createdAt': DateTime.now().toUtc().toIso8601String(),
+      },
+    };
+    appLogger.i('Creating photo record: $record');
+    final response = await dpopClient.send(
+      method: 'POST',
+      url: url,
+      accessToken: session.accessToken,
+      headers: {'Content-Type': 'application/json'},
+      body: jsonEncode(record),
+    );
+    if (response.statusCode != 200 && response.statusCode != 201) {
+      appLogger.w(
+        'Failed to create photo record: \\${response.statusCode} \\${response.body}',
+      );
+      return null;
+    }
+    final result = jsonDecode(response.body) as Map<String, dynamic>;
+    appLogger.i('Created photo record result: $result');
+    return result['uri'] as String?;
+  }
+
+  Future<String?> createGalleryItem({
+    required String galleryUri,
+    required String photoUri,
+    required int position,
+  }) async {
+    final session = await auth.getValidSession();
+    if (session == null) {
+      appLogger.w('No valid session for createGalleryItem');
+      return null;
+    }
+    final dpopClient = DpopHttpClient(dpopKey: session.dpopJwk);
+    final issuer = session.issuer;
+    final did = session.subject;
+    final url = Uri.parse('$issuer/xrpc/com.atproto.repo.createRecord');
+    final record = {
+      'collection': 'social.grain.gallery.item',
+      'repo': did,
+      'record': {
+        'gallery': galleryUri,
+        'item': photoUri,
+        'position': position,
+        'createdAt': DateTime.now().toUtc().toIso8601String(),
+      },
+    };
+    appLogger.i('Creating gallery item: $record');
+    final response = await dpopClient.send(
+      method: 'POST',
+      url: url,
+      accessToken: session.accessToken,
+      headers: {'Content-Type': 'application/json'},
+      body: jsonEncode(record),
+    );
+    if (response.statusCode != 200 && response.statusCode != 201) {
+      appLogger.w(
+        'Failed to create gallery item: \\${response.statusCode} \\${response.body}',
+      );
+      return null;
+    }
+    final result = jsonDecode(response.body) as Map<String, dynamic>;
+    appLogger.i('Created gallery item result: $result');
+    return result['uri'] as String?;
   }
 }
 

lib/auth.dart

···
 import 'package:grain/main.dart';
 import 'package:flutter_web_auth_2/flutter_web_auth_2.dart';
 import 'package:grain/models/atproto_session.dart';
-import 'package:jose/jose.dart';
-import 'package:uuid/uuid.dart';
-import 'package:http/http.dart' as http;
-import 'package:crypto/crypto.dart';
 
 class Auth {
   static const _storage = FlutterSecureStorage();
···
   }
 
   Future<AtprotoSession?> getValidSession() async {
-    final session = await _loadSession();
+    var session = await _loadSession();
     if (session == null || isSessionExpired(session)) {
-      appLogger.w('Session is expired or not found');
-      // Try refresh or return null
-      return null;
+      appLogger.w('Session is expired or not found, attempting refresh');
+      // Try to refresh session by calling fetchSession
+      try {
+        final refreshed = await apiService.fetchSession();
+        if (refreshed != null && !isSessionExpired(refreshed)) {
+          await _saveSession(refreshed);
+          appLogger.i('Session refreshed and saved');
+          return refreshed;
+        } else {
+          appLogger.w('Session refresh failed or still expired');
+          return null;
+        }
+      } catch (e) {
+        appLogger.e('Error refreshing session: $e');
+        return null;
+      }
     }
     return session;
   }

lib/dpop_client.dart

···
       ath: ath,
     );
 
+    // Compose headers, allowing override of Content-Type for raw uploads
     final requestHeaders = <String, String>{
       'Authorization': 'DPoP $accessToken',
       'DPoP': proof,
-      'Content-Type': 'application/json',
       if (headers != null) ...headers,
     };
 
···
         response = await http.put(url, headers: requestHeaders, body: body);
         break;
       case 'DELETE':
-        response = await http.delete(url, headers: requestHeaders);
+        response = await http.delete(url, headers: requestHeaders, body: body);
         break;
       default:
         throw UnsupportedError('Unsupported HTTP method: $method');

lib/main.dart

···
 import 'package:grain/app_logger.dart';
 import 'package:grain/screens/splash_page.dart';
 import 'package:grain/screens/home_page.dart';
-import 'package:grain/auth.dart';
 
 class AppConfig {
   static late final String apiUrl;

lib/screens/create_gallery_page.dart

···
+import 'dart:async';
 import 'dart:io';
+import 'dart:ui' as ui;
 import 'package:flutter/material.dart';
 import 'package:grain/api.dart';
 import 'package:image_picker/image_picker.dart';
 import 'package:grain/widgets/plain_text_field.dart';
 import 'package:grain/widgets/app_button.dart';
 import 'gallery_page.dart';
+import 'package:grain/photo_manip.dart';
+import 'package:flutter/foundation.dart';
 
 class CreateGalleryPage extends StatefulWidget {
   const CreateGalleryPage({super.key});
···
     setState(() {
       _images.removeAt(index);
     });
+  }
+
+  Future<Map<String, int>> _getImageDimensions(XFile xfile) async {
+    final bytes = await xfile.readAsBytes();
+    final completer = Completer<Map<String, int>>();
+    ui.decodeImageFromList(bytes, (image) {
+      completer.complete({'width': image.width, 'height': image.height});
+    });
+    return completer.future;
   }
 
   Future<void> _submit() async {
     setState(() => _submitting = true);
+    final List<String> photoUris = [];
+    for (final xfile in _images) {
+      final file = File(xfile.path);
+      // Use compute to run resizeImage in a background isolate
+      final resizedResult = await compute<File, ResizeResult>(
+        (f) => resizeImage(file: f),
+        file,
+      );
+      final blobResult = await apiService.uploadBlob(resizedResult.file);
+      if (blobResult != null) {
+        final dims = await _getImageDimensions(xfile);
+        final photoUri = await apiService.createPhoto(
+          blob: blobResult,
+          width: dims['width']!,
+          height: dims['height']!,
+        );
+        if (photoUri != null) {
+          photoUris.add(photoUri);
+        }
+      }
+    }
     final galleryUri = await apiService.createGallery(
       title: _titleController.text.trim(),
       description: _descController.text.trim(),
     );
+    // Link photos to gallery as gallery items
+    if (galleryUri != null) {
+      for (int i = 0; i < photoUris.length; i++) {
+        await apiService.createGalleryItem(
+          galleryUri: galleryUri,
+          photoUri: photoUris[i],
+          position: i,
+        );
+      }
+    }
+    if (galleryUri != null) {
+      await apiService.pollGalleryItems(
+        galleryUri: galleryUri,
+        expectedCount: photoUris.length,
+      );
+    }
     setState(() => _submitting = false);
     if (mounted && galleryUri != null) {
       Navigator.of(context).pop();

lib/screens/home_page.dart

···
         ),
         floatingActionButton:
             (!showProfile && !showNotifications && !showExplore)
-            ? FloatingActionButton(
-                onPressed: () {
-                  showModalBottomSheet(
-                    context: context,
-                    isScrollControlled: true,
-                    builder: (context) => CreateGalleryPage(),
-                  );
-                },
-                backgroundColor: const Color(0xFF0EA5E9),
-                foregroundColor: Colors.white,
-                child: const Icon(Icons.add_a_photo),
-                tooltip: 'Create Gallery',
-              )
-            : null,
+                ? FloatingActionButton(
+                    shape: const CircleBorder(),
+                    onPressed: () {
+                      showModalBottomSheet(
+                        context: context,
+                        isScrollControlled: true,
+                        builder: (context) => CreateGalleryPage(),
+                      );
+                    },
+                    backgroundColor: const Color(0xFF0EA5E9),
+                    foregroundColor: Colors.white,
+                    child: const Icon(Icons.add_a_photo),
+                    tooltip: 'Create Gallery',
+                  )
+                : null,
       );
     }
     // Explore, Notifications, Profile: no tabs, no TabController

pubspec.lock

···
 # Generated by pub
 # See https://dart.dev/tools/pub/glossary#lockfile
 packages:
+  archive:
+    dependency: transitive
+    description:
+      name: archive
+      sha256: "2fde1607386ab523f7a36bb3e7edb43bd58e6edaf2ffb29d8a6d578b297fdbbd"
+      url: "https://pub.dev"
+    source: hosted
+    version: "4.0.7"
   asn1lib:
     dependency: transitive
     description:
···
       url: "https://pub.dev"
     source: hosted
     version: "4.1.2"
+  image:
+    dependency: "direct main"
+    description:
+      name: image
+      sha256: "4e973fcf4caae1a4be2fa0a13157aa38a8f9cb049db6529aa00b4d71abc4d928"
+      url: "https://pub.dev"
+    source: hosted
+    version: "4.5.4"
   image_picker:
     dependency: "direct main"
     description:
···
     source: hosted
     version: "1.16.0"
   mime:
-    dependency: transitive
+    dependency: "direct main"
     description:
       name: mime
       sha256: "801fd0b26f14a4a58ccb09d5892c3fbdeff209594300a542492cf13fba9d247a"
···
       url: "https://pub.dev"
     source: hosted
     version: "2.3.0"
+  petitparser:
+    dependency: transitive
+    description:
+      name: petitparser
+      sha256: "07c8f0b1913bcde1ff0d26e57ace2f3012ccbf2b204e070290dad3bb22797646"
+      url: "https://pub.dev"
+    source: hosted
+    version: "6.1.0"
   platform:
     dependency: transitive
     description:
···
       url: "https://pub.dev"
     source: hosted
     version: "3.9.1"
+  posix:
+    dependency: transitive
+    description:
+      name: posix
+      sha256: "6323a5b0fa688b6a010df4905a56b00181479e6d10534cecfecede2aa55add61"
+      url: "https://pub.dev"
+    source: hosted
+    version: "6.0.3"
   quiver:
     dependency: transitive
     description:
···
       url: "https://pub.dev"
     source: hosted
     version: "1.1.0"
+  xml:
+    dependency: transitive
+    description:
+      name: xml
+      sha256: b015a8ad1c488f66851d762d3090a21c600e479dc75e68328c52774040cf9226
+      url: "https://pub.dev"
+    source: hosted
+    version: "6.5.0"
   xrpc:
     dependency: "direct main"
     description:

pubspec.yaml

···
   uuid: ^4.5.1
   crypto: ^3.0.6
   xrpc: ^0.6.1
+  mime: ^1.0.6
+  image: ^4.5.4
 
 dev_dependencies:
   flutter_test: