chore: bump dart sdk to 3.8 (#20355)

* chore: bump dart sdk to 3.8

* chore: make build

* make pigeon

* chore: format files

---------

Co-authored-by: shenlong-tanwen <139912620+shalong-tanwen@users.noreply.github.com>

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

@@ -60,43 +60,38 @@ class BackupNotifier extends StateNotifier<BackUpState> {
     this._backupAlbumService,
     this.ref,
   ) : super(
-          BackUpState(
-            backupProgress: BackUpProgressEnum.idle,
-            allAssetsInDatabase: const [],
-            progressInPercentage: 0,
-            progressInFileSize: "0 B / 0 B",
-            progressInFileSpeed: 0,
-            progressInFileSpeeds: const [],
-            progressInFileSpeedUpdateTime: DateTime.now(),
-            progressInFileSpeedUpdateSentBytes: 0,
-            cancelToken: CancellationToken(),
-            autoBackup: Store.get(StoreKey.autoBackup, false),
-            backgroundBackup: Store.get(StoreKey.backgroundBackup, false),
-            backupRequireWifi: Store.get(StoreKey.backupRequireWifi, true),
-            backupRequireCharging: Store.get(StoreKey.backupRequireCharging, false),
-            backupTriggerDelay: Store.get(StoreKey.backupTriggerDelay, 5000),
-            serverInfo: const ServerDiskInfo(
-              diskAvailable: "0",
-              diskSize: "0",
-              diskUse: "0",
-              diskUsagePercentage: 0,
-            ),
-            availableAlbums: const [],
-            selectedBackupAlbums: const {},
-            excludedBackupAlbums: const {},
-            allUniqueAssets: const {},
-            selectedAlbumsBackupAssetsIds: const {},
-            currentUploadAsset: CurrentUploadAsset(
-              id: '...',
-              fileCreatedAt: DateTime.parse('2020-10-04'),
-              fileName: '...',
-              fileType: '...',
-              fileSize: 0,
-              iCloudAsset: false,
-            ),
-            iCloudDownloadProgress: 0.0,
+        BackUpState(
+          backupProgress: BackUpProgressEnum.idle,
+          allAssetsInDatabase: const [],
+          progressInPercentage: 0,
+          progressInFileSize: "0 B / 0 B",
+          progressInFileSpeed: 0,
+          progressInFileSpeeds: const [],
+          progressInFileSpeedUpdateTime: DateTime.now(),
+          progressInFileSpeedUpdateSentBytes: 0,
+          cancelToken: CancellationToken(),
+          autoBackup: Store.get(StoreKey.autoBackup, false),
+          backgroundBackup: Store.get(StoreKey.backgroundBackup, false),
+          backupRequireWifi: Store.get(StoreKey.backupRequireWifi, true),
+          backupRequireCharging: Store.get(StoreKey.backupRequireCharging, false),
+          backupTriggerDelay: Store.get(StoreKey.backupTriggerDelay, 5000),
+          serverInfo: const ServerDiskInfo(diskAvailable: "0", diskSize: "0", diskUse: "0", diskUsagePercentage: 0),
+          availableAlbums: const [],
+          selectedBackupAlbums: const {},
+          excludedBackupAlbums: const {},
+          allUniqueAssets: const {},
+          selectedAlbumsBackupAssetsIds: const {},
+          currentUploadAsset: CurrentUploadAsset(
+            id: '...',
+            fileCreatedAt: DateTime.parse('2020-10-04'),
+            fileName: '...',
+            fileType: '...',
+            fileSize: 0,
+            iCloudAsset: false,
           ),
-        );
+          iCloudDownloadProgress: 0.0,
+        ),
+      );
 
   final log = Logger('BackupNotifier');
   final BackupService _backupService;
@@ -153,11 +148,7 @@ class BackupNotifier extends StateNotifier<BackUpState> {
       // disable any backup
       cancelBackup();
       setAutoBackup(false);
-      configureBackgroundBackup(
-        enabled: false,
-        onError: (msg) {},
-        onBatteryInfo: () {},
-      );
+      configureBackgroundBackup(enabled: false, onError: (msg) {}, onBatteryInfo: () {});
     }
     return _updateBackupAssetCount();
   }
@@ -175,9 +166,7 @@ class BackupNotifier extends StateNotifier<BackUpState> {
     required void Function(String msg) onError,
     required void Function() onBatteryInfo,
   }) async {
-    assert(
-      enabled != null || requireWifi != null || requireCharging != null || triggerDelay != null,
-    );
+    assert(enabled != null || requireWifi != null || requireCharging != null || triggerDelay != null);
     final bool wasEnabled = state.backgroundBackup;
     final bool wasWifi = state.backupRequireWifi;
     final bool wasCharging = state.backupRequireCharging;
@@ -197,7 +186,8 @@ class BackupNotifier extends StateNotifier<BackUpState> {
         }
         success &= await _backgroundService.enableService(immediate: true);
       }
-      success &= success &&
+      success &=
+          success &&
           await _backgroundService.configureService(
             requireUnmetered: state.backupRequireWifi,
             requireCharging: state.backupRequireCharging,
@@ -206,10 +196,7 @@ class BackupNotifier extends StateNotifier<BackUpState> {
           );
       if (success) {
         await Store.put(StoreKey.backupRequireWifi, state.backupRequireWifi);
-        await Store.put(
-          StoreKey.backupRequireCharging,
-          state.backupRequireCharging,
-        );
+        await Store.put(StoreKey.backupRequireCharging, state.backupRequireCharging);
         await Store.put(StoreKey.backupTriggerDelay, state.backupTriggerDelay);
         await Store.put(StoreKey.backgroundBackup, state.backgroundBackup);
       } else {
@@ -296,14 +283,9 @@ class BackupNotifier extends StateNotifier<BackUpState> {
       }
     }
 
-    state = state.copyWith(
-      selectedBackupAlbums: selectedAlbums,
-      excludedBackupAlbums: excludedAlbums,
-    );
+    state = state.copyWith(selectedBackupAlbums: selectedAlbums, excludedBackupAlbums: excludedAlbums);
 
-    log.info(
-      "_getBackupAlbumsInfo: Found ${availableAlbums.length} available albums",
-    );
+    log.info("_getBackupAlbumsInfo: Found ${availableAlbums.length} available albums");
     debugPrint("_getBackupAlbumsInfo takes ${stopwatch.elapsedMilliseconds}ms");
   }
 
@@ -333,21 +315,14 @@ class BackupNotifier extends StateNotifier<BackUpState> {
       for (final asset in assets) {
         List<String> albumNames = [album.name];
 
-        final existingAsset = assetsFromSelectedAlbums.firstWhereOrNull(
-          (a) => a.asset.localId == asset.localId,
-        );
+        final existingAsset = assetsFromSelectedAlbums.firstWhereOrNull((a) => a.asset.localId == asset.localId);
 
         if (existingAsset != null) {
           albumNames.addAll(existingAsset.albumNames);
           assetsFromSelectedAlbums.remove(existingAsset);
         }
 
-        assetsFromSelectedAlbums.add(
-          BackupCandidate(
-            asset: asset,
-            albumNames: albumNames,
-          ),
-        );
+        assetsFromSelectedAlbums.add(BackupCandidate(asset: asset, albumNames: albumNames));
       }
     }
 
@@ -361,9 +336,7 @@ class BackupNotifier extends StateNotifier<BackUpState> {
       final assets = await ref.read(albumMediaRepositoryProvider).getAssets(album.album.localId!);
 
       for (final asset in assets) {
-        assetsFromExcludedAlbums.add(
-          BackupCandidate(asset: asset, albumNames: [album.name]),
-        );
+        assetsFromExcludedAlbums.add(BackupCandidate(asset: asset, albumNames: [album.name]));
       }
     }
 
@@ -381,9 +354,7 @@ class BackupNotifier extends StateNotifier<BackUpState> {
     selectedAlbumsBackupAssets.removeWhere((assetId) => !allAssetsInDatabase.contains(assetId));
 
     // Remove duplicated asset from all unique assets
-    allUniqueAssets.removeWhere(
-      (candidate) => duplicatedAssetIds.contains(candidate.asset.localId),
-    );
+    allUniqueAssets.removeWhere((candidate) => duplicatedAssetIds.contains(candidate.asset.localId));
 
     if (allUniqueAssets.isEmpty) {
       log.info("No assets are selected for back up");
@@ -509,9 +480,7 @@ class BackupNotifier extends StateNotifier<BackUpState> {
   }
 
   void setAvailableAlbums(availableAlbums) {
-    state = state.copyWith(
-      availableAlbums: availableAlbums,
-    );
+    state = state.copyWith(availableAlbums: availableAlbums);
   }
 
   void _onBackupError(ErrorUploadAsset errorAssetInfo) {
@@ -541,28 +510,20 @@ class BackupNotifier extends StateNotifier<BackUpState> {
     if (result.isDuplicate) {
       state = state.copyWith(
         allUniqueAssets: state.allUniqueAssets
-            .where(
-              (candidate) => candidate.asset.localId != result.candidate.asset.localId,
-            )
+            .where((candidate) => candidate.asset.localId != result.candidate.asset.localId)
             .toSet(),
       );
     } else {
       state = state.copyWith(
-        selectedAlbumsBackupAssetsIds: {
-          ...state.selectedAlbumsBackupAssetsIds,
-          result.candidate.asset.localId!,
-        },
-        allAssetsInDatabase: [
-          ...state.allAssetsInDatabase,
-          result.candidate.asset.localId!,
-        ],
+        selectedAlbumsBackupAssetsIds: {...state.selectedAlbumsBackupAssetsIds, result.candidate.asset.localId!},
+        allAssetsInDatabase: [...state.allAssetsInDatabase, result.candidate.asset.localId!],
       );
     }
 
     if (state.allUniqueAssets.length - state.selectedAlbumsBackupAssetsIds.length == 0) {
-      final latestAssetBackup = state.allUniqueAssets.map((candidate) => candidate.asset.fileModifiedAt).reduce(
-            (v, e) => e.isAfter(v) ? e : v,
-          );
+      final latestAssetBackup = state.allUniqueAssets
+          .map((candidate) => candidate.asset.fileModifiedAt)
+          .reduce((v, e) => e.isAfter(v) ? e : v);
       state = state.copyWith(
         selectedBackupAlbums: state.selectedBackupAlbums.map((e) => e.copyWith(lastBackup: latestAssetBackup)).toSet(),
         excludedBackupAlbums: state.excludedBackupAlbums.map((e) => e.copyWith(lastBackup: latestAssetBackup)).toSet(),
@@ -594,9 +555,7 @@ class BackupNotifier extends StateNotifier<BackUpState> {
     }
 
     if (duration.inSeconds > 0) {
-      lastUploadSpeeds.add(
-        ((sent - lastSentBytes) / duration.inSeconds).abs().roundToDouble(),
-      );
+      lastUploadSpeeds.add(((sent - lastSentBytes) / duration.inSeconds).abs().roundToDouble());
 
       lastUploadSpeed = lastUploadSpeeds.average.abs().roundToDouble();
       lastUpdateTime = now;
@@ -618,9 +577,7 @@ class BackupNotifier extends StateNotifier<BackUpState> {
 
     // Update server info
     if (diskInfo != null) {
-      state = state.copyWith(
-        serverInfo: diskInfo,
-      );
+      state = state.copyWith(serverInfo: diskInfo);
     }
   }
 
@@ -665,17 +622,11 @@ class BackupNotifier extends StateNotifier<BackUpState> {
     Set<AvailableAlbum> selectedAlbums = state.selectedBackupAlbums;
     Set<AvailableAlbum> excludedAlbums = state.excludedBackupAlbums;
     if (selectedAlbums.isNotEmpty) {
-      selectedAlbums = _updateAlbumsBackupTime(
-        selectedAlbums,
-        selectedBackupAlbums,
-      );
+      selectedAlbums = _updateAlbumsBackupTime(selectedAlbums, selectedBackupAlbums);
     }
 
     if (excludedAlbums.isNotEmpty) {
-      excludedAlbums = _updateAlbumsBackupTime(
-        excludedAlbums,
-        excludedBackupAlbums,
-      );
+      excludedAlbums = _updateAlbumsBackupTime(excludedAlbums, excludedBackupAlbums);
     }
     final BackUpProgressEnum previous = state.backupProgress;
     state = state.copyWith(
@@ -692,32 +643,21 @@ class BackupNotifier extends StateNotifier<BackUpState> {
     return _resumeBackup();
   }
 
-  Set<AvailableAlbum> _updateAlbumsBackupTime(
-    Set<AvailableAlbum> albums,
-    List<BackupAlbum> backupAlbums,
-  ) {
+  Set<AvailableAlbum> _updateAlbumsBackupTime(Set<AvailableAlbum> albums, List<BackupAlbum> backupAlbums) {
     Set<AvailableAlbum> result = {};
     for (BackupAlbum ba in backupAlbums) {
       try {
         AvailableAlbum a = albums.firstWhere((e) => e.id == ba.id);
         result.add(a.copyWith(lastBackup: ba.lastBackup));
       } on StateError {
-        log.severe(
-          "[_updateAlbumBackupTime] failed to find album in state",
-          "State Error",
-          StackTrace.current,
-        );
+        log.severe("[_updateAlbumBackupTime] failed to find album in state", "State Error", StackTrace.current);
       }
     }
     return result;
   }
 
   Future<void> notifyBackgroundServiceCanRun() async {
-    const allowedStates = [
-      AppLifeCycleEnum.inactive,
-      AppLifeCycleEnum.paused,
-      AppLifeCycleEnum.detached,
-    ];
+    const allowedStates = [AppLifeCycleEnum.inactive, AppLifeCycleEnum.paused, AppLifeCycleEnum.detached];
     if (allowedStates.contains(ref.read(appStateProvider.notifier).state)) {
       _backgroundService.releaseLock();
     }

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

@@ -5,9 +5,7 @@ import 'package:immich_mobile/infrastructure/repositories/local_album.repository
 import 'package:immich_mobile/providers/infrastructure/album.provider.dart';
 
 final backupAlbumProvider = StateNotifierProvider<BackupAlbumNotifier, List<LocalAlbum>>(
-  (ref) => BackupAlbumNotifier(
-    ref.watch(localAlbumServiceProvider),
-  ),
+  (ref) => BackupAlbumNotifier(ref.watch(localAlbumServiceProvider)),
 );
 
 class BackupAlbumNotifier extends StateNotifier<List<LocalAlbum>> {

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

@@ -64,7 +64,8 @@ class BackupVerification extends _$BackupVerification {
               onOk: () => _performDeletion(context, toDelete),
               title: "Corrupt backups!",
               ok: "Delete",
-              content: "Found ${toDelete.length} (max $limit at once) corrupt asset backups. "
+              content:
+                  "Found ${toDelete.length} (max $limit at once) corrupt asset backups. "
                   "Run the check again to find more.\n"
                   "Do you want to delete the corrupt asset backups now?",
             ),
@@ -77,23 +78,18 @@ class BackupVerification extends _$BackupVerification {
     }
   }
 
-  Future<void> _performDeletion(
-    BuildContext context,
-    List<Asset> assets,
-  ) async {
+  Future<void> _performDeletion(BuildContext context, List<Asset> assets) async {
     try {
       state = true;
       if (context.mounted) {
-        ImmichToast.show(
-          context: context,
-          msg: "Deleting ${assets.length} assets on the server...",
-        );
+        ImmichToast.show(context: context, msg: "Deleting ${assets.length} assets on the server...");
       }
       await ref.read(assetProvider.notifier).deleteAssets(assets, force: true);
       if (context.mounted) {
         ImmichToast.show(
           context: context,
-          msg: "Deleted ${assets.length} assets on the server. "
+          msg:
+              "Deleted ${assets.length} assets on the server. "
               "You can now start a manual backup",
           toastType: ToastType.success,
         );

mobile/lib/providers/backup/backup_verification.provider.g.dart

@@ -13,14 +13,14 @@ String _$backupVerificationHash() =>
 @ProviderFor(BackupVerification)
 final backupVerificationProvider =
     AutoDisposeNotifierProvider<BackupVerification, bool>.internal(
-  BackupVerification.new,
-  name: r'backupVerificationProvider',
-  debugGetCreateSourceHash: const bool.fromEnvironment('dart.vm.product')
-      ? null
-      : _$backupVerificationHash,
-  dependencies: null,
-  allTransitiveDependencies: null,
-);
+      BackupVerification.new,
+      name: r'backupVerificationProvider',
+      debugGetCreateSourceHash: const bool.fromEnvironment('dart.vm.product')
+          ? null
+          : _$backupVerificationHash,
+      dependencies: null,
+      allTransitiveDependencies: null,
+    );
 
 typedef _$BackupVerification = AutoDisposeNotifier<bool>;
 // ignore_for_file: type=lint

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

@@ -14,19 +14,10 @@ class EnqueueStatus {
   final int enqueueCount;
   final int totalCount;
 
-  const EnqueueStatus({
-    required this.enqueueCount,
-    required this.totalCount,
-  });
+  const EnqueueStatus({required this.enqueueCount, required this.totalCount});
 
-  EnqueueStatus copyWith({
-    int? enqueueCount,
-    int? totalCount,
-  }) {
-    return EnqueueStatus(
-      enqueueCount: enqueueCount ?? this.enqueueCount,
-      totalCount: totalCount ?? this.totalCount,
-    );
+  EnqueueStatus copyWith({int? enqueueCount, int? totalCount}) {
+    return EnqueueStatus(enqueueCount: enqueueCount ?? this.enqueueCount, totalCount: totalCount ?? this.totalCount);
   }
 
   @override
@@ -197,25 +188,22 @@ class DriftBackupState {
 }
 
 final driftBackupProvider = StateNotifierProvider<ExpBackupNotifier, DriftBackupState>((ref) {
-  return ExpBackupNotifier(
-    ref.watch(uploadServiceProvider),
-  );
+  return ExpBackupNotifier(ref.watch(uploadServiceProvider));
 });
 
 class ExpBackupNotifier extends StateNotifier<DriftBackupState> {
-  ExpBackupNotifier(
-    this._uploadService,
-  ) : super(
-          const DriftBackupState(
-            totalCount: 0,
-            backupCount: 0,
-            remainderCount: 0,
-            enqueueCount: 0,
-            enqueueTotalCount: 0,
-            isCanceling: false,
-            uploadItems: {},
-          ),
-        ) {
+  ExpBackupNotifier(this._uploadService)
+    : super(
+        const DriftBackupState(
+          totalCount: 0,
+          backupCount: 0,
+          remainderCount: 0,
+          enqueueCount: 0,
+          enqueueTotalCount: 0,
+          isCanceling: false,
+          uploadItems: {},
+        ),
+      ) {
     {
       _uploadService.taskStatusStream.listen(_handleTaskStatusUpdate);
       _uploadService.taskProgressStream.listen(_handleTaskProgressUpdate);
@@ -241,10 +229,7 @@ class ExpBackupNotifier extends StateNotifier<DriftBackupState> {
     switch (update.status) {
       case TaskStatus.complete:
         if (update.task.group == kBackupGroup) {
-          state = state.copyWith(
-            backupCount: state.backupCount + 1,
-            remainderCount: state.remainderCount - 1,
-          );
+          state = state.copyWith(backupCount: state.backupCount + 1, remainderCount: state.remainderCount - 1);
         }
 
         // Remove the completed task from the upload items
@@ -260,14 +245,7 @@ class ExpBackupNotifier extends StateNotifier<DriftBackupState> {
           return;
         }
 
-        state = state.copyWith(
-          uploadItems: {
-            ...state.uploadItems,
-            taskId: currentItem.copyWith(
-              isFailed: true,
-            ),
-          },
-        );
+        state = state.copyWith(uploadItems: {...state.uploadItems, taskId: currentItem.copyWith(isFailed: true)});
         break;
 
       case TaskStatus.canceled:
@@ -299,9 +277,7 @@ class ExpBackupNotifier extends StateNotifier<DriftBackupState> {
                   fileSize: update.expectedFileSize,
                   networkSpeedAsString: update.networkSpeedAsString,
                 )
-              : currentItem.copyWith(
-                  progress: progress,
-                ),
+              : currentItem.copyWith(progress: progress),
         },
       );
 
@@ -329,11 +305,7 @@ class ExpBackupNotifier extends StateNotifier<DriftBackupState> {
       _uploadService.getBackupRemainderCount(userId),
     ]);
 
-    state = state.copyWith(
-      totalCount: totalCount,
-      backupCount: backupCount,
-      remainderCount: remainderCount,
-    );
+    state = state.copyWith(totalCount: totalCount, backupCount: backupCount, remainderCount: remainderCount);
   }
 
   Future<void> startBackup(String userId) {
@@ -341,34 +313,22 @@ class ExpBackupNotifier extends StateNotifier<DriftBackupState> {
   }
 
   void _updateEnqueueCount(EnqueueStatus status) {
-    state = state.copyWith(
-      enqueueCount: status.enqueueCount,
-      enqueueTotalCount: status.totalCount,
-    );
+    state = state.copyWith(enqueueCount: status.enqueueCount, enqueueTotalCount: status.totalCount);
   }
 
   Future<void> cancel() async {
     debugPrint("Canceling backup tasks...");
-    state = state.copyWith(
-      enqueueCount: 0,
-      enqueueTotalCount: 0,
-      isCanceling: true,
-    );
+    state = state.copyWith(enqueueCount: 0, enqueueTotalCount: 0, isCanceling: true);
 
     final activeTaskCount = await _uploadService.cancelBackup();
 
     if (activeTaskCount > 0) {
-      debugPrint(
-        "$activeTaskCount tasks left, continuing to cancel...",
-      );
+      debugPrint("$activeTaskCount tasks left, continuing to cancel...");
       await cancel();
     } else {
       debugPrint("All tasks canceled successfully.");
       // Clear all upload items when cancellation is complete
-      state = state.copyWith(
-        isCanceling: false,
-        uploadItems: {},
-      );
+      state = state.copyWith(isCanceling: false, uploadItems: {});
     }
   }
 

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

@@ -56,44 +56,43 @@ class ManualUploadNotifier extends StateNotifier<ManualUploadState> {
     this._backupAlbumService,
     this.ref,
   ) : super(
-          ManualUploadState(
-            progressInPercentage: 0,
-            progressInFileSize: "0 B / 0 B",
-            progressInFileSpeed: 0,
-            progressInFileSpeeds: const [],
-            progressInFileSpeedUpdateTime: DateTime.now(),
-            progressInFileSpeedUpdateSentBytes: 0,
-            cancelToken: CancellationToken(),
-            currentUploadAsset: CurrentUploadAsset(
-              id: '...',
-              fileCreatedAt: DateTime.parse('2020-10-04'),
-              fileName: '...',
-              fileType: '...',
-            ),
-            totalAssetsToUpload: 0,
-            successfulUploads: 0,
-            currentAssetIndex: 0,
-            showDetailedNotification: false,
+        ManualUploadState(
+          progressInPercentage: 0,
+          progressInFileSize: "0 B / 0 B",
+          progressInFileSpeed: 0,
+          progressInFileSpeeds: const [],
+          progressInFileSpeedUpdateTime: DateTime.now(),
+          progressInFileSpeedUpdateSentBytes: 0,
+          cancelToken: CancellationToken(),
+          currentUploadAsset: CurrentUploadAsset(
+            id: '...',
+            fileCreatedAt: DateTime.parse('2020-10-04'),
+            fileName: '...',
+            fileType: '...',
           ),
-        );
+          totalAssetsToUpload: 0,
+          successfulUploads: 0,
+          currentAssetIndex: 0,
+          showDetailedNotification: false,
+        ),
+      );
 
   String _lastPrintedDetailContent = '';
   String? _lastPrintedDetailTitle;
 
   static const notifyInterval = Duration(milliseconds: 500);
   late final ThrottleProgressUpdate _throttledNotifiy = ThrottleProgressUpdate(_updateProgress, notifyInterval);
-  late final ThrottleProgressUpdate _throttledDetailNotify =
-      ThrottleProgressUpdate(_updateDetailProgress, notifyInterval);
+  late final ThrottleProgressUpdate _throttledDetailNotify = ThrottleProgressUpdate(
+    _updateDetailProgress,
+    notifyInterval,
+  );
 
   void _updateProgress(String? title, int progress, int total) {
     // Guard against throttling calling this method after the upload is done
     if (_backupProvider.backupProgress == BackUpProgressEnum.manualInProgress) {
       _localNotificationService.showOrUpdateManualUploadStatus(
         "backup_background_service_in_progress_notification".tr(),
-        formatAssetBackupProgress(
-          state.currentAssetIndex,
-          state.totalAssetsToUpload,
-        ),
+        formatAssetBackupProgress(state.currentAssetIndex, state.totalAssetsToUpload),
         maxProgress: state.totalAssetsToUpload,
         progress: state.currentAssetIndex,
         showActions: true,
@@ -146,9 +145,7 @@ class ManualUploadNotifier extends StateNotifier<ManualUploadState> {
     }
 
     if (duration.inSeconds > 0) {
-      lastUploadSpeeds.add(
-        ((sent - lastSentBytes) / duration.inSeconds).abs().roundToDouble(),
-      );
+      lastUploadSpeeds.add(((sent - lastSentBytes) / duration.inSeconds).abs().roundToDouble());
 
       lastUploadSpeed = lastUploadSpeeds.average.abs().roundToDouble();
       lastUpdateTime = now;
@@ -165,23 +162,22 @@ class ManualUploadNotifier extends StateNotifier<ManualUploadState> {
     );
 
     if (state.showDetailedNotification) {
-      final title = "backup_background_service_current_upload_notification"
-          .tr(namedArgs: {'filename': state.currentUploadAsset.fileName});
+      final title = "backup_background_service_current_upload_notification".tr(
+        namedArgs: {'filename': state.currentUploadAsset.fileName},
+      );
       _throttledDetailNotify(title: title, progress: sent, total: total);
     }
   }
 
   void _onSetCurrentBackupAsset(CurrentUploadAsset currentUploadAsset) {
-    state = state.copyWith(
-      currentUploadAsset: currentUploadAsset,
-      currentAssetIndex: state.currentAssetIndex + 1,
-    );
+    state = state.copyWith(currentUploadAsset: currentUploadAsset, currentAssetIndex: state.currentAssetIndex + 1);
     if (state.totalAssetsToUpload > 1) {
       _throttledNotifiy();
     }
     if (state.showDetailedNotification) {
-      _throttledDetailNotify.title = "backup_background_service_current_upload_notification"
-          .tr(namedArgs: {'filename': currentUploadAsset.fileName});
+      _throttledDetailNotify.title = "backup_background_service_current_upload_notification".tr(
+        namedArgs: {'filename': currentUploadAsset.fileName},
+      );
       _throttledDetailNotify.progress = 0;
       _throttledDetailNotify.total = 0;
     }
@@ -216,10 +212,7 @@ class ManualUploadNotifier extends StateNotifier<ManualUploadState> {
         // Extrack candidate from allAssetsFromDevice
         final uploadAssets = candidates.where(
           (candidate) =>
-              allAssetsFromDevice.firstWhereOrNull(
-                (asset) => asset.localId == candidate.asset.localId,
-              ) !=
-              null,
+              allAssetsFromDevice.firstWhereOrNull((asset) => asset.localId == candidate.asset.localId) != null,
         );
 
         if (uploadAssets.isEmpty) {
@@ -251,14 +244,15 @@ class ManualUploadNotifier extends StateNotifier<ManualUploadState> {
         }
 
         // Show detailed asset if enabled in settings or if a single asset is uploaded
-        bool showDetailedNotification = ref.read(appSettingsServiceProvider).getSetting<bool>(
-                  AppSettingsEnum.backgroundBackupSingleProgress,
-                ) ||
+        bool showDetailedNotification =
+            ref.read(appSettingsServiceProvider).getSetting<bool>(AppSettingsEnum.backgroundBackupSingleProgress) ||
             state.totalAssetsToUpload == 1;
         state = state.copyWith(showDetailedNotification: showDetailedNotification);
         final pmProgressHandler = Platform.isIOS ? PMProgressHandler() : null;
 
-        final bool ok = await ref.read(backupServiceProvider).backupAsset(
+        final bool ok = await ref
+            .read(backupServiceProvider)
+            .backupAsset(
               uploadAssets,
               state.cancelToken,
               pmProgressHandler: pmProgressHandler,
@@ -269,9 +263,7 @@ class ManualUploadNotifier extends StateNotifier<ManualUploadState> {
             );
 
         // Close detailed notification
-        await _localNotificationService.closeNotification(
-          LocalNotificationService.manualUploadDetailedNotificationID,
-        );
+        await _localNotificationService.closeNotification(LocalNotificationService.manualUploadDetailedNotificationID);
 
         _log.info(
           '[_startUpload] Manual Upload Completed - success: ${state.successfulUploads},'
@@ -310,9 +302,7 @@ class ManualUploadNotifier extends StateNotifier<ManualUploadState> {
     } finally {
       _backupProvider.updateBackupProgress(BackUpProgressEnum.idle);
       _handleAppInActivity();
-      await _localNotificationService.closeNotification(
-        LocalNotificationService.manualUploadDetailedNotificationID,
-      );
+      await _localNotificationService.closeNotification(LocalNotificationService.manualUploadDetailedNotificationID);
       await _backupProvider.notifyBackgroundServiceCanRun();
     }
     return !hasErrors;
@@ -345,10 +335,7 @@ class ManualUploadNotifier extends StateNotifier<ManualUploadState> {
     );
   }
 
-  Future<bool> uploadAssets(
-    BuildContext context,
-    Iterable<Asset> allManualUploads,
-  ) async {
+  Future<bool> uploadAssets(BuildContext context, Iterable<Asset> allManualUploads) async {
     // assumes the background service is currently running and
     // waits until it has stopped to start the backup.
     final bool hasLock = await ref.read(backgroundServiceProvider).acquireLock();