cozy · zatteo · Feb 20, 2024 · Feb 17, 2024 · Feb 17, 2024 · Feb 17, 2024
@@ -0,0 +1,22 @@
+diff --git a/node_modules/react-native-fs/Uploader.m b/node_modules/react-native-fs/Uploader.m
+index 9463c81..04c15cf 100644
+--- a/node_modules/react-native-fs/Uploader.m
++++ b/node_modules/react-native-fs/Uploader.m
+@@ -105,8 +105,15 @@ - (void)uploadFiles:(RNFSUploadParams*)params
+   NSURLSessionConfiguration *sessionConfiguration = [NSURLSessionConfiguration defaultSessionConfiguration];
+   NSURLSession *session = [NSURLSession sessionWithConfiguration:sessionConfiguration delegate:(id)self delegateQueue:[NSOperationQueue mainQueue]];
+   _task = [session dataTaskWithRequest:req completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
+-      NSString * str = [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding];
+-      return self->_params.completeCallback(str, response);
++    // The task was cancelled
++    if (error && [error.domain isEqual:NSURLErrorDomain] && error.code == NSURLErrorCancelled) {
++      NSError* cancelError = [NSError errorWithDomain:@"Uploader" code:NSURLErrorCancelled userInfo:@{NSLocalizedDescriptionKey: [NSString stringWithFormat: @"Task was cancelled"]}];
++      return self->_params.errorCallback(cancelError);
++    }
++
++    // The task completed successfully or with an unknown error
++    NSString * str = [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding];
++    return self->_params.completeCallback(str, response);
+   }];
+   [_task resume];
+   [session finishTasksAndInvalidate];
@@ -1,4 +1,8 @@
-import { NetworkError, UploadError } from '/app/domain/upload/models'
+import {
+  NetworkError,
+  CancellationError,
+  UploadError
+} from '/app/domain/upload/models'
 
 export class BackupError extends Error {
   textMessage: string
@@ -24,6 +28,10 @@ export const isNetworkError = (error: unknown): boolean => {
   )
 }
 
+export const isCancellationError = (error: unknown): boolean => {
+  return error instanceof CancellationError
+}
+
 export const isUploadError = (error: unknown): error is UploadError => {
   return (
     typeof error === 'object' &&
@@ -49,19 +57,11 @@ export const isFileTooBigError = (error: UploadError): boolean => {
   )
 }
 
-export const isCancellationError = (error: UploadError): boolean => {
-  return (
-    error.statusCode === -1 &&
-    error.errors[0]?.detail === 'User cancelled upload'
-  )
-}
-
 export const shouldRetryCallbackBackup = (error: Error): boolean => {
   const notRetryableError =
-    isUploadError(error) &&
-    (isQuotaExceededError(error) ||
-      isFileTooBigError(error) ||
-      isCancellationError(error))
+    (isUploadError(error) &&
+      (isQuotaExceededError(error) || isFileTooBigError(error))) ||
+    isCancellationError(error)
 
   return !notRetryableError
 }
@@ -15,10 +15,12 @@ import {
 import { prepareDeduplication } from '/app/domain/backup/services/manageRemoteBackupConfig'
 import { prepareAlbums } from '/app/domain/backup/services/manageAlbums'
 import { getMediasToBackup } from '/app/domain/backup/services/getMedias'
+import { uploadMedias } from '/app/domain/backup/services/uploadMedias'
 import {
-  uploadMedias,
-  setShouldStopBackup
-} from '/app/domain/backup/services/uploadMedias'
+  StopBackupReason,
+  setStopBackupData,
+  addBackgroundSubscriptionListener
+} from '/app/domain/backup/services/stopBackup'
 import {
   cancelUpload,
   getCurrentUploadId
@@ -104,6 +106,10 @@ export const startBackup = async (
 
   void onProgress(await getBackupInfo(client))
 
+  const backgroundSubscription = addBackgroundSubscriptionListener(
+    () => void stopBackup(client, 'STOPPED_BECAUSE_BACKGROUND')
+  )
+
   try {
     const partialSuccessMessage = await uploadMedias(
       client,
@@ -186,6 +192,8 @@ export const startBackup = async (
         redirectLink: 'photos/#/backup'
       }
     })
+  } finally {
+    backgroundSubscription.remove()
   }
 
   const localBackupConfigAfterUpload = await getLocalBackupConfig(client)
@@ -205,8 +213,16 @@ export const startBackup = async (
   return await getBackupInfo(client)
 }
 
-export const stopBackup = async (client: CozyClient): Promise<BackupInfo> => {
-  setShouldStopBackup(true)
+export const stopBackup = async (
+  client: CozyClient,
+  reason: StopBackupReason = 'STOPPED_BY_USER'
+): Promise<BackupInfo> => {
+  log.debug('Stopping backup because', reason)
+
+  setStopBackupData({
+    shouldStop: true,
+    reason
+  })
 
   const uploadId = getCurrentUploadId()
 

@@ -0,0 +1,64 @@
+import { AppState, NativeEventSubscription, Platform } from 'react-native'
+
+import { t } from '/locales/i18n'
+
+export type StopBackupReason = 'STOPPED_BY_USER' | 'STOPPED_BECAUSE_BACKGROUND'
+
+interface StopBackupData {
+  shouldStop: boolean
+  reason: StopBackupReason | undefined
+  translatedReason: string
+}
+
+let stopBackupData: StopBackupData = {
+  shouldStop: false,
+  reason: undefined,
+  translatedReason: ''
+}
+
+const translateStopBackupReason = (
+  reason: StopBackupReason | undefined
+): string => {
+  if (reason === 'STOPPED_BY_USER') {
+    return t('services.backup.errors.backupStopped')
+  } else if (reason === 'STOPPED_BECAUSE_BACKGROUND') {
+    return t('services.backup.errors.appKilled')
+  }
+
+  return ''
+}
+
+export const getStopBackupData = (): StopBackupData => {
+  return stopBackupData
+}
+
+export const setStopBackupData = (
+  newStopBackupData: Omit<StopBackupData, 'translatedReason'>
+): void => {
+  stopBackupData = {
+    ...newStopBackupData,
+    translatedReason: translateStopBackupReason(newStopBackupData.reason)
+  }
+}
+
+export const resetStopBackupData = (): void => {
+  stopBackupData = {
+    shouldStop: false,
+    reason: undefined,
+    translatedReason: ''
+  }
+}
+
+export const addBackgroundSubscriptionListener = (
+  callback: () => void
+): NativeEventSubscription => {
+  return AppState.addEventListener('change', nextAppState => {
+    if (Platform.OS === 'android' && Platform.Version < 31) {
+      return
+    }
+
+    if (nextAppState === 'background') {
+      callback()
+    }
+  })
+}
@@ -1,7 +1,5 @@
 /* eslint-disable promise/always-return */
 
-import { AppState, Platform } from 'react-native'
-
 import { uploadMedia } from '/app/domain/backup/services/uploadMedia'
 import {
   setMediaAsBackupedBecauseUploaded,
@@ -30,6 +28,10 @@ import {
   areAlbumsEnabled,
   addMediaToAlbums
 } from '/app/domain/backup/services/manageAlbums'
+import {
+  getStopBackupData,
+  resetStopBackupData
+} from '/app/domain/backup/services/stopBackup'
 import { File } from '/app/domain/backup/queries'
 import { t } from '/locales/i18n'
 
@@ -38,28 +40,11 @@ import type { IOCozyFile } from 'cozy-client'
 import flag from 'cozy-flags'
 import Minilog from 'cozy-minilog'
 
+import { CancellationError } from '/app/domain/upload/models'
 const log = Minilog('💿 Backup')
 
 const DOCTYPE_FILES = 'io.cozy.files'
 
-let shouldStopBackup = false
-
-export const getShouldStopBackup = (): boolean => {
-  return shouldStopBackup
-}
-
-export const setShouldStopBackup = (value: boolean): void => {
-  shouldStopBackup = value
-}
-
-const shouldStopBecauseBackground = (): boolean => {
-  if (Platform.OS === 'android' && Platform.Version < 31) {
-    return false
-  }
-
-  return AppState.currentState === 'background'
-}
-
 export const uploadMedias = async (
   client: CozyClient,
   localBackupConfig: LocalBackupConfig,
@@ -74,15 +59,11 @@ export const uploadMedias = async (
   let firstPartialSuccessMessage: string | undefined
 
   for (const mediaToUpload of mediasToUpload) {
-    if (shouldStopBackup) {
-      shouldStopBackup = false
-      log.debug('Backup stopped because asked by the user')
-      return t('services.backup.errors.backupStopped')
-    }
-
-    if (shouldStopBecauseBackground()) {
-      log.debug('Backup stopped because in background')
-      return t('services.backup.errors.appKilled')
+    const { shouldStop, reason, translatedReason } = getStopBackupData()
+    if (shouldStop) {
+      log.debug('Backup stopped at beginning of upload loop', reason)
+      resetStopBackupData()
+      return translatedReason
     }
 
     if (flag('flagship.backup.dedup')) {
@@ -127,6 +108,13 @@ export const uploadMedias = async (
         throw new BackupError(t('services.backup.errors.networkIssue'))
       }
 
+      if (isCancellationError(error)) {
+        const { reason, translatedReason } = getStopBackupData()
+        log.debug('Backup stopped because cancellation error', reason)
+        resetStopBackupData()
+        return translatedReason
+      }
+
       if (isUploadError(error)) {
         if (isQuotaExceededError(error)) {
           throw new BackupError(
@@ -136,9 +124,6 @@ export const uploadMedias = async (
         } else if (isFileTooBigError(error)) {
           firstPartialSuccessMessage =
             firstPartialSuccessMessage ?? t('services.backup.errors.fileTooBig')
-        } else if (isCancellationError(error)) {
-          shouldStopBackup = false
-          return t('services.backup.errors.backupStopped')
         } else {
           firstPartialSuccessMessage =
             firstPartialSuccessMessage ??
@@ -179,6 +164,13 @@ const prepareAndUploadMedia = async (
     uploadMetadata,
     mediaToUpload
   )
+
+  const { shouldStop } = getStopBackupData()
+  if (shouldStop) {
+    log.debug('Backup stopped before uploading media')
+    throw new CancellationError()
+  }
+
   const { data: documentCreated } = await uploadMedia(
     client,
     uploadUrl,

@@ -40,3 +40,10 @@ export class NetworkError extends Error {
     this.name = 'NetworkError'
   }
 }
+
+export class CancellationError extends Error {
+  constructor() {
+    super()
+    this.name = 'CancellationError'
+  }
+}
@@ -9,7 +9,8 @@ import { t } from '/locales/i18n'
 import {
   UploadParams,
   UploadResult,
-  NetworkError
+  NetworkError,
+  CancellationError
 } from '/app/domain/upload/models'
 
 let currentUploadId: string | undefined
@@ -82,16 +83,7 @@ export const uploadFile = async ({
         })
         // eslint-disable-next-line @typescript-eslint/no-unused-vars
         RNBackgroundUpload.addListener('cancelled', uploadId, data => {
-          return reject({
-            statusCode: -1,
-            errors: [
-              {
-                status: -1,
-                title: 'Upload cancelled',
-                detail: 'Upload cancelled'
-              }
-            ]
-          })
+          return reject(new CancellationError())
         })
         RNBackgroundUpload.addListener('completed', uploadId, response => {
           const { data } = JSON.parse(response.responseBody) as {

@@ -6,7 +6,8 @@ import { StackErrors, IOCozyFile } from 'cozy-client'
 import {
   UploadParams,
   UploadResult,
-  NetworkError
+  NetworkError,
+  CancellationError
 } from '/app/domain/upload/models'
 
 let currentUploadId: string | undefined
@@ -27,7 +28,7 @@ export const uploadFile = async ({
   mimetype
 }: UploadParams): Promise<UploadResult> => {
   return new Promise((resolve, reject) => {
-    RNFileSystem.uploadFiles({
+    const { jobId, promise } = RNFileSystem.uploadFiles({
       toUrl: url,
       files: [
         {
@@ -47,12 +48,14 @@ export const uploadFile = async ({
         Accept: 'application/json',
         'Content-Type': mimetype,
         Authorization: `Bearer ${token}`
-      },
-      begin: ({ jobId }) => {
-        setCurrentUploadId(jobId.toString())
       }
     })
-      .promise.then(response => {
+
+    setCurrentUploadId(jobId.toString())
+
+    // Start the upload
+    promise
+      .then(response => {
         if (response.body === '' && !response.statusCode) {
           return reject(new NetworkError())
         }
@@ -75,6 +78,9 @@ export const uploadFile = async ({
         }
       })
       .catch(e => {
+        if ((e as Error).message === 'Task was cancelled') {
+          return reject(new CancellationError())
+        }
         return reject(e)
       })
   })