merge: remote-tracking branch 'origin/main' into feat/integrity-checks-izzy

mobile/lib/services/background_upload.service.dart

@@ -3,7 +3,6 @@ import 'dart:convert';
 import 'dart:io';
 
 import 'package:background_downloader/background_downloader.dart';
-import 'package:cancellation_token_http/http.dart';
 import 'package:flutter/foundation.dart';
 import 'package:hooks_riverpod/hooks_riverpod.dart';
 import 'package:immich_mobile/constants/constants.dart';
@@ -15,12 +14,9 @@ import 'package:immich_mobile/extensions/platform_extensions.dart';
 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/models/server_info/server_info.model.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/providers/server_info.provider.dart';
 import 'package:immich_mobile/repositories/asset_media.repository.dart';
 import 'package:immich_mobile/repositories/upload.repository.dart';
 import 'package:immich_mobile/services/api.service.dart';
@@ -29,43 +25,98 @@ import 'package:immich_mobile/utils/debug_print.dart';
 import 'package:logging/logging.dart';
 import 'package:path/path.dart' as p;
 
-final uploadServiceProvider = Provider((ref) {
-  final service = UploadService(
+final backgroundUploadServiceProvider = Provider((ref) {
+  final service = BackgroundUploadService(
     ref.watch(uploadRepositoryProvider),
-    ref.watch(backupRepositoryProvider),
     ref.watch(storageRepositoryProvider),
     ref.watch(localAssetRepository),
+    ref.watch(backupRepositoryProvider),
     ref.watch(appSettingsServiceProvider),
     ref.watch(assetMediaRepositoryProvider),
-    ref.watch(serverInfoProvider),
   );
 
   ref.onDispose(service.dispose);
   return service;
 });
 
-class UploadService {
-  UploadService(
+/// Metadata for upload tasks to track live photo handling
+class UploadTaskMetadata {
+  final String localAssetId;
+  final bool isLivePhotos;
+  final String livePhotoVideoId;
+
+  const UploadTaskMetadata({required this.localAssetId, required this.isLivePhotos, required this.livePhotoVideoId});
+
+  UploadTaskMetadata copyWith({String? localAssetId, bool? isLivePhotos, String? livePhotoVideoId}) {
+    return UploadTaskMetadata(
+      localAssetId: localAssetId ?? this.localAssetId,
+      isLivePhotos: isLivePhotos ?? this.isLivePhotos,
+      livePhotoVideoId: livePhotoVideoId ?? this.livePhotoVideoId,
+    );
+  }
+
+  Map<String, dynamic> toMap() {
+    return <String, dynamic>{
+      'localAssetId': localAssetId,
+      'isLivePhotos': isLivePhotos,
+      'livePhotoVideoId': livePhotoVideoId,
+    };
+  }
+
+  factory UploadTaskMetadata.fromMap(Map<String, dynamic> map) {
+    return UploadTaskMetadata(
+      localAssetId: map['localAssetId'] as String,
+      isLivePhotos: map['isLivePhotos'] as bool,
+      livePhotoVideoId: map['livePhotoVideoId'] as String,
+    );
+  }
+
+  String toJson() => json.encode(toMap());
+
+  factory UploadTaskMetadata.fromJson(String source) =>
+      UploadTaskMetadata.fromMap(json.decode(source) as Map<String, dynamic>);
+
+  @override
+  String toString() =>
+      'UploadTaskMetadata(localAssetId: $localAssetId, isLivePhotos: $isLivePhotos, livePhotoVideoId: $livePhotoVideoId)';
+
+  @override
+  bool operator ==(covariant UploadTaskMetadata other) {
+    if (identical(this, other)) return true;
+
+    return other.localAssetId == localAssetId &&
+        other.isLivePhotos == isLivePhotos &&
+        other.livePhotoVideoId == livePhotoVideoId;
+  }
+
+  @override
+  int get hashCode => localAssetId.hashCode ^ isLivePhotos.hashCode ^ livePhotoVideoId.hashCode;
+}
+
+/// Service for handling background uploads using iOS URLSession (background_downloader)
+///
+/// This service handles asynchronous background uploads that can continue
+/// even when the app is suspended. Primarily used for iOS background backup.
+class BackgroundUploadService {
+  BackgroundUploadService(
     this._uploadRepository,
-    this._backupRepository,
     this._storageRepository,
     this._localAssetRepository,
+    this._backupRepository,
     this._appSettingsService,
     this._assetMediaRepository,
-    this._serverInfo,
   ) {
     _uploadRepository.onUploadStatus = _onUploadCallback;
     _uploadRepository.onTaskProgress = _onTaskProgressCallback;
   }
 
   final UploadRepository _uploadRepository;
-  final DriftBackupRepository _backupRepository;
   final StorageRepository _storageRepository;
   final DriftLocalAssetRepository _localAssetRepository;
+  final DriftBackupRepository _backupRepository;
   final AppSettingsService _appSettingsService;
   final AssetMediaRepository _assetMediaRepository;
-  final ServerInfo _serverInfo;
-  final Logger _logger = Logger('UploadService');
+  final Logger _logger = Logger('BackgroundUploadService');
 
   final StreamController<TaskStatusUpdate> _taskStatusController = StreamController<TaskStatusUpdate>.broadcast();
   final StreamController<TaskProgressUpdate> _taskProgressController = StreamController<TaskProgressUpdate>.broadcast();
@@ -93,116 +144,49 @@ class UploadService {
     _taskProgressController.close();
   }
 
+  /// Enqueue tasks to the background upload queue
   Future<List<bool>> enqueueTasks(List<UploadTask> tasks) {
     return _uploadRepository.enqueueBackgroundAll(tasks);
   }
 
+  /// Get a list of tasks that are ENQUEUED or RUNNING
   Future<List<Task>> getActiveTasks(String group) {
     return _uploadRepository.getActiveTasks(group);
   }
 
-  Future<({int total, int remainder, int processing})> getBackupCounts(String userId) {
-    return _backupRepository.getAllCounts(userId);
-  }
-
-  Future<void> manualBackup(List<LocalAsset> localAssets) async {
+  /// Start background upload using iOS URLSession
+  ///
+  /// Finds backup candidates, builds upload tasks, and enqueues them
+  /// for background processing.
+  Future<void> uploadBackupCandidates(String userId) async {
     await _storageRepository.clearCache();
+    shouldAbortQueuingTasks = false;
+
+    final candidates = await _backupRepository.getCandidates(userId);
+    if (candidates.isEmpty) {
+      return;
+    }
+
+    const batchSize = 100;
+    final batch = candidates.take(batchSize).toList();
     List<UploadTask> tasks = [];
-    for (final asset in localAssets) {
-      final task = await getUploadTask(
-        asset,
-        group: kManualUploadGroup,
-        priority: 1, // High priority after upload motion photo part
-      );
+
+    for (final asset in batch) {
+      final task = await getUploadTask(asset);
       if (task != null) {
         tasks.add(task);
       }
     }
 
-    if (tasks.isNotEmpty) {
+    if (tasks.isNotEmpty && !shouldAbortQueuingTasks) {
       await enqueueTasks(tasks);
     }
   }
 
-  /// Find backup candidates
-  /// Build the upload tasks
-  /// Enqueue the tasks
-  Future<void> startBackup(String userId, void Function(EnqueueStatus status) onEnqueueTasks) async {
-    await _storageRepository.clearCache();
-
-    shouldAbortQueuingTasks = false;
-
-    final candidates = await _backupRepository.getCandidates(userId);
-    if (candidates.isEmpty) {
-      return;
-    }
-
-    const batchSize = 100;
-    int count = 0;
-    for (int i = 0; i < candidates.length; i += batchSize) {
-      if (shouldAbortQueuingTasks) {
-        break;
-      }
-
-      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) {
-        count += tasks.length;
-        await enqueueTasks(tasks);
-
-        onEnqueueTasks(EnqueueStatus(enqueueCount: count, totalCount: candidates.length));
-      }
-    }
-  }
-
-  Future<void> startBackupWithHttpClient(String userId, bool hasWifi, CancellationToken token) async {
-    await _storageRepository.clearCache();
-
-    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;
-      }
-
-      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 task = await _getUploadTaskWithFile(asset);
-        if (task != null) {
-          tasks.add(task);
-        }
-      }
-
-      if (tasks.isNotEmpty && !shouldAbortQueuingTasks) {
-        await _uploadRepository.backupWithDartClient(tasks, token);
-      }
-    }
-  }
-
-  /// Cancel all ongoing uploads and reset the upload queue
+  /// Cancel all ongoing background uploads and reset the upload queue
   ///
-  /// Return the number of left over tasks in the queue
-  Future<int> cancelBackup() async {
+  /// Returns the number of tasks left in the queue
+  Future<int> cancel() async {
     shouldAbortQueuingTasks = true;
 
     await _storageRepository.clearCache();
@@ -213,7 +197,8 @@ class UploadService {
     return activeTasks.length;
   }
 
-  Future<void> resumeBackup() {
+  /// Resume background backup processing
+  Future<void> resume() {
     return _uploadRepository.start();
   }
 
@@ -271,42 +256,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);
@@ -443,8 +392,7 @@ class UploadService {
       'isFavorite': isFavorite?.toString() ?? 'false',
       'duration': '0',
       if (fields != null) ...fields,
-      // Include cloudId and eTag in metadata if available and server version supports it
-      if (CurrentPlatform.isIOS && cloudId != null && _serverInfo.serverVersion.isAtLeast(major: 2, minor: 4))
+      if (CurrentPlatform.isIOS && cloudId != null)
         'metadata': jsonEncode([
           RemoteAssetMetadataItem(
             key: RemoteAssetMetadataKey.mobileApp,
@@ -479,56 +427,3 @@ class UploadService {
     );
   }
 }
-
-class UploadTaskMetadata {
-  final String localAssetId;
-  final bool isLivePhotos;
-  final String livePhotoVideoId;
-
-  const UploadTaskMetadata({required this.localAssetId, required this.isLivePhotos, required this.livePhotoVideoId});
-
-  UploadTaskMetadata copyWith({String? localAssetId, bool? isLivePhotos, String? livePhotoVideoId}) {
-    return UploadTaskMetadata(
-      localAssetId: localAssetId ?? this.localAssetId,
-      isLivePhotos: isLivePhotos ?? this.isLivePhotos,
-      livePhotoVideoId: livePhotoVideoId ?? this.livePhotoVideoId,
-    );
-  }
-
-  Map<String, dynamic> toMap() {
-    return <String, dynamic>{
-      'localAssetId': localAssetId,
-      'isLivePhotos': isLivePhotos,
-      'livePhotoVideoId': livePhotoVideoId,
-    };
-  }
-
-  factory UploadTaskMetadata.fromMap(Map<String, dynamic> map) {
-    return UploadTaskMetadata(
-      localAssetId: map['localAssetId'] as String,
-      isLivePhotos: map['isLivePhotos'] as bool,
-      livePhotoVideoId: map['livePhotoVideoId'] as String,
-    );
-  }
-
-  String toJson() => json.encode(toMap());
-
-  factory UploadTaskMetadata.fromJson(String source) =>
-      UploadTaskMetadata.fromMap(json.decode(source) as Map<String, dynamic>);
-
-  @override
-  String toString() =>
-      'UploadTaskMetadata(localAssetId: $localAssetId, isLivePhotos: $isLivePhotos, livePhotoVideoId: $livePhotoVideoId)';
-
-  @override
-  bool operator ==(covariant UploadTaskMetadata other) {
-    if (identical(this, other)) return true;
-
-    return other.localAssetId == localAssetId &&
-        other.isLivePhotos == isLivePhotos &&
-        other.livePhotoVideoId == livePhotoVideoId;
-  }
-
-  @override
-  int get hashCode => localAssetId.hashCode ^ isLivePhotos.hashCode ^ livePhotoVideoId.hashCode;
-}

mobile/lib/services/foreground_upload.service.dart

@@ -0,0 +1,461 @@
+import 'dart:async';
+import 'dart:convert';
+import 'dart:io';
+
+import 'package:cancellation_token_http/http.dart';
+import 'package:hooks_riverpod/hooks_riverpod.dart';
+import 'package:immich_mobile/domain/models/asset/asset_metadata.model.dart';
+import 'package:immich_mobile/domain/models/asset/base_asset.model.dart';
+import 'package:immich_mobile/domain/models/store.model.dart';
+import 'package:immich_mobile/entities/store.entity.dart';
+import 'package:immich_mobile/extensions/platform_extensions.dart';
+import 'package:immich_mobile/extensions/network_capability_extensions.dart';
+import 'package:immich_mobile/infrastructure/repositories/backup.repository.dart';
+import 'package:immich_mobile/infrastructure/repositories/storage.repository.dart';
+import 'package:immich_mobile/platform/connectivity_api.g.dart';
+import 'package:immich_mobile/providers/app_settings.provider.dart';
+import 'package:immich_mobile/providers/infrastructure/platform.provider.dart';
+import 'package:immich_mobile/providers/infrastructure/storage.provider.dart';
+import 'package:immich_mobile/repositories/upload.repository.dart';
+import 'package:immich_mobile/services/api.service.dart';
+import 'package:immich_mobile/services/app_settings.service.dart';
+import 'package:logging/logging.dart';
+import 'package:path/path.dart' as p;
+import 'package:photo_manager/photo_manager.dart' show PMProgressHandler;
+
+/// Callbacks for upload progress and status updates
+class UploadCallbacks {
+  final void Function(String id, String filename, int bytes, int totalBytes)? onProgress;
+  final void Function(String localId, String remoteId)? onSuccess;
+  final void Function(String id, String errorMessage)? onError;
+  final void Function(String id, double progress)? onICloudProgress;
+
+  const UploadCallbacks({this.onProgress, this.onSuccess, this.onError, this.onICloudProgress});
+}
+
+final foregroundUploadServiceProvider = Provider((ref) {
+  return ForegroundUploadService(
+    ref.watch(uploadRepositoryProvider),
+    ref.watch(storageRepositoryProvider),
+    ref.watch(backupRepositoryProvider),
+    ref.watch(connectivityApiProvider),
+    ref.watch(appSettingsServiceProvider),
+  );
+});
+
+/// Service for handling foreground HTTP uploads
+///
+/// This service handles synchronous uploads using HTTP client with
+/// concurrent worker pools. Used for manual backups, auto backups
+/// (foreground mode), and share intent uploads.
+class ForegroundUploadService {
+  ForegroundUploadService(
+    this._uploadRepository,
+    this._storageRepository,
+    this._backupRepository,
+    this._connectivityApi,
+    this._appSettingsService,
+  );
+
+  final UploadRepository _uploadRepository;
+  final StorageRepository _storageRepository;
+  final DriftBackupRepository _backupRepository;
+  final ConnectivityApi _connectivityApi;
+  final AppSettingsService _appSettingsService;
+  final Logger _logger = Logger('ForegroundUploadService');
+
+  bool shouldAbortUpload = false;
+
+  Future<({int total, int remainder, int processing})> getBackupCounts(String userId) {
+    return _backupRepository.getAllCounts(userId);
+  }
+
+  Future<List<LocalAsset>> getBackupCandidates(String userId, {bool onlyHashed = true}) {
+    return _backupRepository.getCandidates(userId, onlyHashed: onlyHashed);
+  }
+
+  /// Bulk upload of backup candidates from selected albums
+  Future<void> uploadCandidates(
+    String userId,
+    CancellationToken cancelToken, {
+    UploadCallbacks callbacks = const UploadCallbacks(),
+    bool useSequentialUpload = false,
+  }) async {
+    final candidates = await _backupRepository.getCandidates(userId);
+    if (candidates.isEmpty) {
+      return;
+    }
+
+    final networkCapabilities = await _connectivityApi.getCapabilities();
+    final hasWifi = networkCapabilities.isUnmetered;
+    _logger.info('Network capabilities: $networkCapabilities, hasWifi/isUnmetered: $hasWifi');
+
+    if (useSequentialUpload) {
+      await _uploadSequentially(items: candidates, cancelToken: cancelToken, hasWifi: hasWifi, callbacks: callbacks);
+    } else {
+      await _executeWithWorkerPool<LocalAsset>(
+        items: candidates,
+        cancelToken: cancelToken,
+        shouldSkip: (asset) {
+          final requireWifi = _shouldRequireWiFi(asset);
+          return requireWifi && !hasWifi;
+        },
+        processItem: (asset, httpClient) => _uploadSingleAsset(asset, httpClient, cancelToken, callbacks: callbacks),
+      );
+    }
+  }
+
+  /// Sequential upload - used for background isolate where concurrent HTTP clients may cause issues
+  Future<void> _uploadSequentially({
+    required List<LocalAsset> items,
+    required CancellationToken cancelToken,
+    required bool hasWifi,
+    required UploadCallbacks callbacks,
+  }) async {
+    final httpClient = Client();
+    await _storageRepository.clearCache();
+    shouldAbortUpload = false;
+
+    try {
+      for (final asset in items) {
+        if (shouldAbortUpload || cancelToken.isCancelled) {
+          break;
+        }
+
+        final requireWifi = _shouldRequireWiFi(asset);
+        if (requireWifi && !hasWifi) {
+          _logger.warning('Skipping upload for ${asset.id} because it requires WiFi');
+          continue;
+        }
+
+        await _uploadSingleAsset(asset, httpClient, cancelToken, callbacks: callbacks);
+      }
+    } finally {
+      httpClient.close();
+    }
+  }
+
+  /// Manually upload picked local assets
+  Future<void> uploadManual(
+    List<LocalAsset> localAssets,
+    CancellationToken cancelToken, {
+    UploadCallbacks callbacks = const UploadCallbacks(),
+  }) async {
+    if (localAssets.isEmpty) {
+      return;
+    }
+
+    await _executeWithWorkerPool<LocalAsset>(
+      items: localAssets,
+      cancelToken: cancelToken,
+      processItem: (asset, httpClient) => _uploadSingleAsset(asset, httpClient, cancelToken, callbacks: callbacks),
+    );
+  }
+
+  /// Upload files from shared intent
+  Future<void> uploadShareIntent(
+    List<File> files, {
+    CancellationToken? cancelToken,
+    void Function(String fileId, int bytes, int totalBytes)? onProgress,
+    void Function(String fileId)? onSuccess,
+    void Function(String fileId, String errorMessage)? onError,
+  }) async {
+    if (files.isEmpty) {
+      return;
+    }
+
+    final effectiveCancelToken = cancelToken ?? CancellationToken();
+
+    await _executeWithWorkerPool<File>(
+      items: files,
+      cancelToken: effectiveCancelToken,
+      processItem: (file, httpClient) async {
+        final fileId = p.hash(file.path).toString();
+
+        final result = await _uploadSingleFile(
+          file,
+          deviceAssetId: fileId,
+          httpClient: httpClient,
+          cancelToken: effectiveCancelToken,
+          onProgress: (bytes, totalBytes) => onProgress?.call(fileId, bytes, totalBytes),
+        );
+
+        if (result.isSuccess) {
+          onSuccess?.call(fileId);
+        } else if (!result.isCancelled && result.errorMessage != null) {
+          onError?.call(fileId, result.errorMessage!);
+        }
+      },
+    );
+  }
+
+  void cancel() {
+    shouldAbortUpload = true;
+  }
+
+  /// Generic worker pool for concurrent uploads
+  ///
+  /// [items] - List of items to process
+  /// [cancelToken] - Token to cancel the operation
+  /// [processItem] - Function to process each item with an HTTP client
+  /// [shouldSkip] - Optional function to skip items (e.g., WiFi requirement check)
+  /// [concurrentWorkers] - Number of concurrent workers (default: 3)
+  Future<void> _executeWithWorkerPool<T>({
+    required List<T> items,
+    required CancellationToken cancelToken,
+    required Future<void> Function(T item, Client httpClient) processItem,
+    bool Function(T item)? shouldSkip,
+    int concurrentWorkers = 3,
+  }) async {
+    final httpClients = List.generate(concurrentWorkers, (_) => Client());
+
+    await _storageRepository.clearCache();
+    shouldAbortUpload = false;
+
+    try {
+      int currentIndex = 0;
+
+      Future<void> worker(Client httpClient) async {
+        while (true) {
+          if (shouldAbortUpload || cancelToken.isCancelled) {
+            break;
+          }
+
+          final index = currentIndex;
+          if (index >= items.length) {
+            break;
+          }
+          currentIndex++;
+
+          final item = items[index];
+
+          if (shouldSkip?.call(item) ?? false) {
+            continue;
+          }
+
+          await processItem(item, httpClient);
+        }
+      }
+
+      final workerFutures = <Future<void>>[];
+      for (int i = 0; i < concurrentWorkers; i++) {
+        workerFutures.add(worker(httpClients[i]));
+      }
+
+      await Future.wait(workerFutures);
+    } finally {
+      for (final client in httpClients) {
+        client.close();
+      }
+    }
+  }
+
+  Future<void> _uploadSingleAsset(
+    LocalAsset asset,
+    Client httpClient,
+    CancellationToken cancelToken, {
+    required UploadCallbacks callbacks,
+  }) async {
+    File? file;
+    File? livePhotoFile;
+
+    try {
+      final entity = await _storageRepository.getAssetEntityForAsset(asset);
+      if (entity == null) {
+        return;
+      }
+
+      final isAvailableLocally = await _storageRepository.isAssetAvailableLocally(asset.id);
+
+      if (!isAvailableLocally && CurrentPlatform.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) {
+          callbacks.onICloudProgress?.call(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;
+        }
+
+        // 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 (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(),
+        if (CurrentPlatform.isIOS && asset.cloudId != null)
+          'metadata': jsonEncode([
+            RemoteAssetMetadataItem(
+              key: RemoteAssetMetadataKey.mobileApp,
+              value: RemoteAssetMobileAppMetadata(
+                cloudId: asset.cloudId,
+                createdAt: asset.createdAt.toIso8601String(),
+                adjustmentTime: asset.adjustmentTime?.toIso8601String(),
+                latitude: asset.latitude?.toString(),
+                longitude: asset.longitude?.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) =>
+              callbacks.onProgress?.call(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) =>
+            callbacks.onProgress?.call(asset.localId!, originalFileName, bytes, totalBytes),
+        logContext: 'asset[${asset.localId}]',
+      );
+
+      if (result.isSuccess && result.remoteAssetId != null) {
+        callbacks.onSuccess?.call(asset.localId!, result.remoteAssetId!);
+      } else if (result.isCancelled) {
+        _logger.warning(() => "Backup was cancelled by the user");
+        shouldAbortUpload = true;
+      } else if (result.errorMessage != null) {
+        _logger.severe(
+          () =>
+              "Error(${result.statusCode}) uploading ${asset.localId} | $originalFileName | Created on ${asset.createdAt} | ${result.errorMessage}",
+        );
+
+        callbacks.onError?.call(asset.localId!, result.errorMessage!);
+
+        if (result.errorMessage == "Quota has been exceeded!") {
+          shouldAbortUpload = true;
+        }
+      }
+    } catch (error, stackTrace) {
+      _logger.severe(() => "Error backup asset: ${error.toString()}", stackTrace);
+      callbacks.onError?.call(asset.localId!, error.toString());
+    } finally {
+      if (Platform.isIOS) {
+        try {
+          await file?.delete();
+          await livePhotoFile?.delete();
+        } catch (error, stackTrace) {
+          _logger.severe(() => "ERROR deleting file: ${error.toString()}", stackTrace);
+        }
+      }
+    }
+  }
+
+  Future<UploadResult> _uploadSingleFile(
+    File file, {
+    required String deviceAssetId,
+    required Client httpClient,
+    required CancellationToken cancelToken,
+    void Function(int bytes, int totalBytes)? onProgress,
+  }) async {
+    try {
+      final stats = await file.stat();
+      final fileCreatedAt = stats.changed;
+      final fileModifiedAt = stats.modified;
+      final filename = p.basename(file.path);
+
+      final headers = ApiService.getRequestHeaders();
+      final deviceId = Store.get(StoreKey.deviceId);
+
+      final fields = {
+        'deviceAssetId': deviceAssetId,
+        'deviceId': deviceId,
+        'fileCreatedAt': fileCreatedAt.toUtc().toIso8601String(),
+        'fileModifiedAt': fileModifiedAt.toUtc().toIso8601String(),
+        'isFavorite': 'false',
+        'duration': '0',
+      };
+
+      return await _uploadRepository.uploadFile(
+        file: file,
+        originalFileName: filename,
+        headers: headers,
+        fields: fields,
+        httpClient: httpClient,
+        cancelToken: cancelToken,
+        onProgress: onProgress ?? (_, __) {},
+        logContext: 'shareIntent[$deviceAssetId]',
+      );
+    } catch (e) {
+      return UploadResult.error(errorMessage: e.toString());
+    }
+  }
+
+  bool _shouldRequireWiFi(LocalAsset asset) {
+    bool requiresWiFi = true;
+
+    if (asset.isVideo && _appSettingsService.getSetting(AppSettingsEnum.useCellularForUploadVideos)) {
+      requiresWiFi = false;
+    } else if (!asset.isVideo && _appSettingsService.getSetting(AppSettingsEnum.useCellularForUploadPhotos)) {
+      requiresWiFi = false;
+    }
+
+    return requiresWiFi;
+  }
+}