handle error

mobile/ios/Runner/AppDelegate.swift

@@ -55,6 +55,7 @@ import UIKit
     NativeSyncApiImpl.register(with: engine.registrar(forPlugin: NativeSyncApiImpl.name)!)
     ThumbnailApiSetup.setUp(binaryMessenger: engine.binaryMessenger, api: ThumbnailApiImpl())
     BackgroundWorkerFgHostApiSetup.setUp(binaryMessenger: engine.binaryMessenger, api: BackgroundWorkerApiImpl())
+    ConnectivityApiSetup.setUp(binaryMessenger: engine.binaryMessenger, api: ConnectivityApiImpl())
   }
   
   public static func cancelPlugins(with engine: FlutterEngine) {

mobile/ios/Runner/Connectivity/ConnectivityApiImpl.swift

@@ -1,6 +1,68 @@
+import Network
 
 class ConnectivityApiImpl: ConnectivityApi {
+  private let monitor = NWPathMonitor()
+  private let queue = DispatchQueue(label: "ConnectivityMonitor")
+  private var currentPath: NWPath?
+  
+  init() {
+    monitor.pathUpdateHandler = { [weak self] path in
+      self?.currentPath = path
+      print("[ConnectivityApi] Network status changed:")
+      print("  - Status: \(path.status)")
+      print("  - isExpensive: \(path.isExpensive)")
+      print("  - isConstrained: \(path.isConstrained)")
+      print("  - usesWifi: \(path.usesInterfaceType(.wifi))")
+      print("  - usesCellular: \(path.usesInterfaceType(.cellular))")
+    }
+    monitor.start(queue: queue)
+    // Get initial state synchronously
+    currentPath = monitor.currentPath
+    print("[ConnectivityApi] Initialized with path: \(String(describing: currentPath))")
+  }
+  
+  deinit {
+    monitor.cancel()
+  }
+  
   func getCapabilities() throws -> [NetworkCapability] {
-    []
+    guard let path = currentPath else {
+      return []
+    }
+    
+    guard path.status == .satisfied else {
+      return []
+    }
+    
+    var capabilities: [NetworkCapability] = []
+    
+    if path.usesInterfaceType(.wifi) {
+      capabilities.append(.wifi)
+    }
+    
+    if path.usesInterfaceType(.cellular) {
+      capabilities.append(.cellular)
+    }
+    
+    // Check for VPN - iOS reports VPN as .other interface type in many cases
+    // or through the path's expensive property when on cellular with VPN
+    if path.usesInterfaceType(.other) {
+      capabilities.append(.vpn)
+    }
+    
+    // Determine if connection is unmetered:
+    // - Must be on WiFi (not cellular)
+    // - Must not be expensive (rules out personal hotspot)
+    // - Must not be constrained (Low Data Mode)
+    // Note: VPN over cellular should still be considered metered
+    let isOnCellular = path.usesInterfaceType(.cellular)
+    let isOnWifi = path.usesInterfaceType(.wifi)
+    
+    if isOnWifi && !isOnCellular && !path.isExpensive && !path.isConstrained {
+      capabilities.append(.unmetered)
+    }
+    
+    print("[ConnectivityApi] getCapabilities() returning: \\(capabilities)")
+    return capabilities
   }
 }

mobile/lib/domain/services/background_worker.service.dart

@@ -243,13 +243,21 @@ class BackgroundWorkerBgService extends BackgroundWorkerFlutterApi {
         }
 
         if (Platform.isIOS) {
-          return _ref?.read(driftBackupProvider.notifier).handleBackupResume(currentUser.id);
+          return _ref?.read(driftBackupProvider.notifier).startBackupWithURLSession(currentUser.id);
         }
 
         final networkCapabilities = await _ref?.read(connectivityApiProvider).getCapabilities() ?? [];
         return _ref
             ?.read(uploadServiceProvider)
-            .startBackupWithHttpClient(currentUser.id, networkCapabilities.isUnmetered, _cancellationToken);
+            .startUploadWithHttp(
+              currentUser.id,
+              networkCapabilities.isUnmetered,
+              _cancellationToken,
+              onProgress: (_, __, ___, ____) {},
+              onSuccess: (_, __) {},
+              onError: (_, __) {},
+              onICloudProgress: (_, __) {},
+            );
       },
       (error, stack) {
         dPrint(() => "Error in backup zone $error, $stack");

mobile/lib/infrastructure/repositories/storage.repository.dart

@@ -6,7 +6,9 @@ import 'package:logging/logging.dart';
 import 'package:photo_manager/photo_manager.dart';
 
 class StorageRepository {
-  const StorageRepository();
+  final log = Logger('StorageRepository');
+
+  StorageRepository();
 
   Future<File?> getFileForAsset(String assetId) async {
     File? file;
@@ -82,6 +84,51 @@ class StorageRepository {
     return entity;
   }
 
+  Future<bool> isAssetAvailableLocally(String assetId) async {
+    try {
+      final entity = await AssetEntity.fromId(assetId);
+      if (entity == null) {
+        log.warning("Cannot get AssetEntity for asset $assetId");
+        return false;
+      }
+
+      return await entity.isLocallyAvailable(isOrigin: true);
+    } catch (error, stackTrace) {
+      log.warning("Error checking if asset is locally available $assetId", error, stackTrace);
+      return false;
+    }
+  }
+
+  Future<File?> loadFileFromCloud(String assetId, {PMProgressHandler? progressHandler}) async {
+    try {
+      final entity = await AssetEntity.fromId(assetId);
+      if (entity == null) {
+        log.warning("Cannot get AssetEntity for asset $assetId");
+        return null;
+      }
+
+      return await entity.loadFile(progressHandler: progressHandler);
+    } catch (error, stackTrace) {
+      log.warning("Error loading file from cloud for asset $assetId", error, stackTrace);
+      return null;
+    }
+  }
+
+  Future<File?> loadMotionFileFromCloud(String assetId, {PMProgressHandler? progressHandler}) async {
+    try {
+      final entity = await AssetEntity.fromId(assetId);
+      if (entity == null) {
+        log.warning("Cannot get AssetEntity for asset $assetId");
+        return null;
+      }
+
+      return await entity.loadFile(withSubtype: true, progressHandler: progressHandler);
+    } catch (error, stackTrace) {
+      log.warning("Error loading motion file from cloud for asset $assetId", error, stackTrace);
+      return null;
+    }
+  }
+
   Future<void> clearCache() async {
     final log = Logger('StorageRepository');
 

mobile/lib/pages/backup/drift_backup.page.dart

@@ -93,11 +93,11 @@ class _DriftBackupPageState extends ConsumerState<DriftBackupPage> {
         Logger("DriftBackupPage").warning("Remote sync did not complete successfully, skipping backup");
         return;
       }
-      await backupNotifier.startBackup(currentUser.id);
+      await backupNotifier.startForegroundBackup(currentUser.id);
     }
 
     Future<void> stopBackup() async {
-      await backupNotifier.cancel();
+      await backupNotifier.stopForegroundBackup();
     }
 
     return Scaffold(

mobile/lib/pages/backup/drift_backup_album_selection.page.dart

@@ -113,10 +113,10 @@ class _DriftBackupAlbumSelectionPageState extends ConsumerState<DriftBackupAlbum
             unawaited(nativeSync.cancelHashing().whenComplete(() => backgroundSync.hashAssets()));
             if (isBackupEnabled) {
               unawaited(
-                backupNotifier.cancel().whenComplete(
+                backupNotifier.stopForegroundBackup().whenComplete(
                   () => backgroundSync.syncRemote().then((success) {
                     if (success) {
-                      return backupNotifier.startBackup(user.id);
+                      return backupNotifier.startForegroundBackup(user.id);
                     } else {
                       Logger('DriftBackupAlbumSelectionPage').warning('Background sync failed, not starting backup');
                     }

mobile/lib/pages/backup/drift_backup_options.page.dart

@@ -60,10 +60,10 @@ class DriftBackupOptionsPage extends ConsumerWidget {
           final backupNotifier = ref.read(driftBackupProvider.notifier);
           final backgroundSync = ref.read(backgroundSyncProvider);
           unawaited(
-            backupNotifier.cancel().whenComplete(
+            backupNotifier.stopForegroundBackup().whenComplete(
               () => backgroundSync.syncRemote().then((success) {
                 if (success) {
-                  return backupNotifier.startBackup(currentUser.id);
+                  return backupNotifier.startForegroundBackup(currentUser.id);
                 } else {
                   Logger('DriftBackupOptionsPage').warning('Background sync failed, not starting backup');
                 }

mobile/lib/pages/backup/drift_upload_detail.page.dart

@@ -11,12 +11,50 @@ import 'package:immich_mobile/utils/bytes_units.dart';
 import 'package:path/path.dart' as path;
 
 @RoutePage()
-class DriftUploadDetailPage extends ConsumerWidget {
+class DriftUploadDetailPage extends ConsumerStatefulWidget {
   const DriftUploadDetailPage({super.key});
 
   @override
-  Widget build(BuildContext context, WidgetRef ref) {
+  ConsumerState<DriftUploadDetailPage> createState() => _DriftUploadDetailPageState();
+}
+
+class _DriftUploadDetailPageState extends ConsumerState<DriftUploadDetailPage> {
+  final List<DriftUploadStatus> _completedItems = [];
+  final Set<String> _seenTaskIds = {};
+  final Set<String> _failedTaskIds = {};
+
+  @override
+  Widget build(BuildContext context) {
     final uploadItems = ref.watch(driftBackupProvider.select((state) => state.uploadItems));
+    final iCloudProgress = ref.watch(driftBackupProvider.select((state) => state.iCloudDownloadProgress));
+
+    // Track failed items to exclude them from completed list
+    for (final item in uploadItems.values) {
+      if (item.isFailed == true) {
+        _failedTaskIds.add(item.taskId);
+      }
+    }
+
+    // Remove any items from completed list that have since failed
+    _completedItems.removeWhere((item) => _failedTaskIds.contains(item.taskId));
+
+    // Watch for items with progress >= 1.0 (completed successfully) before they get removed
+    for (final item in uploadItems.values) {
+      if (item.progress >= 1.0 && item.isFailed != true && !_failedTaskIds.contains(item.taskId)) {
+        if (!_seenTaskIds.contains(item.taskId)) {
+          _seenTaskIds.add(item.taskId);
+          _completedItems.insert(0, item);
+          if (_completedItems.length > 50) {
+            _completedItems.removeLast();
+          }
+        }
+      }
+    }
+
+    // Get current uploading items (progress < 1.0 or failed)
+    final currentUploads = uploadItems.values.where((item) => item.progress < 1.0 || item.isFailed == true).toList();
+
+    final hasContent = currentUploads.isNotEmpty || iCloudProgress.isNotEmpty || _completedItems.isNotEmpty;
 
     return Scaffold(
       appBar: AppBar(
@@ -24,8 +62,24 @@ class DriftUploadDetailPage extends ConsumerWidget {
         backgroundColor: context.colorScheme.surface,
         elevation: 0,
         scrolledUnderElevation: 1,
+        actions: [
+          if (_completedItems.isNotEmpty)
+            IconButton(
+              icon: const Icon(Icons.clear_all),
+              tooltip: "Clear completed",
+              onPressed: () {
+                setState(() {
+                  _completedItems.clear();
+                  _seenTaskIds.clear();
+                  _failedTaskIds.clear();
+                });
+              },
+            ),
+        ],
       ),
-      body: uploadItems.isEmpty ? _buildEmptyState(context) : _buildUploadList(uploadItems),
+      body: !hasContent
+          ? _buildEmptyState(context)
+          : _buildTwoSectionLayout(context, currentUploads, iCloudProgress, _completedItems),
     );
   }
 
@@ -45,77 +99,308 @@ class DriftUploadDetailPage extends ConsumerWidget {
     );
   }
 
-  Widget _buildUploadList(Map<String, DriftUploadStatus> uploadItems) {
-    return ListView.separated(
-      addAutomaticKeepAlives: true,
-      padding: const EdgeInsets.all(16),
-      itemCount: uploadItems.length,
-      separatorBuilder: (context, index) => const SizedBox(height: 4),
-      itemBuilder: (context, index) {
-        final item = uploadItems.values.elementAt(index);
-        return _buildUploadCard(context, item);
-      },
+  Widget _buildTwoSectionLayout(
+    BuildContext context,
+    List<DriftUploadStatus> currentUploads,
+    Map<String, double> iCloudProgress,
+    List<DriftUploadStatus> completedItems,
+  ) {
+    return CustomScrollView(
+      slivers: [
+        // iCloud Downloads Section
+        if (iCloudProgress.isNotEmpty) ...[
+          SliverToBoxAdapter(
+            child: _buildSectionHeader(
+              context,
+              title: "Downloading from iCloud",
+              count: iCloudProgress.length,
+              color: context.colorScheme.tertiary,
+            ),
+          ),
+          SliverPadding(
+            padding: const EdgeInsets.symmetric(horizontal: 16),
+            sliver: SliverList(
+              delegate: SliverChildBuilderDelegate((context, index) {
+                final entry = iCloudProgress.entries.elementAt(index);
+                return Padding(
+                  padding: const EdgeInsets.only(bottom: 8),
+                  child: _buildICloudDownloadCard(context, entry.key, entry.value),
+                );
+              }, childCount: iCloudProgress.length),
+            ),
+          ),
+        ],
+
+        SliverToBoxAdapter(
+          child: _buildSectionHeader(
+            context,
+            title: "uploading".t(context: context),
+            color: context.colorScheme.primary,
+          ),
+        ),
+        SliverPadding(
+          padding: const EdgeInsets.symmetric(horizontal: 16),
+          sliver: SliverList(
+            delegate: SliverChildBuilderDelegate((context, index) {
+              if (index < currentUploads.length) {
+                final item = currentUploads[index];
+                return _buildCurrentUploadCard(context, item);
+              } else {
+                return _buildPlaceholderCard(context);
+              }
+            }, childCount: 3),
+          ),
+        ),
+
+        // Completed Section
+        if (completedItems.isNotEmpty) ...[
+          SliverToBoxAdapter(
+            child: _buildSectionHeader(
+              context,
+              title: "completed".t(context: context),
+              count: completedItems.length,
+              color: Colors.green,
+            ),
+          ),
+          SliverPadding(
+            padding: const EdgeInsets.symmetric(horizontal: 16),
+            sliver: SliverList(
+              delegate: SliverChildBuilderDelegate((context, index) {
+                final item = completedItems[index];
+                return Padding(padding: const EdgeInsets.only(bottom: 4), child: _buildCompletedCard(context, item));
+              }, childCount: completedItems.length),
+            ),
+          ),
+        ],
+
+        // Bottom padding
+        const SliverToBoxAdapter(child: SizedBox(height: 24)),
+      ],
     );
   }
 
-  Widget _buildUploadCard(BuildContext context, DriftUploadStatus item) {
-    final isCompleted = item.progress >= 1.0;
-    final double progressPercentage = (item.progress * 100).clamp(0, 100);
+  Widget _buildSectionHeader(BuildContext context, {required String title, int? count, required Color color}) {
+    return Padding(
+      padding: const EdgeInsets.fromLTRB(16, 16, 16, 8),
+      child: Row(
+        crossAxisAlignment: CrossAxisAlignment.start,
+        children: [
+          Text(
+            title,
+            style: context.textTheme.titleSmall?.copyWith(fontWeight: FontWeight.w600, color: color),
+          ),
+          const SizedBox(width: 8),
+          count != null
+              ? Container(
+                  padding: const EdgeInsets.symmetric(horizontal: 8, vertical: 2),
+                  decoration: BoxDecoration(
+                    color: color.withValues(alpha: 0.15),
+                    borderRadius: const BorderRadius.all(Radius.circular(12)),
+                  ),
+                  child: Text(
+                    count.toString(),
+                    style: context.textTheme.labelSmall?.copyWith(fontWeight: FontWeight.bold, color: color),
+                  ),
+                )
+              : const SizedBox.shrink(),
+        ],
+      ),
+    );
+  }
+
+  Widget _buildICloudDownloadCard(BuildContext context, String assetId, double progress) {
+    final double progressPercentage = (progress * 100).clamp(0, 100);
 
     return Card(
       elevation: 0,
-      color: item.isFailed != null ? context.colorScheme.errorContainer : context.colorScheme.surfaceContainer,
+      color: context.colorScheme.tertiaryContainer.withValues(alpha: 0.5),
       shape: RoundedRectangleBorder(
-        borderRadius: const BorderRadius.all(Radius.circular(16)),
+        borderRadius: const BorderRadius.all(Radius.circular(12)),
+        side: BorderSide(color: context.colorScheme.tertiary.withValues(alpha: 0.3), width: 1),
+      ),
+      child: Padding(
+        padding: const EdgeInsets.all(12),
+        child: Row(
+          children: [
+            Container(
+              width: 40,
+              height: 40,
+              decoration: BoxDecoration(
+                color: context.colorScheme.tertiary.withValues(alpha: 0.2),
+                borderRadius: const BorderRadius.all(Radius.circular(8)),
+              ),
+              child: Icon(Icons.cloud_download_rounded, size: 24, color: context.colorScheme.tertiary),
+            ),
+            const SizedBox(width: 12),
+            Expanded(
+              child: Column(
+                crossAxisAlignment: CrossAxisAlignment.start,
+                children: [
+                  Text(
+                    "Downloading from iCloud...",
+                    style: context.textTheme.bodyMedium?.copyWith(fontWeight: FontWeight.w500),
+                    maxLines: 1,
+                    overflow: TextOverflow.ellipsis,
+                  ),
+                  const SizedBox(height: 4),
+                  Text(
+                    assetId,
+                    style: context.textTheme.bodySmall?.copyWith(
+                      color: context.colorScheme.onSurface.withValues(alpha: 0.6),
+                    ),
+                    maxLines: 1,
+                    overflow: TextOverflow.ellipsis,
+                  ),
+                  const SizedBox(height: 8),
+                  ClipRRect(
+                    borderRadius: const BorderRadius.all(Radius.circular(4)),
+                    child: LinearProgressIndicator(
+                      value: progress,
+                      backgroundColor: context.colorScheme.tertiary.withValues(alpha: 0.2),
+                      valueColor: AlwaysStoppedAnimation(context.colorScheme.tertiary),
+                      minHeight: 4,
+                    ),
+                  ),
+                ],
+              ),
+            ),
+            const SizedBox(width: 12),
+            SizedBox(
+              width: 48,
+              child: Text(
+                "${progressPercentage.toStringAsFixed(0)}%",
+                textAlign: TextAlign.right,
+                style: context.textTheme.titleMedium?.copyWith(
+                  fontWeight: FontWeight.bold,
+                  color: context.colorScheme.tertiary,
+                ),
+              ),
+            ),
+          ],
+        ),
+      ),
+    );
+  }
+
+  Widget _buildCurrentUploadCard(BuildContext context, DriftUploadStatus item) {
+    final double progressPercentage = (item.progress * 100).clamp(0, 100);
+    final isFailed = item.isFailed == true;
+
+    return Card(
+      elevation: 0,
+      color: isFailed
+          ? context.colorScheme.errorContainer
+          : context.colorScheme.primaryContainer.withValues(alpha: 0.5),
+      shape: RoundedRectangleBorder(
+        borderRadius: const BorderRadius.all(Radius.circular(12)),
+        side: BorderSide(
+          color: isFailed
+              ? context.colorScheme.error.withValues(alpha: 0.3)
+              : context.colorScheme.primary.withValues(alpha: 0.3),
+          width: 1,
+        ),
+      ),
+      child: InkWell(
+        onTap: () => _showFileDetailDialog(context, item),
+        borderRadius: const BorderRadius.all(Radius.circular(12)),
+        child: Padding(
+          padding: const EdgeInsets.all(12),
+          child: SizedBox(
+            height: 64,
+            child: Row(
+              children: [
+                _CurrentUploadThumbnail(taskId: item.taskId),
+                const SizedBox(width: 12),
+                Expanded(
+                  child: Column(
+                    crossAxisAlignment: CrossAxisAlignment.start,
+                    children: [
+                      Text(
+                        path.basename(item.filename),
+                        style: context.textTheme.bodyMedium?.copyWith(fontWeight: FontWeight.w600),
+                        maxLines: 1,
+                        overflow: TextOverflow.ellipsis,
+                      ),
+                      const SizedBox(height: 2),
+                      Text(
+                        isFailed
+                            ? item.error ?? "Upload failed"
+                            : "${formatHumanReadableBytes(item.fileSize, 1)} • ${item.networkSpeedAsString}",
+                        style: context.textTheme.labelLarge?.copyWith(
+                          color: isFailed
+                              ? context.colorScheme.error
+                              : context.colorScheme.onSurface.withValues(alpha: 0.6),
+                        ),
+                        maxLines: 2,
+                        overflow: TextOverflow.ellipsis,
+                      ),
+                      if (!isFailed) ...[
+                        const SizedBox(height: 8),
+                        ClipRRect(
+                          borderRadius: const BorderRadius.all(Radius.circular(4)),
+                          child: LinearProgressIndicator(
+                            value: item.progress,
+                            backgroundColor: context.colorScheme.primary.withValues(alpha: 0.2),
+                            valueColor: AlwaysStoppedAnimation(context.colorScheme.primary),
+                            minHeight: 4,
+                          ),
+                        ),
+                      ],
+                    ],
+                  ),
+                ),
+                const SizedBox(width: 12),
+                SizedBox(
+                  width: 48,
+                  child: isFailed
+                      ? Icon(Icons.error_rounded, color: context.colorScheme.error, size: 28)
+                      : Text(
+                          "${progressPercentage.toStringAsFixed(0)}%",
+                          textAlign: TextAlign.right,
+                          style: context.textTheme.titleMedium?.copyWith(
+                            fontWeight: FontWeight.bold,
+                            color: context.colorScheme.primary,
+                          ),
+                        ),
+                ),
+              ],
+            ),
+          ),
+        ),
+      ),
+    );
+  }
+
+  Widget _buildCompletedCard(BuildContext context, DriftUploadStatus item) {
+    return Card(
+      elevation: 0,
+      color: context.colorScheme.surfaceContainerLow,
+      shape: RoundedRectangleBorder(
+        borderRadius: const BorderRadius.all(Radius.circular(8)),
         side: BorderSide(color: context.colorScheme.outline.withValues(alpha: 0.1), width: 1),
       ),
       child: InkWell(
         onTap: () => _showFileDetailDialog(context, item),
-        borderRadius: const BorderRadius.all(Radius.circular(16)),
+        borderRadius: const BorderRadius.all(Radius.circular(8)),
         child: Padding(
-          padding: const EdgeInsets.all(16),
-          child: Column(
-            crossAxisAlignment: CrossAxisAlignment.start,
+          padding: const EdgeInsets.symmetric(horizontal: 12, vertical: 8),
+          child: Row(
             children: [
-              Row(
-                children: [
-                  Expanded(
-                    child: Column(
-                      crossAxisAlignment: CrossAxisAlignment.start,
-                      spacing: 4,
-                      children: [
-                        Text(
-                          path.basename(item.filename),
-                          style: context.textTheme.titleSmall?.copyWith(fontWeight: FontWeight.w600),
-                          maxLines: 1,
-                          overflow: TextOverflow.ellipsis,
-                        ),
-                        if (item.error != null)
-                          Text(
-                            item.error!,
-                            style: context.textTheme.bodySmall?.copyWith(
-                              color: context.colorScheme.onErrorContainer.withValues(alpha: 0.6),
-                            ),
-                          ),
-                        Text(
-                          "backup_upload_details_page_more_details".t(context: context),
-                          style: context.textTheme.bodySmall?.copyWith(
-                            color: context.colorScheme.onSurface.withValues(alpha: 0.6),
-                          ),
-                          maxLines: 1,
-                          overflow: TextOverflow.ellipsis,
-                        ),
-                      ],
-                    ),
-                  ),
-                  _buildProgressIndicator(
-                    context,
-                    item.progress,
-                    progressPercentage,
-                    isCompleted,
-                    item.networkSpeedAsString,
-                  ),
-                ],
+              Icon(Icons.check_circle, size: 20, color: Colors.green.shade600),
+              const SizedBox(width: 12),
+              Expanded(
+                child: Text(
+                  path.basename(item.filename),
+                  style: context.textTheme.bodySmall,
+                  maxLines: 1,
+                  overflow: TextOverflow.ellipsis,
+                ),
+              ),
+              Text(
+                formatHumanReadableBytes(item.fileSize, 1),
+                style: context.textTheme.bodySmall?.copyWith(
+                  color: context.colorScheme.onSurface.withValues(alpha: 0.5),
+                ),
               ),
             ],
           ),
@@ -124,49 +409,84 @@ class DriftUploadDetailPage extends ConsumerWidget {
     );
   }
 
-  Widget _buildProgressIndicator(
-    BuildContext context,
-    double progress,
-    double percentage,
-    bool isCompleted,
-    String networkSpeedAsString,
-  ) {
-    return Column(
-      children: [
-        Stack(
-          alignment: AlignmentDirectional.center,
-          children: [
-            SizedBox(
-              width: 36,
-              height: 36,
-              child: TweenAnimationBuilder(
-                tween: Tween<double>(begin: 0.0, end: progress),
-                duration: const Duration(milliseconds: 300),
-                builder: (context, value, _) => CircularProgressIndicator(
-                  backgroundColor: context.colorScheme.outline.withValues(alpha: 0.2),
-                  strokeWidth: 3,
-                  value: value,
-                  color: isCompleted ? context.colorScheme.primary : context.colorScheme.secondary,
+  Widget _buildPlaceholderCard(BuildContext context) {
+    return Card(
+      elevation: 0,
+      color: context.colorScheme.surfaceContainerLow.withValues(alpha: 0.5),
+      shape: RoundedRectangleBorder(
+        borderRadius: const BorderRadius.all(Radius.circular(12)),
+        side: BorderSide(color: context.colorScheme.outline.withValues(alpha: 0.1), width: 1, style: BorderStyle.solid),
+      ),
+      child: Padding(
+        padding: const EdgeInsets.all(12),
+        child: SizedBox(
+          height: 64,
+          child: Row(
+            children: [
+              SizedBox(
+                width: 48,
+                height: 48,
+                child: Container(
+                  decoration: BoxDecoration(
+                    color: context.colorScheme.outline.withValues(alpha: 0.1),
+                    borderRadius: const BorderRadius.all(Radius.circular(8)),
+                  ),
+                  child: Icon(
+                    Icons.hourglass_empty_rounded,
+                    size: 24,
+                    color: context.colorScheme.outline.withValues(alpha: 0.3),
+                  ),
                 ),
               ),
-            ),
-            if (isCompleted)
-              Icon(Icons.check_circle_rounded, size: 28, color: context.colorScheme.primary)
-            else
-              Text(
-                percentage.toStringAsFixed(0),
-                style: context.textTheme.labelSmall?.copyWith(fontWeight: FontWeight.bold, fontSize: 10),
+              const SizedBox(width: 12),
+              Expanded(
+                child: Column(
+                  crossAxisAlignment: CrossAxisAlignment.start,
+                  children: [
+                    Container(
+                      height: 14,
+                      width: 120,
+                      decoration: BoxDecoration(
+                        color: context.colorScheme.outline.withValues(alpha: 0.1),
+                        borderRadius: const BorderRadius.all(Radius.circular(4)),
+                      ),
+                    ),
+                    const SizedBox(height: 6),
+                    Container(
+                      height: 10,
+                      width: 80,
+                      decoration: BoxDecoration(
+                        color: context.colorScheme.outline.withValues(alpha: 0.08),
+                        borderRadius: const BorderRadius.all(Radius.circular(4)),
+                      ),
+                    ),
+                    const SizedBox(height: 8),
+                    Container(
+                      height: 4,
+                      decoration: BoxDecoration(
+                        color: context.colorScheme.outline.withValues(alpha: 0.1),
+                        borderRadius: const BorderRadius.all(Radius.circular(4)),
+                      ),
+                    ),
+                  ],
+                ),
               ),
-          ],
-        ),
-        Text(
-          networkSpeedAsString,
-          style: context.textTheme.labelSmall?.copyWith(
-            color: context.colorScheme.onSurface.withValues(alpha: 0.6),
-            fontSize: 10,
+              const SizedBox(width: 12),
+              SizedBox(
+                width: 48,
+                child: Text(
+                  "0%",
+                  textAlign: TextAlign.right,
+                  style: context.textTheme.titleMedium?.copyWith(
+                    fontWeight: FontWeight.bold,
+                    color: context.colorScheme.outline.withValues(alpha: 0.3),
+                  ),
+                ),
+              ),
+            ],
           ),
         ),
-      ],
+      ),
     );
   }
 
@@ -178,9 +498,44 @@ class DriftUploadDetailPage extends ConsumerWidget {
   }
 }
 
+class _CurrentUploadThumbnail extends ConsumerWidget {
+  final String taskId;
+  const _CurrentUploadThumbnail({required this.taskId});
+
+  @override
+  Widget build(BuildContext context, WidgetRef ref) {
+    return FutureBuilder<LocalAsset?>(
+      future: _getAsset(ref),
+      builder: (context, snapshot) {
+        return SizedBox(
+          width: 48,
+          height: 48,
+          child: Container(
+            decoration: BoxDecoration(
+              color: context.colorScheme.primary.withValues(alpha: 0.2),
+              borderRadius: const BorderRadius.all(Radius.circular(8)),
+            ),
+            clipBehavior: Clip.antiAlias,
+            child: snapshot.data != null
+                ? Thumbnail.fromAsset(asset: snapshot.data!, size: const Size(48, 48), fit: BoxFit.cover)
+                : Icon(Icons.image, size: 24, color: context.colorScheme.primary),
+          ),
+        );
+      },
+    );
+  }
+
+  Future<LocalAsset?> _getAsset(WidgetRef ref) async {
+    try {
+      return await ref.read(localAssetRepository).getById(taskId);
+    } catch (e) {
+      return null;
+    }
+  }
+}
+
 class FileDetailDialog extends ConsumerWidget {
   final DriftUploadStatus uploadStatus;
-
   const FileDetailDialog({super.key, required this.uploadStatus});
 
   @override
@@ -212,14 +567,12 @@ class FileDetailDialog extends ConsumerWidget {
             if (snapshot.connectionState == ConnectionState.waiting) {
               return const SizedBox(height: 200, child: Center(child: CircularProgressIndicator()));
             }
-
             final asset = snapshot.data;
             return SingleChildScrollView(
               child: Column(
                 crossAxisAlignment: CrossAxisAlignment.start,
                 mainAxisSize: MainAxisSize.min,
                 children: [
-                  // Thumbnail at the top center
                   Center(
                     child: ClipRRect(
                       borderRadius: const BorderRadius.all(Radius.circular(12)),
@@ -237,7 +590,7 @@ class FileDetailDialog extends ConsumerWidget {
                     ),
                   ),
                   const SizedBox(height: 24),
-                  if (asset != null) ...[
+                  if (asset != null)
                     _buildInfoSection(context, [
                       _buildInfoRow(context, "filename".t(context: context), path.basename(uploadStatus.filename)),
                       _buildInfoRow(context, "local_id".t(context: context), asset.id),
@@ -254,7 +607,6 @@ class FileDetailDialog extends ConsumerWidget {
                       if (asset.checksum != null)
                         _buildInfoRow(context, "checksum".t(context: context), asset.checksum!),
                     ]),
-                  ],
                 ],
               ),
             );
@@ -282,7 +634,7 @@ class FileDetailDialog extends ConsumerWidget {
         borderRadius: const BorderRadius.all(Radius.circular(12)),
         border: Border.all(color: context.colorScheme.outline.withValues(alpha: 0.1), width: 1),
       ),
-      child: Column(crossAxisAlignment: CrossAxisAlignment.start, children: [...children]),
+      child: Column(crossAxisAlignment: CrossAxisAlignment.start, children: children),
     );
   }
 
@@ -303,12 +655,7 @@ class FileDetailDialog extends ConsumerWidget {
             ),
           ),
           Expanded(
-            child: Text(
-              value,
-              style: context.textTheme.labelMedium?.copyWith(),
-              maxLines: 3,
-              overflow: TextOverflow.ellipsis,
-            ),
+            child: Text(value, style: context.textTheme.labelMedium, maxLines: 3, overflow: TextOverflow.ellipsis),
           ),
         ],
       ),
@@ -317,8 +664,7 @@ class FileDetailDialog extends ConsumerWidget {
 
   Future<LocalAsset?> _getAssetDetails(WidgetRef ref, String localAssetId) async {
     try {
-      final repository = ref.read(localAssetRepository);
-      return await repository.getById(localAssetId);
+      return await ref.read(localAssetRepository).getById(localAssetId);
     } catch (e) {
       return null;
     }

mobile/lib/pages/common/splash_screen.page.dart

@@ -132,7 +132,7 @@ class SplashScreenPageState extends ConsumerState<SplashScreenPage> {
     if (isEnableBackup) {
       final currentUser = Store.tryGet(StoreKey.currentUser);
       if (currentUser != null) {
-        unawaited(notifier.handleBackupResume(currentUser.id));
+        unawaited(notifier.startForegroundBackup(currentUser.id));
       }
     }
   }

mobile/lib/presentation/widgets/asset_viewer/video_viewer.widget.dart

@@ -96,7 +96,7 @@ class NativeVideoViewer extends HookConsumerWidget {
       try {
         if (videoAsset.hasLocal && videoAsset.livePhotoVideoId == null) {
           final id = videoAsset is LocalAsset ? videoAsset.id : (videoAsset as RemoteAsset).localId!;
-          final file = await const StorageRepository().getFileForAsset(id);
+          final file = await StorageRepository().getFileForAsset(id);
           if (!context.mounted) {
             return null;
           }

mobile/lib/presentation/widgets/backup/backup_toggle_button.widget.dart

@@ -67,7 +67,9 @@ class BackupToggleButtonState extends ConsumerState<BackupToggleButton> with Sin
 
     final isSyncing = ref.watch(driftBackupProvider.select((state) => state.isSyncing));
 
-    final isProcessing = uploadTasks.isNotEmpty || isSyncing;
+    final iCloudProgress = ref.watch(driftBackupProvider.select((state) => state.iCloudDownloadProgress));
+
+    final isProcessing = uploadTasks.isNotEmpty || isSyncing || iCloudProgress.isNotEmpty;
 
     return AnimatedBuilder(
       animation: _animationController,

mobile/lib/providers/app_life_cycle.provider.dart

@@ -180,7 +180,7 @@ class AppLifeCycleNotifier extends StateNotifier<AppLifeCycleEnum> {
       final currentUser = Store.tryGet(StoreKey.currentUser);
       if (currentUser != null) {
         await _safeRun(
-          _ref.read(driftBackupProvider.notifier).handleBackupResume(currentUser.id),
+          _ref.read(driftBackupProvider.notifier).startForegroundBackup(currentUser.id),
           "handleBackupResume",
         );
       }

mobile/lib/providers/backup/drift_backup.provider.dart

@@ -1,19 +1,23 @@
-// ignore_for_file: public_member_api_docs, sort_constructors_first
 import 'dart:async';
 
 import 'package:background_downloader/background_downloader.dart';
+import 'package:cancellation_token_http/http.dart';
 import 'package:collection/collection.dart';
 import 'package:hooks_riverpod/hooks_riverpod.dart';
+import 'package:logging/logging.dart';
+
 import 'package:immich_mobile/constants/constants.dart';
 import 'package:immich_mobile/domain/models/album/local_album.model.dart';
 import 'package:immich_mobile/domain/models/asset/base_asset.model.dart';
+import 'package:immich_mobile/extensions/network_capability_extensions.dart';
 import 'package:immich_mobile/extensions/string_extensions.dart';
 import 'package:immich_mobile/infrastructure/repositories/backup.repository.dart';
+import 'package:immich_mobile/utils/upload_speed_calculator.dart';
+import 'package:immich_mobile/platform/connectivity_api.g.dart';
 import 'package:immich_mobile/providers/infrastructure/asset.provider.dart';
+import 'package:immich_mobile/providers/infrastructure/platform.provider.dart';
 import 'package:immich_mobile/providers/user.provider.dart';
 import 'package:immich_mobile/services/upload.service.dart';
-import 'package:immich_mobile/utils/debug_print.dart';
-import 'package:logging/logging.dart';
 
 class EnqueueStatus {
   final int enqueueCount;
@@ -114,6 +118,9 @@ class DriftBackupState {
   final BackupError error;
 
   final Map<String, DriftUploadStatus> uploadItems;
+  final CancellationToken? cancelToken;
+
+  final Map<String, double> iCloudDownloadProgress;
 
   const DriftBackupState({
     required this.totalCount,
@@ -122,10 +129,12 @@ class DriftBackupState {
     required this.processingCount,
     required this.enqueueCount,
     required this.enqueueTotalCount,
-    required this.isCanceling,
     required this.isSyncing,
-    required this.uploadItems,
+    required this.isCanceling,
     this.error = BackupError.none,
+    required this.uploadItems,
+    this.cancelToken,
+    this.iCloudDownloadProgress = const {},
   });
 
   DriftBackupState copyWith({
@@ -135,10 +144,12 @@ class DriftBackupState {
     int? processingCount,
     int? enqueueCount,
     int? enqueueTotalCount,
-    bool? isCanceling,
     bool? isSyncing,
-    Map<String, DriftUploadStatus>? uploadItems,
+    bool? isCanceling,
     BackupError? error,
+    Map<String, DriftUploadStatus>? uploadItems,
+    CancellationToken? cancelToken,
+    Map<String, double>? iCloudDownloadProgress,
   }) {
     return DriftBackupState(
       totalCount: totalCount ?? this.totalCount,
@@ -147,16 +158,18 @@ class DriftBackupState {
       processingCount: processingCount ?? this.processingCount,
       enqueueCount: enqueueCount ?? this.enqueueCount,
       enqueueTotalCount: enqueueTotalCount ?? this.enqueueTotalCount,
-      isCanceling: isCanceling ?? this.isCanceling,
       isSyncing: isSyncing ?? this.isSyncing,
-      uploadItems: uploadItems ?? this.uploadItems,
+      isCanceling: isCanceling ?? this.isCanceling,
       error: error ?? this.error,
+      uploadItems: uploadItems ?? this.uploadItems,
+      cancelToken: cancelToken ?? this.cancelToken,
+      iCloudDownloadProgress: iCloudDownloadProgress ?? this.iCloudDownloadProgress,
     );
   }
 
   @override
   String toString() {
-    return 'DriftBackupState(totalCount: $totalCount, backupCount: $backupCount, remainderCount: $remainderCount, processingCount: $processingCount, enqueueCount: $enqueueCount, enqueueTotalCount: $enqueueTotalCount, isCanceling: $isCanceling, isSyncing: $isSyncing, uploadItems: $uploadItems, error: $error)';
+    return 'DriftBackupState(totalCount: $totalCount, backupCount: $backupCount, remainderCount: $remainderCount, processingCount: $processingCount, enqueueCount: $enqueueCount, enqueueTotalCount: $enqueueTotalCount, isSyncing: $isSyncing, isCanceling: $isCanceling, error: $error, uploadItems: $uploadItems, cancelToken: $cancelToken, iCloudDownloadProgress: $iCloudDownloadProgress)';
   }
 
   @override
@@ -170,10 +183,12 @@ class DriftBackupState {
         other.processingCount == processingCount &&
         other.enqueueCount == enqueueCount &&
         other.enqueueTotalCount == enqueueTotalCount &&
-        other.isCanceling == isCanceling &&
         other.isSyncing == isSyncing &&
+        other.isCanceling == isCanceling &&
+        other.error == error &&
+        mapEquals(other.iCloudDownloadProgress, iCloudDownloadProgress) &&
         mapEquals(other.uploadItems, uploadItems) &&
-        other.error == error;
+        other.cancelToken == cancelToken;
   }
 
   @override
@@ -184,19 +199,21 @@ class DriftBackupState {
         processingCount.hashCode ^
         enqueueCount.hashCode ^
         enqueueTotalCount.hashCode ^
-        isCanceling.hashCode ^
         isSyncing.hashCode ^
+        isCanceling.hashCode ^
+        error.hashCode ^
         uploadItems.hashCode ^
-        error.hashCode;
+        cancelToken.hashCode ^
+        iCloudDownloadProgress.hashCode;
   }
 }
 
 final driftBackupProvider = StateNotifierProvider<DriftBackupNotifier, DriftBackupState>((ref) {
-  return DriftBackupNotifier(ref.watch(uploadServiceProvider));
+  return DriftBackupNotifier(ref.watch(uploadServiceProvider), ref.watch(connectivityApiProvider));
 });
 
 class DriftBackupNotifier extends StateNotifier<DriftBackupState> {
-  DriftBackupNotifier(this._uploadService)
+  DriftBackupNotifier(this._uploadService, this._connectivityApi)
     : super(
         const DriftBackupState(
           totalCount: 0,
@@ -218,9 +235,11 @@ class DriftBackupNotifier extends StateNotifier<DriftBackupState> {
   }
 
   final UploadService _uploadService;
+  final ConnectivityApi _connectivityApi;
   StreamSubscription<TaskStatusUpdate>? _statusSubscription;
   StreamSubscription<TaskProgressUpdate>? _progressSubscription;
   final _logger = Logger("DriftBackupNotifier");
+  final _uploadSpeedManager = UploadSpeedManager();
 
   /// Remove upload item from state
   void _removeUploadItem(String taskId) {
@@ -374,40 +393,120 @@ class DriftBackupNotifier extends StateNotifier<DriftBackupState> {
     state = state.copyWith(isSyncing: isSyncing);
   }
 
-  Future<void> startBackup(String userId) {
+  Future<void> startForegroundBackup(String userId) async {
     state = state.copyWith(error: BackupError.none);
-    return _uploadService.startBackup(userId, _updateEnqueueCount);
+
+    final cancelToken = CancellationToken();
+    state = state.copyWith(cancelToken: cancelToken);
+
+    final networkCapabilities = await _connectivityApi.getCapabilities();
+    final hasWifi = networkCapabilities.isUnmetered;
+    _logger.info('Network capabilities: $networkCapabilities, hasWifi/isUnmetered: $hasWifi');
+
+    return _uploadService.startUploadWithHttp(
+      userId,
+      hasWifi,
+      cancelToken,
+      onProgress: _handleForegroundBackupProgress,
+      onSuccess: _handleForegroundBackupSuccess,
+      onError: _handleForegroundBackupError,
+      onICloudProgress: _handleICloudProgress,
+    );
   }
 
-  void _updateEnqueueCount(EnqueueStatus status) {
-    state = state.copyWith(enqueueCount: status.enqueueCount, enqueueTotalCount: status.totalCount);
+  Future<void> stopForegroundBackup() async {
+    state.cancelToken?.cancel();
+    _uploadSpeedManager.clear();
+    state = state.copyWith(cancelToken: null, uploadItems: {}, iCloudDownloadProgress: {});
   }
 
-  Future<void> cancel() async {
-    if (!mounted) {
-      _logger.warning("Skip cancel (pre-call): notifier disposed");
-      return;
+  void _handleICloudProgress(String localAssetId, double progress) {
+    state = state.copyWith(iCloudDownloadProgress: {...state.iCloudDownloadProgress, localAssetId: progress});
+
+    if (progress >= 1.0) {
+      Future.delayed(const Duration(milliseconds: 250), () {
+        final updatedProgress = Map<String, double>.from(state.iCloudDownloadProgress);
+        updatedProgress.remove(localAssetId);
+        state = state.copyWith(iCloudDownloadProgress: updatedProgress);
+      });
     }
-    dPrint(() => "Canceling backup tasks...");
-    state = state.copyWith(enqueueCount: 0, enqueueTotalCount: 0, isCanceling: true, error: BackupError.none);
+  }
 
-    final activeTaskCount = await _uploadService.cancelBackup();
-    if (!mounted) {
-      _logger.warning("Skip cancel (post-call): notifier disposed");
+  void _handleForegroundBackupProgress(String localAssetId, String filename, int bytes, int totalBytes) {
+    if (state.cancelToken == null) {
       return;
     }
 
-    if (activeTaskCount > 0) {
-      dPrint(() => "$activeTaskCount tasks left, continuing to cancel...");
-      await cancel();
+    final progress = totalBytes > 0 ? bytes / totalBytes : 0.0;
+    final networkSpeedAsString = _uploadSpeedManager.updateProgress(localAssetId, bytes, totalBytes);
+    final currentItem = state.uploadItems[localAssetId];
+    if (currentItem != null) {
+      state = state.copyWith(
+        uploadItems: {
+          ...state.uploadItems,
+          localAssetId: currentItem.copyWith(
+            filename: filename,
+            progress: progress,
+            fileSize: totalBytes,
+            networkSpeedAsString: networkSpeedAsString,
+          ),
+        },
+      );
     } else {
-      dPrint(() => "All tasks canceled successfully.");
-      // Clear all upload items when cancellation is complete
-      state = state.copyWith(isCanceling: false, uploadItems: {});
+      state = state.copyWith(
+        uploadItems: {
+          ...state.uploadItems,
+          localAssetId: DriftUploadStatus(
+            taskId: localAssetId,
+            filename: filename,
+            progress: progress,
+            fileSize: totalBytes,
+            networkSpeedAsString: networkSpeedAsString,
+          ),
+        },
+      );
     }
   }
 
-  Future<void> handleBackupResume(String userId) async {
+  void _handleForegroundBackupSuccess(String localAssetId, String remoteAssetId) {
+    state = state.copyWith(backupCount: state.backupCount + 1, remainderCount: state.remainderCount - 1);
+    _uploadSpeedManager.removeTask(localAssetId);
+
+    Future.delayed(const Duration(milliseconds: 1000), () {
+      _removeUploadItem(localAssetId);
+    });
+  }
+
+  void _handleForegroundBackupError(String localAssetId, String errorMessage) {
+    _logger.severe("Upload failed for $localAssetId: $errorMessage");
+
+    final currentItem = state.uploadItems[localAssetId];
+    if (currentItem != null) {
+      state = state.copyWith(
+        uploadItems: {
+          ...state.uploadItems,
+          localAssetId: currentItem.copyWith(isFailed: true, error: errorMessage),
+        },
+      );
+    } else {
+      state = state.copyWith(
+        uploadItems: {
+          ...state.uploadItems,
+          localAssetId: DriftUploadStatus(
+            taskId: localAssetId,
+            filename: 'Unknown',
+            progress: 0,
+            fileSize: 0,
+            networkSpeedAsString: '',
+            isFailed: true,
+            error: errorMessage,
+          ),
+        },
+      );
+    }
+  }
+
+  Future<void> startBackupWithURLSession(String userId) async {
     if (!mounted) {
       _logger.warning("Skip handleBackupResume (pre-call): notifier disposed");
       return;
@@ -422,9 +521,8 @@ class DriftBackupNotifier extends StateNotifier<DriftBackupState> {
     _logger.info("Found ${tasks.length} tasks");
 
     if (tasks.isEmpty) {
-      // Start a new backup queue
-      _logger.info("Start a new backup queue");
-      return startBackup(userId);
+      _logger.info("Start backup with URLSession");
+      return _uploadService.startUploadWithURLSession(userId);
     }
 
     _logger.info("Tasks to resume: ${tasks.length}");

mobile/lib/providers/infrastructure/storage.provider.dart

@@ -1,4 +1,4 @@
 import 'package:hooks_riverpod/hooks_riverpod.dart';
 import 'package:immich_mobile/infrastructure/repositories/storage.repository.dart';
 
-final storageRepositoryProvider = Provider<StorageRepository>((ref) => const StorageRepository());
+final storageRepositoryProvider = Provider<StorageRepository>((ref) => StorageRepository());

mobile/lib/repositories/upload.repository.dart

@@ -1,3 +1,4 @@
+import 'dart:async';
 import 'dart:convert';
 import 'dart:io';
 
@@ -20,6 +21,7 @@ class UploadTaskWithFile {
 final uploadRepositoryProvider = Provider((ref) => UploadRepository());
 
 class UploadRepository {
+  final Logger logger = Logger('UploadRepository');
   void Function(TaskStatusUpdate)? onUploadStatus;
   void Function(TaskProgressUpdate)? onTaskProgress;
 
@@ -92,52 +94,114 @@ class UploadRepository {
     );
   }
 
-  Future<void> backupWithDartClient(Iterable<UploadTaskWithFile> tasks, CancellationToken cancelToken) async {
-    final httpClient = Client();
+  Future<UploadResult> uploadFile({
+    required File file,
+    required String originalFileName,
+    required Map<String, String> headers,
+    required Map<String, String> fields,
+    required Client httpClient,
+    required CancellationToken cancelToken,
+    required void Function(int bytes, int totalBytes) onProgress,
+    required String logContext,
+  }) async {
     final String savedEndpoint = Store.get(StoreKey.serverEndpoint);
 
-    Logger logger = Logger('UploadRepository');
-    for (final candidate in tasks) {
-      if (cancelToken.isCancelled) {
-        logger.warning("Backup was cancelled by the user");
-        break;
+    try {
+      final fileStream = file.openRead();
+      final assetRawUploadData = MultipartFile("assetData", fileStream, file.lengthSync(), filename: originalFileName);
+
+      final baseRequest = CustomMultipartRequest('POST', Uri.parse('$savedEndpoint/assets'), onProgress: onProgress);
+
+      baseRequest.headers.addAll(headers);
+      baseRequest.fields.addAll(fields);
+      baseRequest.files.add(assetRawUploadData);
+
+      final response = await httpClient.send(baseRequest, cancellationToken: cancelToken);
+      final responseBodyString = await response.stream.bytesToString();
+
+      if (![200, 201].contains(response.statusCode)) {
+        String? errorMessage;
+
+        if (response.statusCode == 413) {
+          errorMessage = 'Error(413) File is too large to upload';
+          return UploadResult.error(statusCode: response.statusCode, errorMessage: errorMessage);
+        }
+
+        try {
+          final error = jsonDecode(responseBodyString);
+          errorMessage = error['message'] ?? error['error'];
+        } catch (_) {
+          errorMessage = responseBodyString.isNotEmpty
+              ? responseBodyString
+              : 'Upload failed with status ${response.statusCode}';
+        }
+
+        return UploadResult.error(statusCode: response.statusCode, errorMessage: errorMessage);
       }
 
       try {
-        final fileStream = candidate.file.openRead();
-        final assetRawUploadData = MultipartFile(
-          "assetData",
-          fileStream,
-          candidate.file.lengthSync(),
-          filename: candidate.task.filename,
-        );
-
-        final baseRequest = MultipartRequest('POST', Uri.parse('$savedEndpoint/assets'));
-
-        baseRequest.headers.addAll(candidate.task.headers);
-        baseRequest.fields.addAll(candidate.task.fields);
-        baseRequest.files.add(assetRawUploadData);
-
-        final response = await httpClient.send(baseRequest, cancellationToken: cancelToken);
-
-        final responseBody = jsonDecode(await response.stream.bytesToString());
-
-        if (![200, 201].contains(response.statusCode)) {
-          final error = responseBody;
-
-          logger.warning(
-            "Error(${error['statusCode']}) uploading ${candidate.task.filename} | Created on ${candidate.task.fields["fileCreatedAt"]} | ${error['error']}",
-          );
-
-          continue;
-        }
-      } on CancelledException {
-        logger.warning("Backup was cancelled by the user");
-        break;
-      } catch (error, stackTrace) {
-        logger.warning("Error backup asset: ${error.toString()}: $stackTrace");
-        continue;
+        final responseBody = jsonDecode(responseBodyString);
+        return UploadResult.success(remoteAssetId: responseBody['id'] as String);
+      } catch (e) {
+        return UploadResult.error(errorMessage: 'Failed to parse server response');
       }
+    } on CancelledException {
+      logger.warning("Upload $logContext was cancelled");
+      return UploadResult.cancelled();
+    } catch (error, stackTrace) {
+      logger.warning("Error uploading $logContext: ${error.toString()}: $stackTrace");
+      return UploadResult.error(errorMessage: error.toString());
     }
   }
 }
+
+class UploadResult {
+  final bool isSuccess;
+  final bool isCancelled;
+  final String? remoteAssetId;
+  final String? errorMessage;
+  final int? statusCode;
+
+  const UploadResult({
+    required this.isSuccess,
+    required this.isCancelled,
+    this.remoteAssetId,
+    this.errorMessage,
+    this.statusCode,
+  });
+
+  factory UploadResult.success({required String remoteAssetId}) {
+    return UploadResult(isSuccess: true, isCancelled: false, remoteAssetId: remoteAssetId);
+  }
+
+  factory UploadResult.error({String? errorMessage, int? statusCode}) {
+    return UploadResult(isSuccess: false, isCancelled: false, errorMessage: errorMessage, statusCode: statusCode);
+  }
+
+  factory UploadResult.cancelled() {
+    return const UploadResult(isSuccess: false, isCancelled: true);
+  }
+}
+
+class CustomMultipartRequest extends MultipartRequest {
+  CustomMultipartRequest(super.method, super.url, {required this.onProgress});
+
+  final void Function(int bytes, int totalBytes) onProgress;
+
+  @override
+  ByteStream finalize() {
+    final byteStream = super.finalize();
+    final total = contentLength;
+    var bytes = 0;
+
+    final t = StreamTransformer.fromHandlers(
+      handleData: (List<int> data, EventSink<List<int>> sink) {
+        bytes += data.length;
+        onProgress.call(bytes, total);
+        sink.add(data);
+      },
+    );
+    final stream = byteStream.transform(t);
+    return ByteStream(stream);
+  }
+}

mobile/lib/services/upload.service.dart

@@ -15,7 +15,6 @@ import 'package:immich_mobile/infrastructure/repositories/backup.repository.dart
 import 'package:immich_mobile/infrastructure/repositories/local_asset.repository.dart';
 import 'package:immich_mobile/infrastructure/repositories/storage.repository.dart';
 import 'package:immich_mobile/providers/app_settings.provider.dart';
-import 'package:immich_mobile/providers/backup/drift_backup.provider.dart';
 import 'package:immich_mobile/providers/infrastructure/asset.provider.dart';
 import 'package:immich_mobile/providers/infrastructure/storage.provider.dart';
 import 'package:immich_mobile/repositories/asset_media.repository.dart';
@@ -25,6 +24,7 @@ import 'package:immich_mobile/services/app_settings.service.dart';
 import 'package:immich_mobile/utils/debug_print.dart';
 import 'package:logging/logging.dart';
 import 'package:path/path.dart' as p;
+import 'package:photo_manager/photo_manager.dart' show PMProgressHandler;
 
 final uploadServiceProvider = Provider((ref) {
   final service = UploadService(
@@ -121,7 +121,7 @@ class UploadService {
   /// Find backup candidates
   /// Build the upload tasks
   /// Enqueue the tasks
-  Future<void> startBackup(String userId, void Function(EnqueueStatus status) onEnqueueTasks) async {
+  Future<void> startUploadWithURLSession(String userId) async {
     await _storageRepository.clearCache();
 
     shouldAbortQueuingTasks = false;
@@ -132,63 +132,231 @@ class UploadService {
     }
 
     const batchSize = 100;
-    int count = 0;
-    for (int i = 0; i < candidates.length; i += batchSize) {
-      if (shouldAbortQueuingTasks) {
-        break;
+    final batch = candidates.take(batchSize).toList();
+    List<UploadTask> tasks = [];
+    for (final asset in batch) {
+      final task = await getUploadTask(asset);
+      if (task != null) {
+        tasks.add(task);
       }
+    }
 
-      final batch = candidates.skip(i).take(batchSize).toList();
-      List<UploadTask> tasks = [];
-      for (final asset in batch) {
-        final task = await getUploadTask(asset);
-        if (task != null) {
-          tasks.add(task);
+    if (tasks.isNotEmpty && !shouldAbortQueuingTasks) {
+      await enqueueTasks(tasks);
+    }
+  }
+
+  Future<void> startUploadWithHttp(
+    String userId,
+    bool hasWifi,
+    CancellationToken cancelToken, {
+    required void Function(String localAssetId, String filename, int bytes, int totalBytes) onProgress,
+    required void Function(String localAssetId, String remoteAssetId) onSuccess,
+    required void Function(String localAssetId, String errorMessage) onError,
+    required void Function(String localAssetId, double progress) onICloudProgress,
+  }) async {
+    const concurrentUploads = 3;
+    final httpClients = List.generate(concurrentUploads, (_) => Client());
+
+    await _storageRepository.clearCache();
+
+    shouldAbortQueuingTasks = false;
+
+    final candidates = await _backupRepository.getCandidates(userId);
+    if (candidates.isEmpty) {
+      return;
+    }
+
+    try {
+      int currentIndex = 0;
+
+      Future<void> worker(Client httpClient) async {
+        while (true) {
+          if (shouldAbortQueuingTasks || cancelToken.isCancelled) {
+            break;
+          }
+
+          final index = currentIndex;
+          if (index >= candidates.length) {
+            break;
+          }
+          currentIndex++;
+
+          final asset = candidates[index];
+
+          final requireWifi = _shouldRequireWiFi(asset);
+          if (requireWifi && !hasWifi) {
+            continue;
+          }
+
+          await _uploadSingleAsset(
+            asset,
+            httpClient,
+            cancelToken,
+            onProgress: onProgress,
+            onSuccess: onSuccess,
+            onError: onError,
+            onICloudProgress: onICloudProgress,
+          );
         }
       }
 
-      if (tasks.isNotEmpty && !shouldAbortQueuingTasks) {
-        count += tasks.length;
-        await enqueueTasks(tasks);
+      // Start all workers in parallel - each worker continuously pulls from the queue
+      final workerFutures = <Future<void>>[];
 
-        onEnqueueTasks(EnqueueStatus(enqueueCount: count, totalCount: candidates.length));
+      for (int i = 0; i < concurrentUploads; i++) {
+        workerFutures.add(worker(httpClients[i]));
+      }
+
+      await Future.wait(workerFutures);
+    } finally {
+      for (final client in httpClients) {
+        client.close();
       }
     }
   }
 
-  Future<void> startBackupWithHttpClient(String userId, bool hasWifi, CancellationToken token) async {
-    await _storageRepository.clearCache();
+  Future<void> _uploadSingleAsset(
+    LocalAsset asset,
+    Client httpClient,
+    CancellationToken cancelToken, {
+    required void Function(String id, String filename, int bytes, int totalBytes) onProgress,
+    required void Function(String localAssetId, String remoteAssetId) onSuccess,
+    required void Function(String localAssetId, String errorMessage) onError,
+    required void Function(String localAssetId, double progress) onICloudProgress,
+  }) async {
+    File? file;
+    File? livePhotoFile;
 
-    shouldAbortQueuingTasks = false;
-
-    final candidates = await _backupRepository.getCandidates(userId);
-    if (candidates.isEmpty) {
-      return;
-    }
-
-    const batchSize = 100;
-    for (int i = 0; i < candidates.length; i += batchSize) {
-      if (shouldAbortQueuingTasks || token.isCancelled) {
-        break;
+    try {
+      final entity = await _storageRepository.getAssetEntityForAsset(asset);
+      if (entity == null) {
+        return;
       }
 
-      final batch = candidates.skip(i).take(batchSize).toList();
-      List<UploadTaskWithFile> tasks = [];
-      for (final asset in batch) {
-        final requireWifi = _shouldRequireWiFi(asset);
-        if (requireWifi && !hasWifi) {
-          _logger.warning('Skipping upload for ${asset.id} because it requires WiFi');
-          continue;
+      final isAvailableLocally = await _storageRepository.isAssetAvailableLocally(asset.id);
+
+      if (!isAvailableLocally && Platform.isIOS) {
+        _logger.info("Loading iCloud asset ${asset.id} - ${asset.name}");
+
+        // Create progress handler for iCloud download
+        PMProgressHandler? progressHandler;
+        StreamSubscription? progressSubscription;
+
+        progressHandler = PMProgressHandler();
+        progressSubscription = progressHandler.stream.listen((event) {
+          onICloudProgress(asset.localId!, event.progress);
+        });
+
+        try {
+          file = await _storageRepository.loadFileFromCloud(asset.id, progressHandler: progressHandler);
+          if (entity.isLivePhoto) {
+            livePhotoFile = await _storageRepository.loadMotionFileFromCloud(
+              asset.id,
+              progressHandler: progressHandler,
+            );
+          }
+        } finally {
+          await progressSubscription.cancel();
+        }
+      } else {
+        // Get files locally
+        file = await _storageRepository.getFileForAsset(asset.id);
+        if (file == null) {
+          return;
         }
 
-        final task = await _getUploadTaskWithFile(asset);
-        if (task != null) {
-          tasks.add(task);
+        // For live photos, get the motion video file
+        if (entity.isLivePhoto) {
+          livePhotoFile = await _storageRepository.getMotionFileForAsset(asset);
+          if (livePhotoFile == null) {
+            _logger.warning("Failed to obtain motion part of the livePhoto - ${asset.name}");
+          }
         }
       }
 
-      if (tasks.isNotEmpty && !shouldAbortQueuingTasks) {
-        await _uploadRepository.backupWithDartClient(tasks, token);
+      if (file == null) {
+        _logger.warning("Failed to obtain file for asset ${asset.id} - ${asset.name}");
+        return;
+      }
+
+      final originalFileName = entity.isLivePhoto ? p.setExtension(asset.name, p.extension(file.path)) : asset.name;
+      final deviceId = Store.get(StoreKey.deviceId);
+
+      final headers = ApiService.getRequestHeaders();
+      final fields = {
+        'deviceAssetId': asset.localId!,
+        'deviceId': deviceId,
+        'fileCreatedAt': asset.createdAt.toUtc().toIso8601String(),
+        'fileModifiedAt': asset.updatedAt.toUtc().toIso8601String(),
+        'isFavorite': asset.isFavorite.toString(),
+        'duration': asset.duration.toString(),
+      };
+
+      // Upload live photo video first if available
+      String? livePhotoVideoId;
+      if (entity.isLivePhoto && livePhotoFile != null) {
+        final livePhotoTitle = p.setExtension(originalFileName, p.extension(livePhotoFile.path));
+
+        final livePhotoResult = await _uploadRepository.uploadFile(
+          file: livePhotoFile,
+          originalFileName: livePhotoTitle,
+          headers: headers,
+          fields: fields,
+          httpClient: httpClient,
+          cancelToken: cancelToken,
+          onProgress: (bytes, totalBytes) => onProgress(asset.localId!, livePhotoTitle, bytes, totalBytes),
+          logContext: 'livePhotoVideo[${asset.localId}]',
+        );
+
+        if (livePhotoResult.isSuccess && livePhotoResult.remoteAssetId != null) {
+          livePhotoVideoId = livePhotoResult.remoteAssetId;
+        }
+      }
+
+      if (livePhotoVideoId != null) {
+        fields['livePhotoVideoId'] = livePhotoVideoId;
+      }
+
+      final result = await _uploadRepository.uploadFile(
+        file: file,
+        originalFileName: originalFileName,
+        headers: headers,
+        fields: fields,
+        httpClient: httpClient,
+        cancelToken: cancelToken,
+        onProgress: (bytes, totalBytes) => onProgress(asset.localId!, originalFileName, bytes, totalBytes),
+        logContext: 'asset[${asset.localId}]',
+      );
+
+      if (result.isSuccess && result.remoteAssetId != null) {
+        onSuccess(asset.localId!, result.remoteAssetId!);
+      } else if (result.isCancelled) {
+        dPrint(() => "Backup was cancelled by the user");
+        shouldAbortQueuingTasks = true;
+      } else if (result.errorMessage != null) {
+        dPrint(
+          () =>
+              "Error(${result.statusCode}) uploading ${asset.localId} | $originalFileName | Created on ${asset.createdAt} | ${result.errorMessage}",
+        );
+
+        onError(asset.localId!, result.errorMessage!);
+
+        if (result.errorMessage == "Quota has been exceeded!") {
+          shouldAbortQueuingTasks = true;
+        }
+      }
+    } catch (error, stackTrace) {
+      dPrint(() => "Error backup asset: ${error.toString()}: $stackTrace");
+      onError(asset.localId!, error.toString());
+    } finally {
+      if (Platform.isIOS) {
+        try {
+          await file?.delete();
+          await livePhotoFile?.delete();
+        } catch (e) {
+          dPrint(() => "ERROR deleting file: ${e.toString()}");
+        }
       }
     }
   }
@@ -265,42 +433,6 @@ class UploadService {
     }
   }
 
-  Future<UploadTaskWithFile?> _getUploadTaskWithFile(LocalAsset asset) async {
-    final entity = await _storageRepository.getAssetEntityForAsset(asset);
-    if (entity == null) {
-      return null;
-    }
-
-    final file = await _storageRepository.getFileForAsset(asset.id);
-    if (file == null) {
-      return null;
-    }
-
-    final originalFileName = entity.isLivePhoto ? p.setExtension(asset.name, p.extension(file.path)) : asset.name;
-
-    String metadata = UploadTaskMetadata(
-      localAssetId: asset.id,
-      isLivePhotos: entity.isLivePhoto,
-      livePhotoVideoId: '',
-    ).toJson();
-
-    return UploadTaskWithFile(
-      file: file,
-      task: await buildUploadTask(
-        file,
-        createdAt: asset.createdAt,
-        modifiedAt: asset.updatedAt,
-        originalFileName: originalFileName,
-        deviceAssetId: asset.id,
-        metadata: metadata,
-        group: "group",
-        priority: 0,
-        isFavorite: asset.isFavorite,
-        requiresWiFi: false,
-      ),
-    );
-  }
-
   @visibleForTesting
   Future<UploadTask?> getUploadTask(LocalAsset asset, {String group = kBackupGroup, int? priority}) async {
     final entity = await _storageRepository.getAssetEntityForAsset(asset);

mobile/lib/utils/upload_speed_calculator.dart

@@ -0,0 +1,182 @@
+/// A class to calculate upload speed based on progress updates.
+///
+/// Tracks bytes transferred over time and calculates average speed
+/// using a sliding window approach to smooth out fluctuations.
+class UploadSpeedCalculator {
+  /// Creates an UploadSpeedCalculator with the given window size.
+  ///
+  /// [windowSize] determines how many recent samples to use for
+  /// calculating the average speed. Default is 5 samples.
+  UploadSpeedCalculator({this.windowSize = 5});
+
+  /// The number of samples to keep in the sliding window.
+  final int windowSize;
+
+  /// List of recent speed samples (bytes per second).
+  final List<double> _speedSamples = [];
+
+  /// The timestamp of the last progress update.
+  DateTime? _lastUpdateTime;
+
+  /// The bytes transferred at the last progress update.
+  int _lastBytes = 0;
+
+  /// The total file size being uploaded.
+  int _totalBytes = 0;
+
+  /// Resets the calculator for a new upload.
+  void reset() {
+    _speedSamples.clear();
+    _lastUpdateTime = null;
+    _lastBytes = 0;
+    _totalBytes = 0;
+  }
+
+  /// Updates the calculator with the current progress.
+  ///
+  /// [currentBytes] is the number of bytes transferred so far.
+  /// [totalBytes] is the total size of the file being uploaded.
+  ///
+  /// Returns the calculated speed in MB/s, or -1 if not enough data.
+  double update(int currentBytes, int totalBytes) {
+    final now = DateTime.now();
+    _totalBytes = totalBytes;
+
+    if (_lastUpdateTime == null) {
+      _lastUpdateTime = now;
+      _lastBytes = currentBytes;
+      return -1;
+    }
+
+    final elapsed = now.difference(_lastUpdateTime!);
+
+    // Only calculate if at least 100ms has passed to avoid division by very small numbers
+    if (elapsed.inMilliseconds < 100) {
+      return _currentSpeed;
+    }
+
+    final bytesTransferred = currentBytes - _lastBytes;
+    final elapsedSeconds = elapsed.inMilliseconds / 1000.0;
+
+    // Calculate bytes per second, then convert to MB/s
+    final bytesPerSecond = bytesTransferred / elapsedSeconds;
+    final mbPerSecond = bytesPerSecond / (1024 * 1024);
+
+    // Add to sliding window
+    _speedSamples.add(mbPerSecond);
+    if (_speedSamples.length > windowSize) {
+      _speedSamples.removeAt(0);
+    }
+
+    _lastUpdateTime = now;
+    _lastBytes = currentBytes;
+
+    return _currentSpeed;
+  }
+
+  /// Returns the current calculated speed in MB/s.
+  ///
+  /// Returns -1 if no valid speed has been calculated yet.
+  double get _currentSpeed {
+    if (_speedSamples.isEmpty) {
+      return -1;
+    }
+    // Calculate average of all samples in the window
+    final sum = _speedSamples.fold(0.0, (prev, speed) => prev + speed);
+    return sum / _speedSamples.length;
+  }
+
+  /// Returns the current speed in MB/s, or -1 if not available.
+  double get speed => _currentSpeed;
+
+  /// Returns a human-readable string representation of the current speed.
+  ///
+  /// Returns '-- MB/s' if N/A, otherwise in MB/s or kB/s format.
+  String get speedAsString {
+    final s = _currentSpeed;
+    return switch (s) {
+      <= 0 => '-- MB/s',
+      >= 1 => '${s.round()} MB/s',
+      _ => '${(s * 1000).round()} kB/s',
+    };
+  }
+
+  /// Returns the estimated time remaining as a Duration.
+  ///
+  /// Returns Duration with negative seconds if not calculable.
+  Duration get timeRemaining {
+    final s = _currentSpeed;
+    if (s <= 0 || _totalBytes <= 0 || _lastBytes >= _totalBytes) {
+      return const Duration(seconds: -1);
+    }
+
+    final remainingBytes = _totalBytes - _lastBytes;
+    final bytesPerSecond = s * 1024 * 1024;
+    final secondsRemaining = remainingBytes / bytesPerSecond;
+
+    return Duration(seconds: secondsRemaining.round());
+  }
+
+  /// Returns a human-readable string representation of time remaining.
+  ///
+  /// Returns '--:--' if N/A, otherwise HH:MM:SS or MM:SS format.
+  String get timeRemainingAsString {
+    final remaining = timeRemaining;
+    return switch (remaining.inSeconds) {
+      <= 0 => '--:--',
+      < 3600 =>
+        '${remaining.inMinutes.toString().padLeft(2, "0")}'
+            ':${remaining.inSeconds.remainder(60).toString().padLeft(2, "0")}',
+      _ =>
+        '${remaining.inHours}'
+            ':${remaining.inMinutes.remainder(60).toString().padLeft(2, "0")}'
+            ':${remaining.inSeconds.remainder(60).toString().padLeft(2, "0")}',
+    };
+  }
+}
+
+/// Manager for tracking upload speeds for multiple concurrent uploads.
+///
+/// Each upload is identified by a unique task ID.
+class UploadSpeedManager {
+  /// Map of task IDs to their speed calculators.
+  final Map<String, UploadSpeedCalculator> _calculators = {};
+
+  /// Gets or creates a speed calculator for the given task ID.
+  UploadSpeedCalculator getCalculator(String taskId) {
+    return _calculators.putIfAbsent(taskId, () => UploadSpeedCalculator());
+  }
+
+  /// Updates progress for a specific task and returns the speed string.
+  ///
+  /// [taskId] is the unique identifier for the upload task.
+  /// [currentBytes] is the number of bytes transferred so far.
+  /// [totalBytes] is the total size of the file being uploaded.
+  ///
+  /// Returns the human-readable speed string.
+  String updateProgress(String taskId, int currentBytes, int totalBytes) {
+    final calculator = getCalculator(taskId);
+    calculator.update(currentBytes, totalBytes);
+    return calculator.speedAsString;
+  }
+
+  /// Gets the current speed string for a specific task.
+  String getSpeedAsString(String taskId) {
+    return _calculators[taskId]?.speedAsString ?? '-- MB/s';
+  }
+
+  /// Gets the time remaining string for a specific task.
+  String getTimeRemainingAsString(String taskId) {
+    return _calculators[taskId]?.timeRemainingAsString ?? '--:--';
+  }
+
+  /// Removes a task from tracking.
+  void removeTask(String taskId) {
+    _calculators.remove(taskId);
+  }
+
+  /// Clears all tracked tasks.
+  void clear() {
+    _calculators.clear();
+  }
+}