From bc82af48128c5ab892d6f64cf6df4131159ba6ef Mon Sep 17 00:00:00 2001
From: thomasvo <thomas.vo@openspace.ai>
Date: Thu, 2 Oct 2025 15:06:35 -0700
Subject: [PATCH 01/28] update

---
 example/RNBGUExample/App.tsx              | 82 +++++++----------------
 example/RNBGUExample/android/build.gradle |  2 +-
 example/RNBGUExample/package.json         |  2 +-
 example/RNBGUExample/yarn.lock            |  8 +--
 4 files changed, 31 insertions(+), 63 deletions(-)

diff --git a/example/RNBGUExample/App.tsx b/example/RNBGUExample/App.tsx
index 135e6141..ce6f2027 100644
--- a/example/RNBGUExample/App.tsx
+++ b/example/RNBGUExample/App.tsx
@@ -24,9 +24,6 @@ import {Colors} from 'react-native/Libraries/NewAppScreen';
 import Upload, {UploadOptions} from 'react-native-background-upload';
 
 import {launchImageLibrary} from 'react-native-image-picker';
-import {createFormDataFile} from './utils/formdata';
-
-const host = `http://${Platform.OS === 'ios' ? 'localhost' : '10.0.2.2'}:3000`;
 
 const App = () => {
   const [uploadId, setUploadId] = useState<string>();
@@ -45,11 +42,26 @@ const App = () => {
     });
   }, []);
 
-  const upload = (
-    url: string,
-    path: string,
-    headers?: UploadOptions['headers'],
-  ) => {
+  const onPressUpload = async () => {
+    const url = 'https://httpbin.org/put/404';
+
+    const response = await launchImageLibrary({mediaType: 'photo'});
+
+    console.log('ImagePicker response: ', response);
+    const {didCancel, errorMessage, assets} = response;
+    if (didCancel) return;
+
+    if (errorMessage) {
+      console.warn('ImagePicker error:', errorMessage);
+      return;
+    }
+
+    const asset = assets?.[0];
+    const path = Platform.OS === 'android' ? asset?.originalPath : asset?.uri;
+    if (!path) return Alert.alert('Invalid path');
+    if (!asset?.type) return Alert.alert('Invalid file type');
+
+    // Video is stored locally on the device
     const uploadOpts: UploadOptions = {
       android: {
         notificationId: 'RNBGUExample',
@@ -62,7 +74,9 @@ const App = () => {
       url,
       path,
       method: 'POST',
-      headers,
+      headers: {
+        'Content-Type': asset.type || '',
+      },
     };
 
     Upload.startUpload(uploadOpts)
@@ -80,26 +94,6 @@ const App = () => {
       });
   };
 
-  const getAsset = async () => {
-    const response = await launchImageLibrary({mediaType: 'photo'});
-    console.log('ImagePicker response: ', response);
-    const {didCancel, errorMessage, assets} = response;
-    if (didCancel) return;
-
-    if (errorMessage) {
-      console.warn('ImagePicker error:', errorMessage);
-      return;
-    }
-
-    const asset = assets?.[0];
-    const type = asset?.type;
-    const path = asset?.uri;
-    if (!path) return Alert.alert('Invalid file path');
-    if (!type) return Alert.alert('Invalid file type');
-
-    return {path, type} as const;
-  };
-
   return (
     <>
       <StatusBar barStyle="dark-content" />
@@ -109,33 +103,7 @@ const App = () => {
           style={styles.scrollView}>
           <View style={styles.body}>
             <View style={styles.sectionContainer}>
-              <Button
-                title="Tap To Upload Multipart"
-                onPress={async () => {
-                  const asset = await getAsset();
-                  if (!asset) return;
-
-                  const {path, contentType} = await createFormDataFile(
-                    'formdata_' + new Date().toString(),
-                    [
-                      {
-                        name: 'data',
-                        string: JSON.stringify({key: 'value'}),
-                        contentType: 'application/json',
-                      },
-                      {
-                        name: 'file',
-                        path: asset.path,
-                        contentType: asset.type,
-                      },
-                    ],
-                  );
-
-                  upload(`${host}/multipart-upload`, path, {
-                    'Content-Type': contentType,
-                  });
-                }}
-              />
+              <Button title="Upload" onPress={onPressUpload} />
 
               <View style={{height: 32}} />
               <Text style={{textAlign: 'center'}}>
@@ -147,7 +115,7 @@ const App = () => {
               <View />
               <Button
                 testID="cancel_button"
-                title="Tap to Cancel Upload"
+                title="Cancel Upload"
                 onPress={() => {
                   if (!uploadId) {
                     console.log('Nothing to cancel!');
diff --git a/example/RNBGUExample/android/build.gradle b/example/RNBGUExample/android/build.gradle
index df1ce4db..c83c9a07 100644
--- a/example/RNBGUExample/android/build.gradle
+++ b/example/RNBGUExample/android/build.gradle
@@ -1,7 +1,7 @@
 buildscript {
     ext {
         buildToolsVersion = "34.0.0"
-        minSdkVersion = 23
+        minSdkVersion = 24
         compileSdkVersion = 34
         targetSdkVersion = 34
         ndkVersion = "26.1.10909125"
diff --git a/example/RNBGUExample/package.json b/example/RNBGUExample/package.json
index 8f01cc6d..d72a0740 100644
--- a/example/RNBGUExample/package.json
+++ b/example/RNBGUExample/package.json
@@ -33,7 +33,7 @@
     "jest": "^29.6.3",
     "prettier": "2.8.8",
     "react-test-renderer": "18.3.1",
-    "typescript": "5.0.4"
+    "typescript": "^5.9.3"
   },
   "engines": {
     "node": ">=18"
diff --git a/example/RNBGUExample/yarn.lock b/example/RNBGUExample/yarn.lock
index 58301c26..dbe66e73 100644
--- a/example/RNBGUExample/yarn.lock
+++ b/example/RNBGUExample/yarn.lock
@@ -6623,10 +6623,10 @@ typed-array-length@^1.0.6:
     is-typed-array "^1.1.13"
     possible-typed-array-names "^1.0.0"
 
-typescript@5.0.4:
-  version "5.0.4"
-  resolved "https://registry.yarnpkg.com/typescript/-/typescript-5.0.4.tgz#b217fd20119bd61a94d4011274e0ab369058da3b"
-  integrity sha512-cW9T5W9xY37cc+jfEnaUvX91foxtHkza3Nw3wkoF4sSlKn0MONdkdEndig/qPBWXNkmplh3NzayQzCiHM4/hqw==
+typescript@^5.9.3:
+  version "5.9.3"
+  resolved "https://registry.yarnpkg.com/typescript/-/typescript-5.9.3.tgz#5b4f59e15310ab17a216f5d6cf53ee476ede670f"
+  integrity sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==
 
 unbox-primitive@^1.0.2:
   version "1.0.2"

From 3d02c41e0985d2df65e1ab5f9e6161cff3aa9e92 Mon Sep 17 00:00:00 2001
From: thomasvo <thomas.vo@openspace.ai>
Date: Fri, 3 Oct 2025 12:14:10 -0700
Subject: [PATCH 02/28] better example app

---
 android/build.gradle              |   2 +-
 example/RNBGUExample/App.tsx      | 144 +++++++++++++++++-------------
 example/RNBGUExample/package.json |   2 +
 example/RNBGUExample/yarn.lock    |  10 +++
 4 files changed, 95 insertions(+), 63 deletions(-)

diff --git a/android/build.gradle b/android/build.gradle
index 03cd8c44..4935c0df 100755
--- a/android/build.gradle
+++ b/android/build.gradle
@@ -85,5 +85,5 @@ dependencies {
 
     implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.6.4'
 
-    implementation "androidx.work:work-runtime-ktx:2.7.1"
+    implementation "androidx.work:work-runtime-ktx:2.8.0"
 }
diff --git a/example/RNBGUExample/App.tsx b/example/RNBGUExample/App.tsx
index ce6f2027..a75bca9e 100644
--- a/example/RNBGUExample/App.tsx
+++ b/example/RNBGUExample/App.tsx
@@ -15,19 +15,28 @@ import {
   Text,
   StatusBar,
   Button,
-  Platform,
-  Alert,
 } from 'react-native';
-
+import notifee, {
+  AndroidImportance,
+  AndroidVisibility,
+} from '@notifee/react-native';
 import {Colors} from 'react-native/Libraries/NewAppScreen';
 
 import Upload, {UploadOptions} from 'react-native-background-upload';
 
-import {launchImageLibrary} from 'react-native-image-picker';
+import * as RNFS from 'react-native-fs';
+
+const TEST_FILE = `${RNFS.DocumentDirectoryPath}/1MB.bin`;
+const TEST_FILE_URL =
+  'https://gist.githubusercontent.com/khaykov/a6105154becce4c0530da38e723c2330/raw/41ab415ac41c93a198f7da5b47d604956157c5c3/gistfile1.txt';
+const UPLOAD_URL = 'https://httpbin.org/put/404';
 
 const App = () => {
   const [uploadId, setUploadId] = useState<string>();
   const [progress, setProgress] = useState<number>();
+  const [testFileDownload, setTestFileDownload] = useState<
+    'downloading' | 'downloaded'
+  >();
 
   useEffect(() => {
     Upload.addListener('progress', null, data => {
@@ -42,41 +51,43 @@ const App = () => {
     });
   }, []);
 
-  const onPressUpload = async () => {
-    const url = 'https://httpbin.org/put/404';
-
-    const response = await launchImageLibrary({mediaType: 'photo'});
-
-    console.log('ImagePicker response: ', response);
-    const {didCancel, errorMessage, assets} = response;
-    if (didCancel) return;
+  useEffect(() => {
+    RNFS.exists('file://' + TEST_FILE)
+      .then(exists => {
+        if (exists) return;
 
-    if (errorMessage) {
-      console.warn('ImagePicker error:', errorMessage);
-      return;
-    }
+        setTestFileDownload('downloading');
+        return RNFS.downloadFile({fromUrl: TEST_FILE_URL, toFile: TEST_FILE})
+          .promise;
+      })
+      .then(() => setTestFileDownload('downloaded'));
+  }, []);
 
-    const asset = assets?.[0];
-    const path = Platform.OS === 'android' ? asset?.originalPath : asset?.uri;
-    if (!path) return Alert.alert('Invalid path');
-    if (!asset?.type) return Alert.alert('Invalid file type');
+  const onPressUpload = async () => {
+    await notifee.requestPermission({alert: true, sound: true});
+
+    const channelId = 'RNBGUExample';
+    await notifee.createChannel({
+      id: channelId,
+      name: channelId,
+      visibility: AndroidVisibility.PRIVATE,
+      // LOW so it doesn't vibrate every time a new chunk upload starts
+      importance: AndroidImportance.LOW,
+    });
 
-    // Video is stored locally on the device
     const uploadOpts: UploadOptions = {
       android: {
-        notificationId: 'RNBGUExample',
-        notificationTitle: 'RNBGUExample',
+        notificationId: channelId,
+        notificationTitle: channelId,
         notificationTitleNoWifi: 'No wifi',
         notificationTitleNoInternet: 'No internet',
-        notificationChannel: 'RNBGUExample',
+        notificationChannel: channelId,
       },
       type: 'raw',
-      url,
-      path,
+      url: UPLOAD_URL,
+      path: TEST_FILE,
       method: 'POST',
-      headers: {
-        'Content-Type': asset.type || '',
-      },
+      headers: {},
     };
 
     Upload.startUpload(uploadOpts)
@@ -98,40 +109,49 @@ const App = () => {
     <>
       <StatusBar barStyle="dark-content" />
       <SafeAreaView testID="main_screen">
-        <ScrollView
-          contentInsetAdjustmentBehavior="automatic"
-          style={styles.scrollView}>
-          <View style={styles.body}>
-            <View style={styles.sectionContainer}>
-              <Button title="Upload" onPress={onPressUpload} />
-
-              <View style={{height: 32}} />
-              <Text style={{textAlign: 'center'}}>
-                {`Current Upload ID: ${uploadId === null ? 'none' : uploadId}`}
-              </Text>
-              <Text style={{textAlign: 'center'}}>
-                {`Progress: ${progress === null ? 'none' : `${progress}%`}`}
-              </Text>
-              <View />
-              <Button
-                testID="cancel_button"
-                title="Cancel Upload"
-                onPress={() => {
-                  if (!uploadId) {
-                    console.log('Nothing to cancel!');
-                    return;
-                  }
-
-                  Upload.cancelUpload(uploadId).then(() => {
-                    console.log(`Upload ${uploadId} canceled`);
-                    setUploadId(undefined);
-                    setProgress(undefined);
-                  });
-                }}
-              />
+        <View style={{padding: 20}}>
+          {testFileDownload === 'downloading' && (
+            <Text style={{textAlign: 'center'}}>Downloading test file...</Text>
+          )}
+        </View>
+        {testFileDownload === 'downloaded' && (
+          <ScrollView
+            contentInsetAdjustmentBehavior="automatic"
+            style={styles.scrollView}>
+            <View style={styles.body}>
+              <View style={styles.sectionContainer}>
+                <Button title="Upload" onPress={onPressUpload} />
+
+                <View style={{height: 32}} />
+                <Text style={{textAlign: 'center'}}>
+                  {`Current Upload ID: ${
+                    uploadId === null ? 'none' : uploadId
+                  }`}
+                </Text>
+                <Text style={{textAlign: 'center'}}>
+                  {`Progress: ${progress === null ? 'none' : `${progress}%`}`}
+                </Text>
+                <View />
+                <Button
+                  testID="cancel_button"
+                  title="Cancel Upload"
+                  onPress={() => {
+                    if (!uploadId) {
+                      console.log('Nothing to cancel!');
+                      return;
+                    }
+
+                    Upload.cancelUpload(uploadId).then(() => {
+                      console.log(`Upload ${uploadId} canceled`);
+                      setUploadId(undefined);
+                      setProgress(undefined);
+                    });
+                  }}
+                />
+              </View>
             </View>
-          </View>
-        </ScrollView>
+          </ScrollView>
+        )}
       </SafeAreaView>
     </>
   );
diff --git a/example/RNBGUExample/package.json b/example/RNBGUExample/package.json
index d72a0740..39f38474 100644
--- a/example/RNBGUExample/package.json
+++ b/example/RNBGUExample/package.json
@@ -10,6 +10,8 @@
     "test": "jest"
   },
   "dependencies": {
+    "@notifee/react-native": "^9.1.8",
+    "notifee": "^0.0.1",
     "path": "^0.12.7",
     "react": "18.3.1",
     "react-native": "0.75.3",
diff --git a/example/RNBGUExample/yarn.lock b/example/RNBGUExample/yarn.lock
index dbe66e73..eb94e450 100644
--- a/example/RNBGUExample/yarn.lock
+++ b/example/RNBGUExample/yarn.lock
@@ -1477,6 +1477,11 @@
     "@nodelib/fs.scandir" "2.1.5"
     fastq "^1.6.0"
 
+"@notifee/react-native@^9.1.8":
+  version "9.1.8"
+  resolved "https://registry.yarnpkg.com/@notifee/react-native/-/react-native-9.1.8.tgz#3d55cb3fbcc21f9e35931e366afdf64b294da891"
+  integrity sha512-Az/dueoPerJsbbjRxu8a558wKY+gONUrfoy3Hs++5OqbeMsR0dYe6P+4oN6twrLFyzAhEA1tEoZRvQTFDRmvQg==
+
 "@react-native-community/cli-clean@14.1.0":
   version "14.1.0"
   resolved "https://registry.yarnpkg.com/@react-native-community/cli-clean/-/cli-clean-14.1.0.tgz#fee1a178fa58c84dfe18e23ee79fd3110d974971"
@@ -5343,6 +5348,11 @@ normalize-path@^3.0.0:
   resolved "https://registry.yarnpkg.com/normalize-path/-/normalize-path-3.0.0.tgz#0dcd69ff23a1c9b11fd0978316644a0388216a65"
   integrity sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==
 
+notifee@^0.0.1:
+  version "0.0.1"
+  resolved "https://registry.yarnpkg.com/notifee/-/notifee-0.0.1.tgz#0b06f1fc2dc03d2573a167148df0dd39faeb9ae8"
+  integrity sha512-R5DEyfQnhBR717u66Zut+Jx5MAOS4iLNSVEdsbiVcSzPH9S1gjxHEUJNnLnUmRTbvz8L8sUzhgkNMrtgm55UHg==
+
 npm-run-path@^4.0.1:
   version "4.0.1"
   resolved "https://registry.yarnpkg.com/npm-run-path/-/npm-run-path-4.0.1.tgz#b7ecd1e5ed53da8e37a55e1c2269e0b97ed748ea"

From 65c7e5c613d50c8c6a93b9e8f4c99871c8162953 Mon Sep 17 00:00:00 2001
From: thomasvo <thomas.vo@openspace.ai>
Date: Fri, 3 Oct 2025 12:58:48 -0700
Subject: [PATCH 03/28] fix

---
 example/RNBGUExample/package.json | 1 -
 example/RNBGUExample/yarn.lock    | 5 -----
 2 files changed, 6 deletions(-)

diff --git a/example/RNBGUExample/package.json b/example/RNBGUExample/package.json
index 39f38474..6cc6727d 100644
--- a/example/RNBGUExample/package.json
+++ b/example/RNBGUExample/package.json
@@ -11,7 +11,6 @@
   },
   "dependencies": {
     "@notifee/react-native": "^9.1.8",
-    "notifee": "^0.0.1",
     "path": "^0.12.7",
     "react": "18.3.1",
     "react-native": "0.75.3",
diff --git a/example/RNBGUExample/yarn.lock b/example/RNBGUExample/yarn.lock
index eb94e450..3cf69734 100644
--- a/example/RNBGUExample/yarn.lock
+++ b/example/RNBGUExample/yarn.lock
@@ -5348,11 +5348,6 @@ normalize-path@^3.0.0:
   resolved "https://registry.yarnpkg.com/normalize-path/-/normalize-path-3.0.0.tgz#0dcd69ff23a1c9b11fd0978316644a0388216a65"
   integrity sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==
 
-notifee@^0.0.1:
-  version "0.0.1"
-  resolved "https://registry.yarnpkg.com/notifee/-/notifee-0.0.1.tgz#0b06f1fc2dc03d2573a167148df0dd39faeb9ae8"
-  integrity sha512-R5DEyfQnhBR717u66Zut+Jx5MAOS4iLNSVEdsbiVcSzPH9S1gjxHEUJNnLnUmRTbvz8L8sUzhgkNMrtgm55UHg==
-
 npm-run-path@^4.0.1:
   version "4.0.1"
   resolved "https://registry.yarnpkg.com/npm-run-path/-/npm-run-path-4.0.1.tgz#b7ecd1e5ed53da8e37a55e1c2269e0b97ed748ea"

From 75bb6de0517bdf910d03abb19d87c553bd27297b Mon Sep 17 00:00:00 2001
From: thomasvo <thomas.vo@openspace.ai>
Date: Fri, 3 Oct 2025 13:27:21 -0700
Subject: [PATCH 04/28] upgrade

---
 android/build.gradle | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/android/build.gradle b/android/build.gradle
index 4935c0df..dee87982 100755
--- a/android/build.gradle
+++ b/android/build.gradle
@@ -85,5 +85,5 @@ dependencies {
 
     implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.6.4'
 
-    implementation "androidx.work:work-runtime-ktx:2.8.0"
+    implementation "androidx.work:work-runtime-ktx:2.8.1"
 }

From bd89d6131bcc2666ea70fa49e2f1cbb162082bc3 Mon Sep 17 00:00:00 2001
From: thomasvo <thomas.vo@openspace.ai>
Date: Fri, 3 Oct 2025 14:10:36 -0700
Subject: [PATCH 05/28] fix

---
 example/RNBGUExample/App.tsx | 2 --
 1 file changed, 2 deletions(-)

diff --git a/example/RNBGUExample/App.tsx b/example/RNBGUExample/App.tsx
index a75bca9e..00386560 100644
--- a/example/RNBGUExample/App.tsx
+++ b/example/RNBGUExample/App.tsx
@@ -70,8 +70,6 @@ const App = () => {
     await notifee.createChannel({
       id: channelId,
       name: channelId,
-      visibility: AndroidVisibility.PRIVATE,
-      // LOW so it doesn't vibrate every time a new chunk upload starts
       importance: AndroidImportance.LOW,
     });
 

From 7ad28efcab39392d00e176d32f1a4e20e4536ba7 Mon Sep 17 00:00:00 2001
From: thomasvo <thomas.vo@openspace.ai>
Date: Fri, 3 Oct 2025 14:11:52 -0700
Subject: [PATCH 06/28] remove image picker

---
 example/RNBGUExample/package.json | 3 +--
 example/RNBGUExample/yarn.lock    | 5 -----
 2 files changed, 1 insertion(+), 7 deletions(-)

diff --git a/example/RNBGUExample/package.json b/example/RNBGUExample/package.json
index 6cc6727d..02448e26 100644
--- a/example/RNBGUExample/package.json
+++ b/example/RNBGUExample/package.json
@@ -14,8 +14,7 @@
     "path": "^0.12.7",
     "react": "18.3.1",
     "react-native": "0.75.3",
-    "react-native-fs": "^2.20.0",
-    "react-native-image-picker": "^7.1.2"
+    "react-native-fs": "^2.20.0"
   },
   "devDependencies": {
     "@babel/core": "^7.20.0",
diff --git a/example/RNBGUExample/yarn.lock b/example/RNBGUExample/yarn.lock
index 3cf69734..0361c9fa 100644
--- a/example/RNBGUExample/yarn.lock
+++ b/example/RNBGUExample/yarn.lock
@@ -5778,11 +5778,6 @@ react-native-fs@^2.20.0:
     base-64 "^0.1.0"
     utf8 "^3.0.0"
 
-react-native-image-picker@^7.1.2:
-  version "7.1.2"
-  resolved "https://registry.yarnpkg.com/react-native-image-picker/-/react-native-image-picker-7.1.2.tgz#383849d1953caf4578874a1f5e5dd11c737bd5cd"
-  integrity sha512-b5y5nP60RIPxlAXlptn2QwlIuZWCUDWa/YPUVjgHc0Ih60mRiOg1PSzf0IjHSLeOZShCpirpvSPGnDExIpTRUg==
-
 react-native@0.75.3:
   version "0.75.3"
   resolved "https://registry.yarnpkg.com/react-native/-/react-native-0.75.3.tgz#31a6555a22228b75c06babe5b5edddb3ed1a457a"

From ec321f6333ddb3a7628896323acc904e72c59f78 Mon Sep 17 00:00:00 2001
From: thomasvo <thomas.vo@openspace.ai>
Date: Fri, 3 Oct 2025 15:36:48 -0700
Subject: [PATCH 07/28] init in js

---
 example/RNBGUExample/App.tsx | 26 ++++++++++++--------------
 lib/index.d.ts               |  5 +++--
 lib/types.d.ts               |  3 +--
 src/index.ts                 | 27 +++++++++++++++++++++++----
 src/types.ts                 |  3 +--
 5 files changed, 40 insertions(+), 24 deletions(-)

diff --git a/example/RNBGUExample/App.tsx b/example/RNBGUExample/App.tsx
index 00386560..d51c22c8 100644
--- a/example/RNBGUExample/App.tsx
+++ b/example/RNBGUExample/App.tsx
@@ -16,10 +16,7 @@ import {
   StatusBar,
   Button,
 } from 'react-native';
-import notifee, {
-  AndroidImportance,
-  AndroidVisibility,
-} from '@notifee/react-native';
+import notifee, {AndroidImportance} from '@notifee/react-native';
 import {Colors} from 'react-native/Libraries/NewAppScreen';
 
 import Upload, {UploadOptions} from 'react-native-background-upload';
@@ -30,6 +27,15 @@ const TEST_FILE = `${RNFS.DocumentDirectoryPath}/1MB.bin`;
 const TEST_FILE_URL =
   'https://gist.githubusercontent.com/khaykov/a6105154becce4c0530da38e723c2330/raw/41ab415ac41c93a198f7da5b47d604956157c5c3/gistfile1.txt';
 const UPLOAD_URL = 'https://httpbin.org/put/404';
+const ANDROID_NOTIFICATION_CHANNEL = 'RNBGUExample';
+
+Upload.initialize({
+  notificationId: ANDROID_NOTIFICATION_CHANNEL,
+  notificationTitle: ANDROID_NOTIFICATION_CHANNEL,
+  notificationTitleNoWifi: 'No wifi',
+  notificationTitleNoInternet: 'No internet',
+  notificationChannel: ANDROID_NOTIFICATION_CHANNEL,
+});
 
 const App = () => {
   const [uploadId, setUploadId] = useState<string>();
@@ -66,21 +72,13 @@ const App = () => {
   const onPressUpload = async () => {
     await notifee.requestPermission({alert: true, sound: true});
 
-    const channelId = 'RNBGUExample';
     await notifee.createChannel({
-      id: channelId,
-      name: channelId,
+      id: ANDROID_NOTIFICATION_CHANNEL,
+      name: ANDROID_NOTIFICATION_CHANNEL,
       importance: AndroidImportance.LOW,
     });
 
     const uploadOpts: UploadOptions = {
-      android: {
-        notificationId: channelId,
-        notificationTitle: channelId,
-        notificationTitleNoWifi: 'No wifi',
-        notificationTitleNoInternet: 'No internet',
-        notificationChannel: channelId,
-      },
       type: 'raw',
       url: UPLOAD_URL,
       path: TEST_FILE,
diff --git a/lib/index.d.ts b/lib/index.d.ts
index 32bfeeaa..1aa132e9 100644
--- a/lib/index.d.ts
+++ b/lib/index.d.ts
@@ -1,7 +1,8 @@
-import { AddListener, UploadOptions } from './types';
+import { AddListener, AndroidInitializationOptions, UploadOptions } from './types';
 export * from './types';
 declare const _default: {
-    startUpload: ({ path, android, ios, ...options }: UploadOptions) => Promise<string>;
+    initialize: (options: AndroidInitializationOptions) => void;
+    startUpload: ({ path, ios, ...options }: UploadOptions) => Promise<string>;
     cancelUpload: (cancelUploadId: string) => Promise<boolean>;
     addListener: AddListener;
     chunkFile: (parentFilePath: string, chunks: {
diff --git a/lib/types.d.ts b/lib/types.d.ts
index 085ed05f..2d4fbbb3 100644
--- a/lib/types.d.ts
+++ b/lib/types.d.ts
@@ -22,10 +22,9 @@ export type UploadOptions = {
         [index: string]: string;
     };
     wifiOnly?: boolean;
-    android: AndroidOnlyUploadOptions;
     ios?: IOSOnlyUploadOptions;
 } & RawUploadOptions;
-type AndroidOnlyUploadOptions = {
+export type AndroidInitializationOptions = {
     notificationId: string;
     notificationTitle: string;
     notificationTitleNoWifi: string;
diff --git a/src/index.ts b/src/index.ts
index 1b642881..08e83600 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -2,7 +2,12 @@
  * Handles HTTP background file uploads from an iOS or Android device.
  */
 import { NativeModules, DeviceEventEmitter, Platform } from 'react-native';
-import { AddListener, UploadId, UploadOptions } from './types';
+import {
+  AddListener,
+  AndroidInitializationOptions,
+  UploadId,
+  UploadOptions,
+} from './types';
 
 export * from './types';
 
@@ -19,6 +24,18 @@ if (NativeModules.VydiaRNFileUploader) {
   NativeModule.addListener(eventPrefix + 'completed');
 }
 
+let initializedPromise: Promise<void> | undefined;
+
+/**
+ * Initializes the module with the given options.
+ * Must be called at the global level before starting any uploads.
+ * The notification channel doesn't have to be created beforehand.
+ * @param options
+ */
+const initialize = (options: AndroidInitializationOptions) => {
+  initializedPromise = Promise.resolve(NativeModule.initialize?.(options));
+};
+
 /**
  * Starts uploading a file to an HTTP endpoint.
  * Options object:
@@ -35,12 +52,13 @@ if (NativeModules.VydiaRNFileUploader) {
  * Returns a promise with the string ID of the upload.  Will reject if there is a connection problem, the file doesn't exist, or there is some other problem.
  * It is recommended to add listeners in the .then of this promise.
 */
-const startUpload = ({
+const startUpload = async ({
   path,
-  android,
   ios,
   ...options
 }: UploadOptions): Promise<UploadId> => {
+  await initializedPromise;
+
   if (!path.startsWith(fileURIPrefix)) {
     path = fileURIPrefix + path;
   }
@@ -49,7 +67,7 @@ const startUpload = ({
     path = path.replace(fileURIPrefix, '');
   }
 
-  return NativeModule.startUpload({ ...options, ...android, ...ios, path });
+  return NativeModule.startUpload({ ...options, ...ios, path });
 };
 
 /**
@@ -127,6 +145,7 @@ const android = {
 };
 
 export default {
+  initialize,
   startUpload,
   cancelUpload,
   addListener,
diff --git a/src/types.ts b/src/types.ts
index 2498be65..ca10c9bd 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -29,11 +29,10 @@ export type UploadOptions = {
   };
   // Whether the upload should wait for wifi before starting
   wifiOnly?: boolean;
-  android: AndroidOnlyUploadOptions;
   ios?: IOSOnlyUploadOptions;
 } & RawUploadOptions;
 
-type AndroidOnlyUploadOptions = {
+export type AndroidInitializationOptions = {
   notificationId: string;
   notificationTitle: string;
   notificationTitleNoWifi: string;

From 47e53c4359f3ba1a87fe08f03ddc695993b53125 Mon Sep 17 00:00:00 2001
From: thomasvo <thomas.vo@openspace.ai>
Date: Fri, 3 Oct 2025 16:04:54 -0700
Subject: [PATCH 08/28] initialize

---
 android/build.gradle                          |  2 +
 .../com/vydia/RNUploader/UploaderModule.kt    | 54 ++++++++++++++++++-
 2 files changed, 54 insertions(+), 2 deletions(-)

diff --git a/android/build.gradle b/android/build.gradle
index dee87982..ea56b9e5 100755
--- a/android/build.gradle
+++ b/android/build.gradle
@@ -86,4 +86,6 @@ dependencies {
     implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.6.4'
 
     implementation "androidx.work:work-runtime-ktx:2.8.1"
+
+    implementation("androidx.datastore:datastore-preferences:1.1.7")
 }
diff --git a/android/src/main/java/com/vydia/RNUploader/UploaderModule.kt b/android/src/main/java/com/vydia/RNUploader/UploaderModule.kt
index 1e82963a..86372bee 100644
--- a/android/src/main/java/com/vydia/RNUploader/UploaderModule.kt
+++ b/android/src/main/java/com/vydia/RNUploader/UploaderModule.kt
@@ -1,18 +1,36 @@
 package com.vydia.RNUploader
 
+import android.content.Context
 import android.util.Log
+import androidx.datastore.preferences.core.edit
+import androidx.datastore.preferences.core.intPreferencesKey
+import androidx.datastore.preferences.core.stringPreferencesKey
+import androidx.datastore.preferences.preferencesDataStore
 import androidx.work.ExistingWorkPolicy
 import androidx.work.OneTimeWorkRequestBuilder
 import androidx.work.WorkManager
 import androidx.work.workDataOf
 import com.facebook.react.bridge.*
 import com.google.gson.Gson
+import com.vydia.RNUploader.Upload.MissingOptionException
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
 
 
-class UploaderModule(context: ReactApplicationContext) :
+// This is the recommended way to create a DataStore instance
+// https://developer.android.com/topic/libraries/architecture/datastore#preferences-create
+internal val Context.vydiaDataStore by preferencesDataStore(name = "com.vydia.RNUploader")
+
+object UploadConfigKeys {
+  val NOTIFICATION_ID = intPreferencesKey("notification_id")
+  val NOTIFICATION_TITLE = stringPreferencesKey("notification_title")
+  val NOTIFICATION_TITLE_NO_INTERNET = stringPreferencesKey("notification_title_no_internet")
+  val NOTIFICATION_TITLE_NO_WIFI = stringPreferencesKey("notification_title_no_wifi")
+  val NOTIFICATION_CHANNEL = stringPreferencesKey("notification_channel")
+}
+
+class UploaderModule(private val context: ReactApplicationContext) :
   ReactContextBaseJavaModule(context) {
 
   companion object {
@@ -46,6 +64,38 @@ class UploaderModule(context: ReactApplicationContext) :
     }
   }
 
+  @ReactMethod
+  fun initialize(opts: ReadableMap, promise: Promise) {
+    CoroutineScope(Dispatchers.IO).launch {
+      try {
+        val notificationId = opts.getString("notificationId")
+          ?: throw MissingOptionException("notificationId")
+        val notificationTitle = opts.getString("notificationTitle")
+          ?: throw MissingOptionException("notificationTitle")
+        val notificationTitleNoInternet = opts.getString("notificationTitleNoInternet")
+          ?: throw MissingOptionException("notificationTitleNoInternet")
+        val notificationTitleNoWifi = opts.getString("notificationTitleNoWifi")
+          ?: throw MissingOptionException("notificationTitleNoWifi")
+        val notificationChannel = opts.getString("notificationChannel")
+          ?: throw MissingOptionException("notificationChannel")
+
+        context.vydiaDataStore.edit { settings ->
+          settings[UploadConfigKeys.NOTIFICATION_TITLE] = notificationTitle
+          settings[UploadConfigKeys.NOTIFICATION_ID] = notificationId.hashCode()
+          settings[UploadConfigKeys.NOTIFICATION_TITLE_NO_INTERNET] = notificationTitleNoInternet
+          settings[UploadConfigKeys.NOTIFICATION_TITLE_NO_WIFI] = notificationTitleNoWifi
+          settings[UploadConfigKeys.NOTIFICATION_CHANNEL] = notificationChannel
+        }
+      } catch (exc: Throwable) {
+        if (exc !is MissingOptionException) {
+          exc.printStackTrace()
+          Log.e(TAG, exc.message, exc)
+        }
+        promise.reject(exc)
+      }
+    }
+  }
+
 
   /*
    * Starts a file upload.
@@ -57,7 +107,7 @@ class UploaderModule(context: ReactApplicationContext) :
       val id = startUpload(rawOptions)
       promise.resolve(id)
     } catch (exc: Throwable) {
-      if (exc !is Upload.MissingOptionException) {
+      if (exc !is MissingOptionException) {
         exc.printStackTrace()
         Log.e(TAG, exc.message, exc)
       }

From f82e15aa972deef1399e971c4847b90c133cb891 Mon Sep 17 00:00:00 2001
From: thomasvo <thomas.vo@openspace.ai>
Date: Fri, 3 Oct 2025 16:12:57 -0700
Subject: [PATCH 09/28] removed

---
 .../java/com/vydia/RNUploader/ChunkUtils.kt   | 56 -------------------
 .../com/vydia/RNUploader/UploaderModule.kt    | 15 -----
 ios/VydiaRNFileUploader.m                     | 50 +----------------
 lib/index.d.ts                                |  8 ---
 src/index.ts                                  | 19 -------
 5 files changed, 1 insertion(+), 147 deletions(-)
 delete mode 100644 android/src/main/java/com/vydia/RNUploader/ChunkUtils.kt

diff --git a/android/src/main/java/com/vydia/RNUploader/ChunkUtils.kt b/android/src/main/java/com/vydia/RNUploader/ChunkUtils.kt
deleted file mode 100644
index 484e9df2..00000000
--- a/android/src/main/java/com/vydia/RNUploader/ChunkUtils.kt
+++ /dev/null
@@ -1,56 +0,0 @@
-package com.vydia.RNUploader
-
-import com.facebook.react.bridge.ReadableArray
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.async
-import kotlinx.coroutines.awaitAll
-import kotlinx.coroutines.coroutineScope
-import java.io.FileInputStream
-import java.io.FileOutputStream
-
-
-data class Chunk(val position: Long, val size: Long, val path: String) {
-  companion object {
-    fun fromReadableArray(paramChunks: ReadableArray): List<Chunk> {
-      val chunks = mutableListOf<Chunk>()
-      for (i in 0 until paramChunks.size()) {
-        val paramChunk = paramChunks.getMap(i)
-        val position = paramChunk.getDouble("position").toLong()
-        val size = paramChunk.getDouble("size").toLong()
-        val path = paramChunk.getString("path") ?: throw Throwable("Path is not defined")
-
-        if (size <= 0) throw Throwable("Size is smaller than or equal 0")
-        if (position < 0) throw Throwable("Position is smaller than 0")
-
-        chunks.add(Chunk(position, size, path))
-      }
-
-      return chunks
-    }
-  }
-}
-
-private const val BUFFER_SIZE = 128 * 1024 // 128 KB
-
-suspend fun chunkFile(parentFilePath: String, chunks: List<Chunk>) = coroutineScope {
-  chunks.map { chunk ->
-    async(Dispatchers.IO) {
-      FileInputStream(parentFilePath).use { input ->
-        FileOutputStream(chunk.path).use { output ->
-          val buffer = ByteArray(BUFFER_SIZE)
-          input.skip(chunk.position)
-
-          var remainingBytes = chunk.size
-          while (remainingBytes > 0) {
-            val bytesToRead = minOf(BUFFER_SIZE.toLong(), remainingBytes).toInt()
-            val bytesRead = input.read(buffer, 0, bytesToRead)
-            if (bytesRead == -1) break
-            output.write(buffer, 0, bytesRead)
-            remainingBytes -= bytesRead
-          }
-        }
-      }
-    }
-  }.awaitAll()
-}
-
diff --git a/android/src/main/java/com/vydia/RNUploader/UploaderModule.kt b/android/src/main/java/com/vydia/RNUploader/UploaderModule.kt
index 1e82963a..0b6db02b 100644
--- a/android/src/main/java/com/vydia/RNUploader/UploaderModule.kt
+++ b/android/src/main/java/com/vydia/RNUploader/UploaderModule.kt
@@ -7,9 +7,6 @@ import androidx.work.WorkManager
 import androidx.work.workDataOf
 import com.facebook.react.bridge.*
 import com.google.gson.Gson
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.launch
 
 
 class UploaderModule(context: ReactApplicationContext) :
@@ -34,18 +31,6 @@ class UploaderModule(context: ReactApplicationContext) :
 
   override fun getName(): String = "RNFileUploader"
 
-  @ReactMethod
-  fun chunkFile(parentFilePath: String, chunks: ReadableArray, promise: Promise) {
-    CoroutineScope(Dispatchers.IO).launch {
-      try {
-        chunkFile(parentFilePath, Chunk.fromReadableArray(chunks))
-        promise.resolve(true)
-      } catch (e: Throwable) {
-        promise.reject(e)
-      }
-    }
-  }
-
 
   /*
    * Starts a file upload.
diff --git a/ios/VydiaRNFileUploader.m b/ios/VydiaRNFileUploader.m
index efce4ad6..a6021683 100644
--- a/ios/VydiaRNFileUploader.m
+++ b/ios/VydiaRNFileUploader.m
@@ -44,7 +44,7 @@ -(id) init {
 // The reason for that is self is being sent to the operating system as delegate.
 // After a JS reload, the old self still sticks around accepting events and
 // sending the events through an old instance of the RN app. This crashes the app.
-// That's why we need to use a static variable to reference the latest instance of self, 
+// That's why we need to use a static variable to reference the latest instance of self,
 // which references the latest instance of the RN app.
 - (void)_sendEventWithName:(NSString *)eventName body:(id)body {
   if (!staticEventEmitter) return;
@@ -277,54 +277,6 @@ - (void)copyAssetToFile: (NSString *)assetUrl completionHandler: (void(^)(NSStri
     resolve(NULL);
 }
 
-/*
- * Light-speed file chunking method
- * Can chunk a 2GB file in under 3s
- */
-RCT_EXPORT_METHOD(chunkFile: (NSString *)parentFilePath
-                  chunks: (NSArray<NSDictionary *> *)chunks
-                  resolve: (RCTPromiseResolveBlock)resolve
-                  reject: (RCTPromiseRejectBlock)reject
-                  ) {
-    __block NSError *error;
-
-    // Create a readonly mem map reference to the file.
-    // This does not load the whole file into memory,
-    // but converts the file into a memory region.
-    NSData *parentFile = [NSData dataWithContentsOfFile:parentFilePath options:NSDataReadingMappedAlways error:&error];
-    if(error) {
-        reject(@"ChunkFile", @"Failed to get parent file", error);
-        return;
-    };
-
-    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
-    dispatch_group_t group = dispatch_group_create();
-
-
-    for(int i = 0; i < chunks.count; i++) {
-        NSDictionary * chunk = chunks[i];
-        double rangeStart = [[chunk objectForKey:@"position"] doubleValue];
-        double rangeLength = [[chunk objectForKey:@"size"] doubleValue];
-        NSString * chunkPath = [chunk objectForKey:@"path"];
-
-
-        dispatch_group_async(group, queue, ^{
-            // This also doesn't load the file content into memory
-            NSData *chunk = [parentFile subdataWithRange:NSMakeRange(rangeStart, rangeLength)];
-            [chunk writeToFile:chunkPath options:0 error:&error];
-        });
-    }
-
-    dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
-
-    if(error) {
-        reject(@"ChunkFile", @"Failed to chunk file", error);
-        return;
-    };
-
-    resolve([NSNumber numberWithBool:YES]);
-}
-
 
 - (NSData *)createBodyWithBoundary:(NSString *)boundary
                               path:(NSString *)path
diff --git a/lib/index.d.ts b/lib/index.d.ts
index 32bfeeaa..3beeecd0 100644
--- a/lib/index.d.ts
+++ b/lib/index.d.ts
@@ -4,14 +4,6 @@ declare const _default: {
     startUpload: ({ path, android, ios, ...options }: UploadOptions) => Promise<string>;
     cancelUpload: (cancelUploadId: string) => Promise<boolean>;
     addListener: AddListener;
-    chunkFile: (parentFilePath: string, chunks: {
-        /** Byte position of the chunk */
-        position: number;
-        /** Byte length of the chunk */
-        size: number;
-        /** Where the chunk will be exported to */
-        path: string;
-    }[]) => Promise<void>;
     ios: {
         /**
          * Directly check the state of a single upload task without using event listeners.
diff --git a/src/index.ts b/src/index.ts
index 1b642881..4710e914 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -80,24 +80,6 @@ const addListener: AddListener = (eventType, uploadId, listener) =>
     }
   });
 
-/**
- * Splits a parent file into {numChunks} chunks and place them into the specified directory.
- * Each chunk file will be named by its corresponding index (0, 1, 2,...).
- */
-const chunkFile = async (
-  parentFilePath: string,
-  chunks: {
-    /** Byte position of the chunk */
-    position: number;
-    /** Byte length of the chunk */
-    size: number;
-    /** Where the chunk will be exported to */
-    path: string;
-  }[],
-) => {
-  await NativeModule.chunkFile(parentFilePath, chunks);
-};
-
 const ios = {
   /**
    * Directly check the state of a single upload task without using event listeners.
@@ -130,7 +112,6 @@ export default {
   startUpload,
   cancelUpload,
   addListener,
-  chunkFile,
   ios,
   android,
 };

From 8697d33ebb329bdca405094019ce24c2f6fb5874 Mon Sep 17 00:00:00 2001
From: thomasvo <thomas.vo@openspace.ai>
Date: Fri, 3 Oct 2025 18:19:01 -0700
Subject: [PATCH 10/28] move out of Upload

---
 android/build.gradle                          | 22 ++++++-
 .../vydia/RNUploader/NotificationConfigs.kt   | 62 +++++++++++++++++++
 .../main/java/com/vydia/RNUploader/Upload.kt  | 18 ------
 .../java/com/vydia/RNUploader/UploadUtils.kt  |  5 +-
 .../java/com/vydia/RNUploader/UploadWorker.kt | 11 ++--
 .../com/vydia/RNUploader/UploaderModule.kt    | 45 +++-----------
 .../src/main/proto/notification_configs.proto | 13 ++++
 package.json                                  |  2 +-
 8 files changed, 115 insertions(+), 63 deletions(-)
 create mode 100644 android/src/main/java/com/vydia/RNUploader/NotificationConfigs.kt
 create mode 100644 android/src/main/proto/notification_configs.proto

diff --git a/android/build.gradle b/android/build.gradle
index ea56b9e5..c67378a7 100755
--- a/android/build.gradle
+++ b/android/build.gradle
@@ -15,11 +15,13 @@ buildscript {
     dependencies {
         classpath 'com.android.tools.build:gradle:3.5.4'
         classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlinVersion"
+        classpath "com.google.protobuf:protobuf-gradle-plugin:0.9.5"
     }
 }
 
 apply plugin: 'com.android.library'
 apply plugin: 'kotlin-android'
+apply plugin: 'com.google.protobuf'
 
 def DEFAULT_COMPILE_SDK_VERSION = 28
 def DEFAULT_BUILD_TOOLS_VERSION = "28.0.3"
@@ -62,6 +64,7 @@ android {
 }
 
 repositories {
+    google()
     mavenCentral()
 }
 
@@ -69,6 +72,7 @@ def _ext = ext
 
 def _kotlinVersion = _ext.has('detoxKotlinVersion') ? _ext.detoxKotlinVersion : '1.3.10'
 def _kotlinStdlib = _ext.has('detoxKotlinStdlib') ? _ext.detoxKotlinStdlib : 'kotlin-stdlib-jdk8'
+def _protobufVersion = "4.32.1"
 
 dependencies {
     implementation "androidx.core:core-ktx:1.7.0"
@@ -87,5 +91,21 @@ dependencies {
 
     implementation "androidx.work:work-runtime-ktx:2.8.1"
 
-    implementation("androidx.datastore:datastore-preferences:1.1.7")
+    implementation "androidx.datastore:datastore:1.1.7"
+
+    implementation "com.google.protobuf:protobuf-kotlin-lite:$_protobufVersion"
 }
+
+protobuf {
+    protoc { artifact = "com.google.protobuf:protoc:$_protobufVersion" }
+
+    generateProtoTasks {
+        all().each { task ->
+            task.plugins {
+                java {
+                    option 'lite'
+                }
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/android/src/main/java/com/vydia/RNUploader/NotificationConfigs.kt b/android/src/main/java/com/vydia/RNUploader/NotificationConfigs.kt
new file mode 100644
index 00000000..3c8a7aec
--- /dev/null
+++ b/android/src/main/java/com/vydia/RNUploader/NotificationConfigs.kt
@@ -0,0 +1,62 @@
+package com.vydia.RNUploader
+
+import android.content.Context
+import androidx.datastore.core.CorruptionException
+import androidx.datastore.core.DataStore
+import androidx.datastore.core.Serializer
+import androidx.datastore.dataStore
+import com.facebook.react.bridge.ReadableMap
+import com.google.protobuf.InvalidProtocolBufferException
+import kotlinx.coroutines.flow.first
+import java.io.InputStream
+import java.io.OutputStream
+
+
+object NotificationConfigsSerializer : Serializer<NotificationConfigs> {
+  override val defaultValue: NotificationConfigs = NotificationConfigs.getDefaultInstance()
+
+  override suspend fun readFrom(input: InputStream): NotificationConfigs {
+    try {
+      return NotificationConfigs.parseFrom(input)
+    } catch (exception: InvalidProtocolBufferException) {
+      throw CorruptionException("Cannot read proto.", exception)
+    }
+  }
+
+  override suspend fun writeTo(
+    t: NotificationConfigs,
+    output: OutputStream) = t.writeTo(output)
+}
+
+// This is the recommended way to create a DataStore instance
+// https://developer.android.com/topic/libraries/architecture/datastore#preferences-create
+private val Context.vydiaNotificationConfigs: DataStore<NotificationConfigs> by dataStore(
+  fileName = "settings.pb",
+  serializer = NotificationConfigsSerializer
+)
+
+suspend fun fetchNotificationConfigs(context: Context): NotificationConfigs =
+  context.vydiaNotificationConfigs.data.first()
+
+suspend fun updateNotificationConfigs(opts: ReadableMap, context: Context) {
+  val notificationId = opts.getString("notificationId")
+    ?: throw MissingOptionException("notificationId")
+  val notificationTitle = opts.getString("notificationTitle")
+    ?: throw MissingOptionException("notificationTitle")
+  val notificationTitleNoInternet = opts.getString("notificationTitleNoInternet")
+    ?: throw MissingOptionException("notificationTitleNoInternet")
+  val notificationTitleNoWifi = opts.getString("notificationTitleNoWifi")
+    ?: throw MissingOptionException("notificationTitleNoWifi")
+  val notificationChannel = opts.getString("notificationChannel")
+    ?: throw MissingOptionException("notificationChannel")
+
+  context.vydiaNotificationConfigs.updateData { currentSettings ->
+    currentSettings.toBuilder().apply {
+      this.id = notificationId.hashCode()
+      this.title = notificationTitle
+      this.titleNoInternet = notificationTitleNoInternet
+      this.titleNoWifi = notificationTitleNoWifi
+      this.channel = notificationChannel
+    }.build()
+  }
+}
diff --git a/android/src/main/java/com/vydia/RNUploader/Upload.kt b/android/src/main/java/com/vydia/RNUploader/Upload.kt
index 5afdac69..c35fe9eb 100644
--- a/android/src/main/java/com/vydia/RNUploader/Upload.kt
+++ b/android/src/main/java/com/vydia/RNUploader/Upload.kt
@@ -14,15 +14,7 @@ data class Upload(
   val maxRetries: Int,
   val wifiOnly: Boolean,
   val headers: Map<String, String>,
-  val notificationId: String,
-  val notificationTitle: String,
-  val notificationTitleNoInternet: String,
-  val notificationTitleNoWifi: String,
-  val notificationChannel: String,
 ) {
-  class MissingOptionException(optionName: String) :
-    IllegalArgumentException("Missing '$optionName'")
-
   companion object {
     fun fromReadableMap(map: ReadableMap) = Upload(
       id = map.getString("customUploadId") ?: UUID.randomUUID().toString(),
@@ -39,16 +31,6 @@ data class Upload(
         }
         return@let map
       },
-      notificationId = map.getString(Upload::notificationId.name)
-        ?: throw MissingOptionException(Upload::notificationId.name),
-      notificationTitle = map.getString(Upload::notificationTitle.name)
-        ?: throw MissingOptionException(Upload::notificationTitle.name),
-      notificationTitleNoInternet = map.getString(Upload::notificationTitleNoInternet.name)
-        ?: throw MissingOptionException(Upload::notificationTitleNoInternet.name),
-      notificationTitleNoWifi = map.getString(Upload::notificationTitleNoWifi.name)
-        ?: throw MissingOptionException(Upload::notificationTitleNoWifi.name),
-      notificationChannel = map.getString(Upload::notificationChannel.name)
-        ?: throw MissingOptionException(Upload::notificationChannel.name),
     )
   }
 }
diff --git a/android/src/main/java/com/vydia/RNUploader/UploadUtils.kt b/android/src/main/java/com/vydia/RNUploader/UploadUtils.kt
index 57da5aac..efddd451 100644
--- a/android/src/main/java/com/vydia/RNUploader/UploadUtils.kt
+++ b/android/src/main/java/com/vydia/RNUploader/UploadUtils.kt
@@ -75,4 +75,7 @@ private fun withProgressListener(
     body.writeTo(bufferedSink)
     bufferedSink.flush()
   }
-}
\ No newline at end of file
+}
+
+class MissingOptionException(optionName: String) :
+  IllegalArgumentException("Missing '$optionName'")
\ No newline at end of file
diff --git a/android/src/main/java/com/vydia/RNUploader/UploadWorker.kt b/android/src/main/java/com/vydia/RNUploader/UploadWorker.kt
index a3fc701b..800ae2b3 100644
--- a/android/src/main/java/com/vydia/RNUploader/UploadWorker.kt
+++ b/android/src/main/java/com/vydia/RNUploader/UploadWorker.kt
@@ -212,14 +212,15 @@ class UploadWorker(private val context: Context, params: WorkerParameters) :
   // builds the notification required to enable Foreground mode
   override suspend fun getForegroundInfo(): ForegroundInfo {
     // All workers share the same notification that shows the total progress
-    val id = upload.notificationId.hashCode()
-    val channel = upload.notificationChannel
+    val notificationConfigs = fetchNotificationConfigs(context)
+    val id = notificationConfigs.id
+    val channel = notificationConfigs.channel
     val progress = UploadProgress.total(context)
     val progress2Decimals = "%.2f".format(progress)
     val title = when (connectivity) {
-      Connectivity.NoWifi -> upload.notificationTitleNoWifi
-      Connectivity.NoInternet -> upload.notificationTitleNoInternet
-      Connectivity.Ok -> upload.notificationTitle
+      Connectivity.NoWifi -> notificationConfigs.titleNoWifi
+      Connectivity.NoInternet -> notificationConfigs.titleNoInternet
+      Connectivity.Ok -> notificationConfigs.title
     }
 
     // Custom layout for progress notification.
diff --git a/android/src/main/java/com/vydia/RNUploader/UploaderModule.kt b/android/src/main/java/com/vydia/RNUploader/UploaderModule.kt
index f144b462..603cef05 100644
--- a/android/src/main/java/com/vydia/RNUploader/UploaderModule.kt
+++ b/android/src/main/java/com/vydia/RNUploader/UploaderModule.kt
@@ -1,35 +1,21 @@
 package com.vydia.RNUploader
 
-import android.content.Context
 import android.util.Log
-import androidx.datastore.preferences.core.edit
-import androidx.datastore.preferences.core.intPreferencesKey
-import androidx.datastore.preferences.core.stringPreferencesKey
-import androidx.datastore.preferences.preferencesDataStore
 import androidx.work.ExistingWorkPolicy
 import androidx.work.OneTimeWorkRequestBuilder
 import androidx.work.WorkManager
 import androidx.work.workDataOf
-import com.facebook.react.bridge.*
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.ReadableMap
 import com.google.gson.Gson
-import com.vydia.RNUploader.Upload.MissingOptionException
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
 
 
-// This is the recommended way to create a DataStore instance
-// https://developer.android.com/topic/libraries/architecture/datastore#preferences-create
-internal val Context.vydiaDataStore by preferencesDataStore(name = "com.vydia.RNUploader")
-
-object UploadConfigKeys {
-  val NOTIFICATION_ID = intPreferencesKey("notification_id")
-  val NOTIFICATION_TITLE = stringPreferencesKey("notification_title")
-  val NOTIFICATION_TITLE_NO_INTERNET = stringPreferencesKey("notification_title_no_internet")
-  val NOTIFICATION_TITLE_NO_WIFI = stringPreferencesKey("notification_title_no_wifi")
-  val NOTIFICATION_CHANNEL = stringPreferencesKey("notification_channel")
-}
-
 class UploaderModule(private val context: ReactApplicationContext) :
   ReactContextBaseJavaModule(context) {
 
@@ -52,28 +38,13 @@ class UploaderModule(private val context: ReactApplicationContext) :
 
   override fun getName(): String = "RNFileUploader"
 
+
   @ReactMethod
   fun initialize(opts: ReadableMap, promise: Promise) {
     CoroutineScope(Dispatchers.IO).launch {
       try {
-        val notificationId = opts.getString("notificationId")
-          ?: throw MissingOptionException("notificationId")
-        val notificationTitle = opts.getString("notificationTitle")
-          ?: throw MissingOptionException("notificationTitle")
-        val notificationTitleNoInternet = opts.getString("notificationTitleNoInternet")
-          ?: throw MissingOptionException("notificationTitleNoInternet")
-        val notificationTitleNoWifi = opts.getString("notificationTitleNoWifi")
-          ?: throw MissingOptionException("notificationTitleNoWifi")
-        val notificationChannel = opts.getString("notificationChannel")
-          ?: throw MissingOptionException("notificationChannel")
-
-        context.vydiaDataStore.edit { settings ->
-          settings[UploadConfigKeys.NOTIFICATION_TITLE] = notificationTitle
-          settings[UploadConfigKeys.NOTIFICATION_ID] = notificationId.hashCode()
-          settings[UploadConfigKeys.NOTIFICATION_TITLE_NO_INTERNET] = notificationTitleNoInternet
-          settings[UploadConfigKeys.NOTIFICATION_TITLE_NO_WIFI] = notificationTitleNoWifi
-          settings[UploadConfigKeys.NOTIFICATION_CHANNEL] = notificationChannel
-        }
+        updateNotificationConfigs(opts, context)
+        promise.resolve(true)
       } catch (exc: Throwable) {
         if (exc !is MissingOptionException) {
           exc.printStackTrace()
diff --git a/android/src/main/proto/notification_configs.proto b/android/src/main/proto/notification_configs.proto
new file mode 100644
index 00000000..30ace5d0
--- /dev/null
+++ b/android/src/main/proto/notification_configs.proto
@@ -0,0 +1,13 @@
+syntax = "proto3";
+
+option java_package = "com.vydia.RNUploader";
+option java_multiple_files = true;
+
+// Keep field numbers STABLE forever; add new fields with new tags.
+message NotificationConfigs {
+  int32 id = 1;
+  string title = 2;
+  string title_no_internet = 3;
+  string title_no_wifi = 4;
+  string channel = 5;
+}
diff --git a/package.json b/package.json
index d66fa806..a1e349f8 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "react-native-background-upload",
-  "version": "7.5.2",
+  "version": "8.0.0",
   "description": "Cross platform http post file uploader with android and iOS background support",
   "main": "src/index",
   "typings": "lib/index.d.ts",

From 674c96e9ac5baa5d17a1149a915775723485a15f Mon Sep 17 00:00:00 2001
From: thomasvo <thomas.vo@openspace.ai>
Date: Fri, 3 Oct 2025 18:20:07 -0700
Subject: [PATCH 11/28] private

---
 .../src/main/java/com/vydia/RNUploader/NotificationConfigs.kt   | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/android/src/main/java/com/vydia/RNUploader/NotificationConfigs.kt b/android/src/main/java/com/vydia/RNUploader/NotificationConfigs.kt
index 3c8a7aec..506ca983 100644
--- a/android/src/main/java/com/vydia/RNUploader/NotificationConfigs.kt
+++ b/android/src/main/java/com/vydia/RNUploader/NotificationConfigs.kt
@@ -12,7 +12,7 @@ import java.io.InputStream
 import java.io.OutputStream
 
 
-object NotificationConfigsSerializer : Serializer<NotificationConfigs> {
+private object NotificationConfigsSerializer : Serializer<NotificationConfigs> {
   override val defaultValue: NotificationConfigs = NotificationConfigs.getDefaultInstance()
 
   override suspend fun readFrom(input: InputStream): NotificationConfigs {

From 93c6602f6012e9b3efbbe9e1cd3bb510e3f24312 Mon Sep 17 00:00:00 2001
From: thomasvo <thomas.vo@openspace.ai>
Date: Wed, 8 Oct 2025 15:05:00 -0700
Subject: [PATCH 12/28] simpler

---
 .../main/java/com/vydia/RNUploader/NotificationConfigs.kt   | 6 ++----
 .../src/main/java/com/vydia/RNUploader/UploaderModule.kt    | 3 +--
 2 files changed, 3 insertions(+), 6 deletions(-)

diff --git a/android/src/main/java/com/vydia/RNUploader/NotificationConfigs.kt b/android/src/main/java/com/vydia/RNUploader/NotificationConfigs.kt
index 506ca983..869156f9 100644
--- a/android/src/main/java/com/vydia/RNUploader/NotificationConfigs.kt
+++ b/android/src/main/java/com/vydia/RNUploader/NotificationConfigs.kt
@@ -23,9 +23,7 @@ private object NotificationConfigsSerializer : Serializer<NotificationConfigs> {
     }
   }
 
-  override suspend fun writeTo(
-    t: NotificationConfigs,
-    output: OutputStream) = t.writeTo(output)
+  override suspend fun writeTo(t: NotificationConfigs, output: OutputStream) = t.writeTo(output)
 }
 
 // This is the recommended way to create a DataStore instance
@@ -35,7 +33,7 @@ private val Context.vydiaNotificationConfigs: DataStore<NotificationConfigs> by
   serializer = NotificationConfigsSerializer
 )
 
-suspend fun fetchNotificationConfigs(context: Context): NotificationConfigs =
+suspend fun fetchNotificationConfigs(context: Context) =
   context.vydiaNotificationConfigs.data.first()
 
 suspend fun updateNotificationConfigs(opts: ReadableMap, context: Context) {
diff --git a/android/src/main/java/com/vydia/RNUploader/UploaderModule.kt b/android/src/main/java/com/vydia/RNUploader/UploaderModule.kt
index 603cef05..543bea04 100644
--- a/android/src/main/java/com/vydia/RNUploader/UploaderModule.kt
+++ b/android/src/main/java/com/vydia/RNUploader/UploaderModule.kt
@@ -40,7 +40,7 @@ class UploaderModule(private val context: ReactApplicationContext) :
 
 
   @ReactMethod
-  fun initialize(opts: ReadableMap, promise: Promise) {
+  fun initialize(opts: ReadableMap, promise: Promise) =
     CoroutineScope(Dispatchers.IO).launch {
       try {
         updateNotificationConfigs(opts, context)
@@ -53,7 +53,6 @@ class UploaderModule(private val context: ReactApplicationContext) :
         promise.reject(exc)
       }
     }
-  }
 
 
   /*

From d68dffe68fd98c426f70b63f8116a34357e03ced Mon Sep 17 00:00:00 2001
From: thomasvo <thomas.vo@openspace.ai>
Date: Thu, 9 Oct 2025 16:55:59 -0700
Subject: [PATCH 13/28] poc

---
 .../com/vydia/RNUploader/EventReporter.kt     |  19 +--
 .../main/java/com/vydia/RNUploader/Upload.kt  |  10 +-
 .../java/com/vydia/RNUploader/UploadQueue.kt  |  58 +++++++++
 .../java/com/vydia/RNUploader/UploadUtils.kt  |  26 +++-
 .../java/com/vydia/RNUploader/UploadWorker.kt | 118 ++++++------------
 .../com/vydia/RNUploader/UploaderModule.kt    |  47 ++-----
 example/RNBGUExample/App.tsx                  |  35 ++++--
 7 files changed, 168 insertions(+), 145 deletions(-)
 create mode 100644 android/src/main/java/com/vydia/RNUploader/UploadQueue.kt

diff --git a/android/src/main/java/com/vydia/RNUploader/EventReporter.kt b/android/src/main/java/com/vydia/RNUploader/EventReporter.kt
index 32daf999..3c4e0af4 100644
--- a/android/src/main/java/com/vydia/RNUploader/EventReporter.kt
+++ b/android/src/main/java/com/vydia/RNUploader/EventReporter.kt
@@ -7,7 +7,6 @@ import com.facebook.react.modules.core.DeviceEventManagerModule.RCTDeviceEventEm
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
-import okhttp3.Response
 
 // Sends events to React Native
 class EventReporter {
@@ -24,26 +23,20 @@ class EventReporter {
         putString("error", exception.message ?: "Unknown exception")
       })
 
-    fun success(uploadId: String, response: Response) =
+    fun success(uploadId: String, response: UploadResponse) =
       CoroutineScope(Dispatchers.IO).launch {
         sendEvent("completed", Arguments.createMap().apply {
           putString("id", uploadId)
-          putInt("responseCode", response.code)
-          putString("responseBody", response.body?.string().let {
-            if (it.isNullOrBlank()) response.message else it
-          })
-          putMap("responseHeaders", Arguments.createMap().apply {
-            response.headers.names().forEach { name ->
-              putString(name, response.headers.values(name).joinToString(", "))
-            }
-          })
+          putInt("responseCode", response.statusCode)
+          putString("responseBody", response.body)
+          putMap("responseHeaders", Arguments.makeNativeMap(response.headers))
         })
       }
 
-    fun progress(uploadId: String, bytesSentTotal: Long, contentLength: Long) =
+    fun progress(uploadId: String) =
       sendEvent("progress", Arguments.createMap().apply {
         putString("id", uploadId)
-        putDouble("progress", (bytesSentTotal.toDouble() * 100 / contentLength)) //0-100
+        putDouble("progress", UploadQueue.progressPercentage().toDouble())
       })
 
     fun notification() = sendEvent("notification")
diff --git a/android/src/main/java/com/vydia/RNUploader/Upload.kt b/android/src/main/java/com/vydia/RNUploader/Upload.kt
index c35fe9eb..de7c3c25 100644
--- a/android/src/main/java/com/vydia/RNUploader/Upload.kt
+++ b/android/src/main/java/com/vydia/RNUploader/Upload.kt
@@ -15,8 +15,13 @@ data class Upload(
   val wifiOnly: Boolean,
   val headers: Map<String, String>,
 ) {
+  // Progress tracking properties
+  var bytesUploaded: Long = 0L
+  var size: Long = 0L
+  var completed: Boolean = false
+
   companion object {
-    fun fromReadableMap(map: ReadableMap) = Upload(
+    fun fromRawOptions(map: ReadableMap) = Upload(
       id = map.getString("customUploadId") ?: UUID.randomUUID().toString(),
       url = map.getString(Upload::url.name) ?: throw MissingOptionException(Upload::url.name),
       path = map.getString(Upload::path.name) ?: throw MissingOptionException(Upload::path.name),
@@ -34,6 +39,3 @@ data class Upload(
     )
   }
 }
-
-
-
diff --git a/android/src/main/java/com/vydia/RNUploader/UploadQueue.kt b/android/src/main/java/com/vydia/RNUploader/UploadQueue.kt
new file mode 100644
index 00000000..6920d893
--- /dev/null
+++ b/android/src/main/java/com/vydia/RNUploader/UploadQueue.kt
@@ -0,0 +1,58 @@
+package com.vydia.RNUploader
+
+import java.io.File
+import java.io.FileNotFoundException
+
+object UploadQueue {
+  private val queue = ArrayDeque<Upload>()
+  private var completedBytes = 0L
+
+  /**
+   * Returns the overall progress percentage of all uploads in the queue.
+   * 0 - 100
+   */
+  fun progressPercentage(): Float {
+    if (queue.isEmpty()) return 0f
+
+    val totalBytes = queue.sumOf { it.size } + completedBytes
+    if (totalBytes == 0L) return 0f
+    val uploadedBytes = current().bytesUploaded + completedBytes
+
+    return uploadedBytes.toFloat() / totalBytes.toFloat() * 100
+  }
+
+  fun add(upload: Upload) {
+    if (queue.any { it.id == upload.id }) return
+
+    val file = File(upload.path)
+    if (file.exists())
+      upload.size = file.length()
+    else
+      throw FileNotFoundException("File at path ${upload.path} does not exist")
+
+    queue.add(upload)
+  }
+
+  fun progress(uploadId: String, bytesUploaded: Long) {
+    queue.find { it.id == uploadId }?.bytesUploaded = bytesUploaded
+  }
+
+  fun complete() {
+    val upload = pop()
+
+    upload.bytesUploaded = upload.size
+    upload.completed = true
+    // Keep completed upload sizes for a while to report overall progress correctly
+    completedBytes += upload.size
+  }
+
+  fun pop() = queue.removeFirst()
+
+  fun remove(uploadId: String) = queue.removeIf { it.id === uploadId }
+
+  fun current() = queue.first()
+
+  fun clear() = queue.clear()
+
+  fun isEmpty() = queue.isEmpty()
+}
\ No newline at end of file
diff --git a/android/src/main/java/com/vydia/RNUploader/UploadUtils.kt b/android/src/main/java/com/vydia/RNUploader/UploadUtils.kt
index efddd451..c89e59d3 100644
--- a/android/src/main/java/com/vydia/RNUploader/UploadUtils.kt
+++ b/android/src/main/java/com/vydia/RNUploader/UploadUtils.kt
@@ -15,6 +15,13 @@ import kotlin.coroutines.resumeWithException
 // Throttling interval of progress reports
 private const val PROGRESS_INTERVAL = 500 // milliseconds
 
+// Data class to hold the important response information
+data class UploadResponse(
+  val statusCode: Int,
+  val statusMessage: String,
+  val headers: Map<String, String>,
+  val body: String? = null
+)
 
 // make an upload request using okhttp
 suspend fun okhttpUpload(
@@ -22,8 +29,8 @@ suspend fun okhttpUpload(
   upload: Upload,
   file: File,
   onProgress: (Long) -> Unit
-) =
-  suspendCancellableCoroutine<Response> { continuation ->
+): UploadResponse =
+  suspendCancellableCoroutine { continuation ->
     val requestBody = file.asRequestBody()
     var lastProgressReport = 0L
     fun throttled(): Boolean {
@@ -47,8 +54,19 @@ suspend fun okhttpUpload(
       override fun onFailure(call: Call, e: IOException) =
         continuation.resumeWithException(e)
 
-      override fun onResponse(call: Call, response: Response) =
-        continuation.resumeWith(Result.success(response))
+      override fun onResponse(call: Call, response: Response) {
+        response.use { // Automatically closes the response
+          val uploadResponse = UploadResponse(
+            statusCode = response.code,
+            statusMessage = response.message,
+            headers = response.headers.toMap(),
+            body = response.body?.string().let {
+              if (it.isNullOrBlank()) response.message else it
+            }
+          )
+          continuation.resumeWith(Result.success(uploadResponse))
+        }
+      }
     })
   }
 
diff --git a/android/src/main/java/com/vydia/RNUploader/UploadWorker.kt b/android/src/main/java/com/vydia/RNUploader/UploadWorker.kt
index 800ae2b3..0bb2d008 100644
--- a/android/src/main/java/com/vydia/RNUploader/UploadWorker.kt
+++ b/android/src/main/java/com/vydia/RNUploader/UploadWorker.kt
@@ -9,27 +9,22 @@ import android.net.ConnectivityManager
 import android.net.NetworkCapabilities.NET_CAPABILITY_VALIDATED
 import android.net.NetworkCapabilities.TRANSPORT_WIFI
 import android.os.Build
+import android.util.Log
 import android.widget.RemoteViews
 import androidx.core.app.NotificationCompat
 import androidx.work.CoroutineWorker
 import androidx.work.ForegroundInfo
 import androidx.work.WorkerParameters
-import com.google.gson.Gson
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.launch
-import kotlinx.coroutines.sync.Semaphore
 import kotlinx.coroutines.withContext
 import okhttp3.OkHttpClient
-import okhttp3.Response
 import java.io.File
 import java.io.IOException
 import java.net.UnknownHostException
 import java.util.concurrent.TimeUnit
 
-// All workers will start `doWork` immediately but only 1 request is active at a time.
-private const val MAX_CONCURRENCY = 1
-
 // Retry delay
 private val RETRY_DELAY = TimeUnit.SECONDS.toMillis(10L)
 
@@ -40,9 +35,6 @@ private val RETRY_DELAY = TimeUnit.SECONDS.toMillis(10L)
 private const val REQUEST_TIMEOUT = 24L
 private val REQUEST_TIMEOUT_UNIT = TimeUnit.HOURS
 
-// Control max concurrent requests using semaphore to instead of using
-// `maxConnectionsCount` in HttpClient as the latter introduces a delay between requests
-private val semaphore = Semaphore(MAX_CONCURRENCY)
 
 // Use Okhttp as it provides the most standard behaviors even though it's not coroutine friendly
 private val client = OkHttpClient.Builder()
@@ -54,37 +46,35 @@ private enum class Connectivity { NoWifi, NoInternet, Ok }
 class UploadWorker(private val context: Context, params: WorkerParameters) :
   CoroutineWorker(context, params) {
 
-  enum class Input { Params }
 
   private lateinit var upload: Upload
   private var retries = 0
   private var connectivity = Connectivity.Ok
 
   override suspend fun doWork(): Result = withContext(Dispatchers.IO) {
-    // Retrieve the upload. If this throws errors, error reporting won't work.
-    // However, the only way it has errors is the implementation is incorrect,
-    // which can be caught in development
-    val paramsJson = inputData.getString(Input.Params.name) ?: throw Throwable("No Params")
-    upload = Gson().fromJson(paramsJson, Upload::class.java)
-
-    // initialization, errors thrown here won't be retried
     try {
-      // `setForeground` is recommended for long-running workers.
-      // Foreground mode helps prioritize the worker, reducing the risk
-      // of it being killed during low memory or Doze/App Standby situations.
-      // ⚠️ This should be called in the foreground
       setForeground(getForegroundInfo())
     } catch (error: Throwable) {
-      if (!checkAndHandleCancellation()) handleError(error)
+      UploadQueue.clear()
       throw error
     }
 
+    try {
+      // Keep processing uploads until no more incomplete uploads
+      while (!UploadQueue.isEmpty()) processUpload(UploadQueue.current())
+
+      return@withContext Result.success()
+    } finally {
+      UploadQueue.clear()
+    }
+  }
+
+  private suspend fun processUpload(upload: Upload) = withContext(Dispatchers.IO) {
+    this@UploadWorker.upload = upload
+    retries = 0
+    connectivity = Connectivity.Ok
 
     // Complex work, errors thrown below here trigger retry.
-    // We don't let WorkManager manage retries and network constraints as it's very buggy.
-    // i.e. we'd occasionally get BackgroundServiceStartNotAllowedException,
-    // or ForegroundServiceStartNotAllowedException, or "isStopped" gets set to "true"
-    // for no reason
     var isRetried = false
     while (true) {
       try {
@@ -100,79 +90,53 @@ class UploadWorker(private val context: Context, params: WorkerParameters) :
         if (isRetried) delay(RETRY_DELAY)
         isRetried = true
 
-        val response = upload() ?: continue
-        handleSuccess(response)
-        return@withContext Result.success()
-      } catch (error: Throwable) {
-        if (checkAndHandleCancellation()) throw error
-        if (checkRetry(error)) continue
-        handleError(error)
-        throw error
-      }
-    }
+        val file = File(upload.path)
 
-    // This should never happen. Only here to satisfy the type check
-    return@withContext Result.failure()
-  }
+        // Don't bother to run on an invalid network
+        if (!validateAndReportConnectivity()) continue
 
-  private suspend fun upload(): Response? = withContext(Dispatchers.IO) {
-    val file = File(upload.path)
-    val size = file.length()
+        EventReporter.progress(upload.id)
 
-    // Register progress asap so the total progress is accurate
-    // This needs to happen before the semaphore wait
-    handleProgress(0, size)
+        val response = okhttpUpload(client, upload, file) { bytesSentTotal ->
+          UploadQueue.progress(upload.id, bytesSentTotal)
+          EventReporter.progress(upload.id)
 
-    // Don't bother to run on an invalid network
-    if (!validateAndReportConnectivity()) return@withContext null
+          launch { setForeground(getForegroundInfo()) }
+        }
 
-    // wait for its turn to run
-    semaphore.acquire()
+        handleSuccess(upload, response)
+        return@withContext
+      } catch (error: Throwable) {
+        if (checkAndHandleCancellation(upload)) throw error
+        if (checkRetry(upload, error)) continue
 
-    try {
-      val response = okhttpUpload(client, upload, file) { progress ->
-        launch { handleProgress(progress, size) }
+        // Log error but continue with next upload
+        Log.e("UploadWorker", "Upload ${upload.id} failed", error)
+        UploadQueue.pop()
+        EventReporter.error(upload.id, error)
+        throw error
       }
-
-      handleProgress(size, size)
-      return@withContext response
-    }
-    // don't catch, propagate error up
-    finally {
-      semaphore.release()
     }
   }
 
-  private suspend fun handleProgress(bytesSentTotal: Long, fileSize: Long) {
-    UploadProgress.set(context, upload.id, bytesSentTotal, fileSize)
-    EventReporter.progress(upload.id, bytesSentTotal, fileSize)
-    setForeground(getForegroundInfo())
-  }
-
-  private fun handleSuccess(response: Response) {
-    UploadProgress.scheduleClearing(context)
+  private fun handleSuccess(upload: Upload, response: UploadResponse) {
+    // Mark as completed on success
+    UploadQueue.complete()
     EventReporter.success(upload.id, response)
   }
 
-  private fun handleError(error: Throwable) {
-    UploadProgress.remove(context, upload.id)
-    UploadProgress.scheduleClearing(context)
-    EventReporter.error(upload.id, error)
-  }
 
   // Check if cancelled by user or new worker with same ID
   // Worker won't rerun, perform teardown
-  private fun checkAndHandleCancellation(): Boolean {
+  private fun checkAndHandleCancellation(upload: Upload): Boolean {
     if (!isStopped) return false
 
-    UploadProgress.remove(context, upload.id)
-    UploadProgress.scheduleClearing(context)
     EventReporter.cancelled(upload.id)
     return true
   }
 
   /** @return whether to retry */
-  private suspend fun checkRetry(error: Throwable): Boolean {
+  private suspend fun checkRetry(upload: Upload, error: Throwable): Boolean {
     var unlimitedRetry = false
 
     // Error was thrown due to unmet network preferences.
@@ -215,7 +179,7 @@ class UploadWorker(private val context: Context, params: WorkerParameters) :
     val notificationConfigs = fetchNotificationConfigs(context)
     val id = notificationConfigs.id
     val channel = notificationConfigs.channel
-    val progress = UploadProgress.total(context)
+    val progress = UploadQueue.progressPercentage()
     val progress2Decimals = "%.2f".format(progress)
     val title = when (connectivity) {
       Connectivity.NoWifi -> notificationConfigs.titleNoWifi
diff --git a/android/src/main/java/com/vydia/RNUploader/UploaderModule.kt b/android/src/main/java/com/vydia/RNUploader/UploaderModule.kt
index 543bea04..1963c697 100644
--- a/android/src/main/java/com/vydia/RNUploader/UploaderModule.kt
+++ b/android/src/main/java/com/vydia/RNUploader/UploaderModule.kt
@@ -4,13 +4,11 @@ import android.util.Log
 import androidx.work.ExistingWorkPolicy
 import androidx.work.OneTimeWorkRequestBuilder
 import androidx.work.WorkManager
-import androidx.work.workDataOf
 import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReactContextBaseJavaModule
 import com.facebook.react.bridge.ReactMethod
 import com.facebook.react.bridge.ReadableMap
-import com.google.gson.Gson
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
@@ -30,9 +28,6 @@ class UploaderModule(private val context: ReactApplicationContext) :
 
   init {
     reactContext = context
-    // workers may be killed abruptly for whatever reasons,
-    // so they might not have had a chance to clear the progress data.
-    UploadProgress.clearIfNeeded(context)
   }
 
 
@@ -62,8 +57,15 @@ class UploaderModule(private val context: ReactApplicationContext) :
   @ReactMethod
   fun startUpload(rawOptions: ReadableMap, promise: Promise) {
     try {
-      val id = startUpload(rawOptions)
-      promise.resolve(id)
+      val upload = Upload.fromRawOptions(rawOptions)
+      UploadQueue.add(upload)
+
+      val request = OneTimeWorkRequestBuilder<UploadWorker>().build()
+      workManager
+        .beginUniqueWork(WORKER_TAG, ExistingWorkPolicy.KEEP, request)
+        .enqueue()
+
+      promise.resolve(upload.id)
     } catch (exc: Throwable) {
       if (exc !is MissingOptionException) {
         exc.printStackTrace()
@@ -73,30 +75,6 @@ class UploaderModule(private val context: ReactApplicationContext) :
     }
   }
 
-  /**
-   * @return whether the upload was started
-   */
-  private fun startUpload(options: ReadableMap): String {
-    val upload = Upload.fromReadableMap(options)
-    val data = Gson().toJson(upload)
-
-    val request = OneTimeWorkRequestBuilder<UploadWorker>()
-      .addTag(WORKER_TAG)
-      .setInputData(workDataOf(UploadWorker.Input.Params.name to data))
-      .build()
-
-    workManager
-      // Using KEEP policy to prevent it from cancelling the work if it's already running.
-      // Otherwise, it will emit "cancelled" and then go on to emit "progress" events,
-      // which is confusing and quite difficult to manage. "cancelled" should be reserved for
-      // when the user explicitly cancels the upload.
-      .beginUniqueWork(upload.id, ExistingWorkPolicy.KEEP, request)
-      .enqueue()
-
-    return upload.id
-  }
-
-
   /*
    * Cancels file upload
    * Accepts upload ID as a first argument, this upload will be cancelled
@@ -105,7 +83,8 @@ class UploaderModule(private val context: ReactApplicationContext) :
   @ReactMethod
   fun cancelUpload(uploadId: String, promise: Promise) {
     try {
-      workManager.cancelUniqueWork(uploadId)
+      // Just remove from queue, worker will handle progress cleanup
+      UploadQueue.remove(uploadId)
       promise.resolve(true)
     } catch (exc: Throwable) {
       exc.printStackTrace()
@@ -114,13 +93,13 @@ class UploaderModule(private val context: ReactApplicationContext) :
     }
   }
 
-
   /*
    * Cancels all file uploads
    */
   @ReactMethod
   fun stopAllUploads(promise: Promise) {
     try {
+      UploadQueue.clear()
       workManager.cancelAllWorkByTag(WORKER_TAG)
       promise.resolve(true)
     } catch (exc: Throwable) {
@@ -130,6 +109,4 @@ class UploaderModule(private val context: ReactApplicationContext) :
     }
   }
 
-
 }
-
diff --git a/example/RNBGUExample/App.tsx b/example/RNBGUExample/App.tsx
index d51c22c8..e5759b95 100644
--- a/example/RNBGUExample/App.tsx
+++ b/example/RNBGUExample/App.tsx
@@ -8,13 +8,13 @@
 
 import React, {useEffect, useState} from 'react';
 import {
+  Button,
   SafeAreaView,
-  StyleSheet,
   ScrollView,
-  View,
-  Text,
   StatusBar,
-  Button,
+  StyleSheet,
+  Text,
+  View,
 } from 'react-native';
 import notifee, {AndroidImportance} from '@notifee/react-native';
 import {Colors} from 'react-native/Libraries/NewAppScreen';
@@ -46,6 +46,7 @@ const App = () => {
 
   useEffect(() => {
     Upload.addListener('progress', null, data => {
+      setUploadId(data.uploadId);
       setProgress(data.progress);
       console.log(`Progress: ${data.progress}%`);
     });
@@ -58,6 +59,14 @@ const App = () => {
   }, []);
 
   useEffect(() => {
+    notifee.requestPermission({alert: true, sound: true});
+
+    notifee.createChannel({
+      id: ANDROID_NOTIFICATION_CHANNEL,
+      name: ANDROID_NOTIFICATION_CHANNEL,
+      importance: AndroidImportance.LOW,
+    });
+
     RNFS.exists('file://' + TEST_FILE)
       .then(exists => {
         if (exists) return;
@@ -69,16 +78,12 @@ const App = () => {
       .then(() => setTestFileDownload('downloaded'));
   }, []);
 
-  const onPressUpload = async () => {
-    await notifee.requestPermission({alert: true, sound: true});
-
-    await notifee.createChannel({
-      id: ANDROID_NOTIFICATION_CHANNEL,
-      name: ANDROID_NOTIFICATION_CHANNEL,
-      importance: AndroidImportance.LOW,
-    });
+  const doUpload = async (id?: string) => {
+    const customUploadId = id ?? Date.now().toString() + Math.random();
+    console.log('---starting', customUploadId);
 
     const uploadOpts: UploadOptions = {
+      customUploadId,
       type: 'raw',
       url: UPLOAD_URL,
       path: TEST_FILE,
@@ -101,6 +106,12 @@ const App = () => {
       });
   };
 
+  const onPressUpload = () => {
+    for (let i = 0; i < 100; i++) {
+      doUpload();
+    }
+  };
+
   return (
     <>
       <StatusBar barStyle="dark-content" />

From 1f3a08e92a85457b4d5e9a9b76d65fb2eedce581 Mon Sep 17 00:00:00 2001
From: thomasvo <thomas.vo@openspace.ai>
Date: Thu, 9 Oct 2025 18:00:22 -0700
Subject: [PATCH 14/28] poc

---
 .../vydia/RNUploader/NotificationConfigs.kt   | 75 ++++++-------------
 .../java/com/vydia/RNUploader/UploadWorker.kt | 49 +++++++-----
 .../com/vydia/RNUploader/UploaderModule.kt    |  8 +-
 .../src/main/proto/notification_configs.proto | 13 ----
 4 files changed, 58 insertions(+), 87 deletions(-)
 delete mode 100644 android/src/main/proto/notification_configs.proto

diff --git a/android/src/main/java/com/vydia/RNUploader/NotificationConfigs.kt b/android/src/main/java/com/vydia/RNUploader/NotificationConfigs.kt
index 869156f9..4d03be12 100644
--- a/android/src/main/java/com/vydia/RNUploader/NotificationConfigs.kt
+++ b/android/src/main/java/com/vydia/RNUploader/NotificationConfigs.kt
@@ -1,60 +1,31 @@
 package com.vydia.RNUploader
 
-import android.content.Context
-import androidx.datastore.core.CorruptionException
-import androidx.datastore.core.DataStore
-import androidx.datastore.core.Serializer
-import androidx.datastore.dataStore
 import com.facebook.react.bridge.ReadableMap
-import com.google.protobuf.InvalidProtocolBufferException
-import kotlinx.coroutines.flow.first
-import java.io.InputStream
-import java.io.OutputStream
 
 
-private object NotificationConfigsSerializer : Serializer<NotificationConfigs> {
-  override val defaultValue: NotificationConfigs = NotificationConfigs.getDefaultInstance()
-
-  override suspend fun readFrom(input: InputStream): NotificationConfigs {
-    try {
-      return NotificationConfigs.parseFrom(input)
-    } catch (exception: InvalidProtocolBufferException) {
-      throw CorruptionException("Cannot read proto.", exception)
-    }
+object NotificationConfigs {
+  var id: Int = 0
+    private set
+  var title: String = "Uploading files"
+    private set
+  var titleNoInternet: String = "Waiting for internet connection"
+    private set
+  var titleNoWifi: String = "Waiting for WiFi connection"
+    private set
+  var channel: String = "File Uploads"
+    private set
+
+  fun update(opts: ReadableMap) {
+    id = opts.getString("notificationId")?.hashCode()
+      ?: throw MissingOptionException("notificationId")
+    title = opts.getString("notificationTitle")
+      ?: throw MissingOptionException("notificationTitle")
+    titleNoInternet = opts.getString("notificationTitleNoInternet")
+      ?: throw MissingOptionException("notificationTitleNoInternet")
+    titleNoWifi = opts.getString("notificationTitleNoWifi")
+      ?: throw MissingOptionException("notificationTitleNoWifi")
+    channel = opts.getString("notificationChannel")
+      ?: throw MissingOptionException("notificationChannel")
   }
-
-  override suspend fun writeTo(t: NotificationConfigs, output: OutputStream) = t.writeTo(output)
 }
 
-// This is the recommended way to create a DataStore instance
-// https://developer.android.com/topic/libraries/architecture/datastore#preferences-create
-private val Context.vydiaNotificationConfigs: DataStore<NotificationConfigs> by dataStore(
-  fileName = "settings.pb",
-  serializer = NotificationConfigsSerializer
-)
-
-suspend fun fetchNotificationConfigs(context: Context) =
-  context.vydiaNotificationConfigs.data.first()
-
-suspend fun updateNotificationConfigs(opts: ReadableMap, context: Context) {
-  val notificationId = opts.getString("notificationId")
-    ?: throw MissingOptionException("notificationId")
-  val notificationTitle = opts.getString("notificationTitle")
-    ?: throw MissingOptionException("notificationTitle")
-  val notificationTitleNoInternet = opts.getString("notificationTitleNoInternet")
-    ?: throw MissingOptionException("notificationTitleNoInternet")
-  val notificationTitleNoWifi = opts.getString("notificationTitleNoWifi")
-    ?: throw MissingOptionException("notificationTitleNoWifi")
-  val notificationChannel = opts.getString("notificationChannel")
-    ?: throw MissingOptionException("notificationChannel")
-
-  context.vydiaNotificationConfigs.updateData { currentSettings ->
-    currentSettings.toBuilder().apply {
-      this.id = notificationId.hashCode()
-      this.title = notificationTitle
-      this.titleNoInternet = notificationTitleNoInternet
-      this.titleNoWifi = notificationTitleNoWifi
-      this.channel = notificationChannel
-    }.build()
-  }
-}
diff --git a/android/src/main/java/com/vydia/RNUploader/UploadWorker.kt b/android/src/main/java/com/vydia/RNUploader/UploadWorker.kt
index 0bb2d008..23e772f2 100644
--- a/android/src/main/java/com/vydia/RNUploader/UploadWorker.kt
+++ b/android/src/main/java/com/vydia/RNUploader/UploadWorker.kt
@@ -1,6 +1,7 @@
 package com.vydia.RNUploader
 
 import android.app.Notification
+import android.app.NotificationManager
 import android.app.PendingIntent
 import android.content.Context
 import android.content.Intent
@@ -17,7 +18,6 @@ import androidx.work.ForegroundInfo
 import androidx.work.WorkerParameters
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.delay
-import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
 import okhttp3.OkHttpClient
 import java.io.File
@@ -46,17 +46,20 @@ private enum class Connectivity { NoWifi, NoInternet, Ok }
 class UploadWorker(private val context: Context, params: WorkerParameters) :
   CoroutineWorker(context, params) {
 
-
   private lateinit var upload: Upload
   private var retries = 0
   private var connectivity = Connectivity.Ok
+  private var foreground = false
+
+  val notificationManager =
+    context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
 
   override suspend fun doWork(): Result = withContext(Dispatchers.IO) {
     try {
       setForeground(getForegroundInfo())
+      foreground = true
     } catch (error: Throwable) {
-      UploadQueue.clear()
-      throw error
+      // Should not block the worker if setting foreground fails
     }
 
     try {
@@ -100,8 +103,7 @@ class UploadWorker(private val context: Context, params: WorkerParameters) :
         val response = okhttpUpload(client, upload, file) { bytesSentTotal ->
           UploadQueue.progress(upload.id, bytesSentTotal)
           EventReporter.progress(upload.id)
-
-          launch { setForeground(getForegroundInfo()) }
+          updateNotification()
         }
 
         handleSuccess(upload, response)
@@ -166,25 +168,27 @@ class UploadWorker(private val context: Context, params: WorkerParameters) :
   }
 
   // Checks connection and alerts connection issues
-  private suspend fun validateAndReportConnectivity(): Boolean {
+  private fun validateAndReportConnectivity(): Boolean {
     this.connectivity = validateConnectivity(context, upload.wifiOnly)
-    // alert connectivity mode
-    setForeground(getForegroundInfo())
+    // Update notification instead of calling setForeground
+    updateNotification()
     return this.connectivity == Connectivity.Ok
   }
 
-  // builds the notification required to enable Foreground mode
-  override suspend fun getForegroundInfo(): ForegroundInfo {
-    // All workers share the same notification that shows the total progress
-    val notificationConfigs = fetchNotificationConfigs(context)
-    val id = notificationConfigs.id
-    val channel = notificationConfigs.channel
+  private fun updateNotification() {
+    if (!foreground) return
+
+    val (id, notification) = buildNotification()
+    notificationManager.notify(id, notification)
+  }
+
+  private fun buildNotification(): Pair<Int, Notification> {
     val progress = UploadQueue.progressPercentage()
     val progress2Decimals = "%.2f".format(progress)
     val title = when (connectivity) {
-      Connectivity.NoWifi -> notificationConfigs.titleNoWifi
-      Connectivity.NoInternet -> notificationConfigs.titleNoInternet
-      Connectivity.Ok -> notificationConfigs.title
+      Connectivity.NoWifi -> NotificationConfigs.titleNoWifi
+      Connectivity.NoInternet -> NotificationConfigs.titleNoInternet
+      Connectivity.Ok -> NotificationConfigs.title
     }
 
     // Custom layout for progress notification.
@@ -195,7 +199,7 @@ class UploadWorker(private val context: Context, params: WorkerParameters) :
     content.setTextViewText(R.id.notification_progress, "${progress2Decimals}%")
     content.setProgressBar(R.id.notification_progress_bar, 100, progress.toInt(), false)
 
-    val notification = NotificationCompat.Builder(context, channel).run {
+    val notification = NotificationCompat.Builder(context, NotificationConfigs.channel).run {
       // Starting Android 12, the notification shows up with a confusing delay of 10s.
       // This fixes that delay.
       if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S)
@@ -214,6 +218,13 @@ class UploadWorker(private val context: Context, params: WorkerParameters) :
       build()
     }
 
+    return Pair(NotificationConfigs.id, notification)
+  }
+
+  // builds the notification required to enable Foreground mode
+  override suspend fun getForegroundInfo(): ForegroundInfo {
+    val (id, notification) = buildNotification()
+
     // Starting Android 14, FOREGROUND_SERVICE_TYPE_DATA_SYNC is mandatory, otherwise app will crash
     return if (Build.VERSION.SDK_INT > Build.VERSION_CODES.TIRAMISU)
       ForegroundInfo(id, notification, ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC)
diff --git a/android/src/main/java/com/vydia/RNUploader/UploaderModule.kt b/android/src/main/java/com/vydia/RNUploader/UploaderModule.kt
index 1963c697..6b1d036f 100644
--- a/android/src/main/java/com/vydia/RNUploader/UploaderModule.kt
+++ b/android/src/main/java/com/vydia/RNUploader/UploaderModule.kt
@@ -14,7 +14,7 @@ import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
 
 
-class UploaderModule(private val context: ReactApplicationContext) :
+class UploaderModule(context: ReactApplicationContext) :
   ReactContextBaseJavaModule(context) {
 
   companion object {
@@ -38,7 +38,7 @@ class UploaderModule(private val context: ReactApplicationContext) :
   fun initialize(opts: ReadableMap, promise: Promise) =
     CoroutineScope(Dispatchers.IO).launch {
       try {
-        updateNotificationConfigs(opts, context)
+        NotificationConfigs.update(opts)
         promise.resolve(true)
       } catch (exc: Throwable) {
         if (exc !is MissingOptionException) {
@@ -60,7 +60,9 @@ class UploaderModule(private val context: ReactApplicationContext) :
       val upload = Upload.fromRawOptions(rawOptions)
       UploadQueue.add(upload)
 
-      val request = OneTimeWorkRequestBuilder<UploadWorker>().build()
+      val request = OneTimeWorkRequestBuilder<UploadWorker>()
+        .build()
+
       workManager
         .beginUniqueWork(WORKER_TAG, ExistingWorkPolicy.KEEP, request)
         .enqueue()
diff --git a/android/src/main/proto/notification_configs.proto b/android/src/main/proto/notification_configs.proto
deleted file mode 100644
index 30ace5d0..00000000
--- a/android/src/main/proto/notification_configs.proto
+++ /dev/null
@@ -1,13 +0,0 @@
-syntax = "proto3";
-
-option java_package = "com.vydia.RNUploader";
-option java_multiple_files = true;
-
-// Keep field numbers STABLE forever; add new fields with new tags.
-message NotificationConfigs {
-  int32 id = 1;
-  string title = 2;
-  string title_no_internet = 3;
-  string title_no_wifi = 4;
-  string channel = 5;
-}

From 40c397a91379c41a03e64734d3928560f63df8d0 Mon Sep 17 00:00:00 2001
From: thomasvo <thomas.vo@openspace.ai>
Date: Thu, 9 Oct 2025 18:04:48 -0700
Subject: [PATCH 15/28] remove

---
 .../com/vydia/RNUploader/UploadProgress.kt    | 64 -------------------
 1 file changed, 64 deletions(-)
 delete mode 100644 android/src/main/java/com/vydia/RNUploader/UploadProgress.kt

diff --git a/android/src/main/java/com/vydia/RNUploader/UploadProgress.kt b/android/src/main/java/com/vydia/RNUploader/UploadProgress.kt
deleted file mode 100644
index ee1bd78a..00000000
--- a/android/src/main/java/com/vydia/RNUploader/UploadProgress.kt
+++ /dev/null
@@ -1,64 +0,0 @@
-package com.vydia.RNUploader
-
-import android.content.Context
-import android.os.Handler
-import android.os.Looper
-import androidx.work.WorkManager
-import com.vydia.RNUploader.UploaderModule.Companion.WORKER_TAG
-
-// Stores and aggregates total progress from all workers
-class UploadProgress {
-
-  companion object {
-    private fun storage(context: Context) =
-      context.getSharedPreferences("RNFileUpload-Progress", Context.MODE_PRIVATE)
-
-    @Synchronized
-    fun set(context: Context, uploadId: String, bytesUploaded: Long, fileSize: Long) =
-      storage(context).edit()
-        .putLong("$uploadId-uploaded", bytesUploaded)
-        .putLong("$uploadId-size", fileSize)
-        .apply()
-
-    @Synchronized
-    fun remove(context: Context, uploadId: String) =
-      storage(context).edit()
-        .remove("$uploadId-uploaded")
-        .remove("$uploadId-size")
-        .apply()
-
-    @Synchronized
-    fun total(context: Context): Double {
-      val storage = storage(context)
-
-      val totalBytesUploaded = storage.all.keys
-        .filter { it.endsWith("-uploaded") }
-        .sumOf { storage.getLong(it, 0L) }
-
-      val totalFileSize = storage.all.keys
-        .filter { it.endsWith("-size") }
-        .sumOf { storage.getLong(it, 0L) }
-
-      if (totalFileSize == 0L) return 0.0
-      return (totalBytesUploaded.toDouble() * 100 / totalFileSize)
-    }
-
-    private val handler = Handler(Looper.getMainLooper())
-
-    // Attempt to clear in 2 seconds. This is the simplest way to let the
-    // last worker reset the overall progress.
-    // Clearing progress ensures the notification starts at 0% next time.
-    fun scheduleClearing(context: Context) =
-      handler.postDelayed({ clearIfNeeded(context) }, 2000)
-
-    @Synchronized
-    fun clearIfNeeded(context: Context) {
-      val workManager = WorkManager.getInstance(context)
-      val works = workManager.getWorkInfosByTag(WORKER_TAG).get()
-      if (works.any { !it.state.isFinished }) return
-
-      val storage = storage(context)
-      storage.edit().clear().apply()
-    }
-  }
-}
\ No newline at end of file

From a5f511b166743f5ea4f46e3a90f5ac4e38b8dd3b Mon Sep 17 00:00:00 2001
From: thomasvo <thomas.vo@openspace.ai>
Date: Thu, 9 Oct 2025 18:07:16 -0700
Subject: [PATCH 16/28] doc

---
 .../src/main/java/com/vydia/RNUploader/UploadWorker.kt    | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/android/src/main/java/com/vydia/RNUploader/UploadWorker.kt b/android/src/main/java/com/vydia/RNUploader/UploadWorker.kt
index 23e772f2..a1a3e449 100644
--- a/android/src/main/java/com/vydia/RNUploader/UploadWorker.kt
+++ b/android/src/main/java/com/vydia/RNUploader/UploadWorker.kt
@@ -56,6 +56,10 @@ class UploadWorker(private val context: Context, params: WorkerParameters) :
 
   override suspend fun doWork(): Result = withContext(Dispatchers.IO) {
     try {
+      // `setForeground` is recommended for long-running workers.
+      // Foreground mode helps prioritize the worker, reducing the risk
+      // of it being killed during low memory or Doze/App Standby situations.
+      // ⚠️ This should be called in the foreground
       setForeground(getForegroundInfo())
       foreground = true
     } catch (error: Throwable) {
@@ -78,6 +82,10 @@ class UploadWorker(private val context: Context, params: WorkerParameters) :
     connectivity = Connectivity.Ok
 
     // Complex work, errors thrown below here trigger retry.
+    // We don't let WorkManager manage retries and network constraints as it's very buggy.
+    // i.e. we'd occasionally get BackgroundServiceStartNotAllowedException,
+    // or ForegroundServiceStartNotAllowedException, or "isStopped" gets set to "true"
+    // for no reason
     var isRetried = false
     while (true) {
       try {

From a6b6fb442b77154bcc41784429c6512024ec197d Mon Sep 17 00:00:00 2001
From: thomasvo <thomas.vo@openspace.ai>
Date: Thu, 9 Oct 2025 18:10:29 -0700
Subject: [PATCH 17/28] revert

---
 android/build.gradle | 24 ------------------------
 1 file changed, 24 deletions(-)

diff --git a/android/build.gradle b/android/build.gradle
index c67378a7..ff1777e0 100755
--- a/android/build.gradle
+++ b/android/build.gradle
@@ -15,13 +15,11 @@ buildscript {
     dependencies {
         classpath 'com.android.tools.build:gradle:3.5.4'
         classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlinVersion"
-        classpath "com.google.protobuf:protobuf-gradle-plugin:0.9.5"
     }
 }
 
 apply plugin: 'com.android.library'
 apply plugin: 'kotlin-android'
-apply plugin: 'com.google.protobuf'
 
 def DEFAULT_COMPILE_SDK_VERSION = 28
 def DEFAULT_BUILD_TOOLS_VERSION = "28.0.3"
@@ -64,7 +62,6 @@ android {
 }
 
 repositories {
-    google()
     mavenCentral()
 }
 
@@ -72,7 +69,6 @@ def _ext = ext
 
 def _kotlinVersion = _ext.has('detoxKotlinVersion') ? _ext.detoxKotlinVersion : '1.3.10'
 def _kotlinStdlib = _ext.has('detoxKotlinStdlib') ? _ext.detoxKotlinStdlib : 'kotlin-stdlib-jdk8'
-def _protobufVersion = "4.32.1"
 
 dependencies {
     implementation "androidx.core:core-ktx:1.7.0"
@@ -83,29 +79,9 @@ dependencies {
 
     implementation("com.squareup.okhttp3:okhttp:4.10.0")
 
-    implementation 'com.google.code.gson:gson:2.8.9'
-
     implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-core:1.6.4'
 
     implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.6.4'
 
     implementation "androidx.work:work-runtime-ktx:2.8.1"
-
-    implementation "androidx.datastore:datastore:1.1.7"
-
-    implementation "com.google.protobuf:protobuf-kotlin-lite:$_protobufVersion"
-}
-
-protobuf {
-    protoc { artifact = "com.google.protobuf:protoc:$_protobufVersion" }
-
-    generateProtoTasks {
-        all().each { task ->
-            task.plugins {
-                java {
-                    option 'lite'
-                }
-            }
-        }
-    }
 }
\ No newline at end of file

From aab5d264f12e0ce9a7ed30d8f71a68dbd712f3e9 Mon Sep 17 00:00:00 2001
From: thomasvo <thomas.vo@openspace.ai>
Date: Thu, 9 Oct 2025 18:12:23 -0700
Subject: [PATCH 18/28] fix

---
 android/src/main/java/com/vydia/RNUploader/UploadWorker.kt | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/android/src/main/java/com/vydia/RNUploader/UploadWorker.kt b/android/src/main/java/com/vydia/RNUploader/UploadWorker.kt
index a1a3e449..e8ee8ac1 100644
--- a/android/src/main/java/com/vydia/RNUploader/UploadWorker.kt
+++ b/android/src/main/java/com/vydia/RNUploader/UploadWorker.kt
@@ -10,7 +10,6 @@ import android.net.ConnectivityManager
 import android.net.NetworkCapabilities.NET_CAPABILITY_VALIDATED
 import android.net.NetworkCapabilities.TRANSPORT_WIFI
 import android.os.Build
-import android.util.Log
 import android.widget.RemoteViews
 import androidx.core.app.NotificationCompat
 import androidx.work.CoroutineWorker
@@ -117,14 +116,14 @@ class UploadWorker(private val context: Context, params: WorkerParameters) :
         handleSuccess(upload, response)
         return@withContext
       } catch (error: Throwable) {
+        // TODO not necessary anymore?
         if (checkAndHandleCancellation(upload)) throw error
         if (checkRetry(upload, error)) continue
 
         // Log error but continue with next upload
-        Log.e("UploadWorker", "Upload ${upload.id} failed", error)
         UploadQueue.pop()
         EventReporter.error(upload.id, error)
-        throw error
+        return@withContext
       }
     }
   }

From 5d8ff5f18cab7d0cf25b111cf03aaeaa13ba9ee1 Mon Sep 17 00:00:00 2001
From: thomasvo <thomas.vo@openspace.ai>
Date: Thu, 9 Oct 2025 18:15:06 -0700
Subject: [PATCH 19/28] fix

---
 android/src/main/java/com/vydia/RNUploader/UploadWorker.kt | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/android/src/main/java/com/vydia/RNUploader/UploadWorker.kt b/android/src/main/java/com/vydia/RNUploader/UploadWorker.kt
index e8ee8ac1..02a1c39f 100644
--- a/android/src/main/java/com/vydia/RNUploader/UploadWorker.kt
+++ b/android/src/main/java/com/vydia/RNUploader/UploadWorker.kt
@@ -50,6 +50,8 @@ class UploadWorker(private val context: Context, params: WorkerParameters) :
   private var connectivity = Connectivity.Ok
   private var foreground = false
 
+  private var lastNotificationUpdate = 0L
+
   val notificationManager =
     context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
 
@@ -185,6 +187,9 @@ class UploadWorker(private val context: Context, params: WorkerParameters) :
   private fun updateNotification() {
     if (!foreground) return
 
+    val timeSinceLastUpdate = System.currentTimeMillis() - lastNotificationUpdate
+    if (timeSinceLastUpdate < 1000L) return
+
     val (id, notification) = buildNotification()
     notificationManager.notify(id, notification)
   }

From 976384e9e33ca8e8cd08cb254790d5846828a5cd Mon Sep 17 00:00:00 2001
From: thomasvo <thomas.vo@openspace.ai>
Date: Fri, 10 Oct 2025 16:42:49 -0700
Subject: [PATCH 20/28] simpler build.gradle

---
 android/build.gradle | 58 +++++++++++++-------------------------------
 1 file changed, 17 insertions(+), 41 deletions(-)

diff --git a/android/build.gradle b/android/build.gradle
index ff1777e0..7674d13e 100755
--- a/android/build.gradle
+++ b/android/build.gradle
@@ -1,19 +1,17 @@
 buildscript {
     ext {
-        kotlinVersion = '1.6.20'
+        kotlinVersion = '2.2.20'
         buildToolsVersion = '29.0.2'
-        compileSdkVersion = 31 // this helps us use the latest Worker version
-        targetSdkVersion = 29
-        minSdkVersion = 18
+        minSdkVersion = 29
+        compileSdkVersion = 35
+        targetSdkVersion = 35
     }
-    ext.detoxKotlinVersion = ext.kotlinVersion
-
     repositories {
         mavenCentral()
         google()
     }
     dependencies {
-        classpath 'com.android.tools.build:gradle:3.5.4'
+        classpath 'com.android.tools.build:gradle:8.13.0'
         classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlinVersion"
     }
 }
@@ -21,28 +19,17 @@ buildscript {
 apply plugin: 'com.android.library'
 apply plugin: 'kotlin-android'
 
-def DEFAULT_COMPILE_SDK_VERSION = 28
-def DEFAULT_BUILD_TOOLS_VERSION = "28.0.3"
-def DEFAULT_TARGET_SDK_VERSION = 28
-
-def safeExtGet(prop, fallback) {
-    rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
+def safeExtGet(prop) {
+    rootProject.ext.has(prop) ? rootProject.ext.get(prop) : ext.get(prop)
 }
 
 android {
-    buildFeatures {
-        /*
-            This is a replacement for the deprecated 'kotlin-android-extensions' library. More
-            information can be found here: https://developer.android.com/topic/libraries/view-binding/migration
-        */
-        viewBinding = true
-    }
-    compileSdkVersion safeExtGet('compileSdkVersion', DEFAULT_COMPILE_SDK_VERSION)
-    buildToolsVersion safeExtGet('buildToolsVersion', DEFAULT_BUILD_TOOLS_VERSION)
+    compileSdkVersion safeExtGet('compileSdkVersion')
+    buildToolsVersion safeExtGet('buildToolsVersion')
 
     defaultConfig {
-        minSdkVersion 24
-        targetSdkVersion safeExtGet('targetSdkVersion', DEFAULT_TARGET_SDK_VERSION)
+        minSdkVersion safeExtGet('minSdkVersion')
+        targetSdkVersion safeExtGet('targetSdkVersion')
         versionCode 1
         versionName "1.0"
         ndk {
@@ -65,23 +52,12 @@ repositories {
     mavenCentral()
 }
 
-def _ext = ext
-
-def _kotlinVersion = _ext.has('detoxKotlinVersion') ? _ext.detoxKotlinVersion : '1.3.10'
-def _kotlinStdlib = _ext.has('detoxKotlinStdlib') ? _ext.detoxKotlinStdlib : 'kotlin-stdlib-jdk8'
-
 dependencies {
-    implementation "androidx.core:core-ktx:1.7.0"
-
+    implementation "androidx.core:core-ktx:1.17.0"
     implementation 'com.facebook.react:react-native:+'
-
-    implementation "org.jetbrains.kotlin:$_kotlinStdlib:$_kotlinVersion"
-
-    implementation("com.squareup.okhttp3:okhttp:4.10.0")
-
-    implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-core:1.6.4'
-
-    implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.6.4'
-
-    implementation "androidx.work:work-runtime-ktx:2.8.1"
+    implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8:$kotlinVersion"
+    implementation("com.squareup.okhttp3:okhttp:5.2.1")
+    implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-core:1.10.2'
+    implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.10.2'
+    implementation "androidx.work:work-runtime-ktx:2.10.5"
 }
\ No newline at end of file

From f206b78161e9a998fcbcdf9f63190cd5b0ab57d1 Mon Sep 17 00:00:00 2001
From: thomasvo <thomas.vo@openspace.ai>
Date: Fri, 10 Oct 2025 18:08:42 -0700
Subject: [PATCH 21/28] thread safe

---
 .../java/com/vydia/RNUploader/UploadQueue.kt  | 22 ++++++++++++++++---
 1 file changed, 19 insertions(+), 3 deletions(-)

diff --git a/android/src/main/java/com/vydia/RNUploader/UploadQueue.kt b/android/src/main/java/com/vydia/RNUploader/UploadQueue.kt
index 6920d893..c6ae240b 100644
--- a/android/src/main/java/com/vydia/RNUploader/UploadQueue.kt
+++ b/android/src/main/java/com/vydia/RNUploader/UploadQueue.kt
@@ -5,12 +5,17 @@ import java.io.FileNotFoundException
 
 object UploadQueue {
   private val queue = ArrayDeque<Upload>()
+
+  /**
+   * Keeps track of the total bytes of completed uploads to report overall progress correctly.
+   */
   private var completedBytes = 0L
 
   /**
    * Returns the overall progress percentage of all uploads in the queue.
    * 0 - 100
    */
+  @Synchronized
   fun progressPercentage(): Float {
     if (queue.isEmpty()) return 0f
 
@@ -21,6 +26,7 @@ object UploadQueue {
     return uploadedBytes.toFloat() / totalBytes.toFloat() * 100
   }
 
+  @Synchronized
   fun add(upload: Upload) {
     if (queue.any { it.id == upload.id }) return
 
@@ -33,12 +39,14 @@ object UploadQueue {
     queue.add(upload)
   }
 
+  @Synchronized
   fun progress(uploadId: String, bytesUploaded: Long) {
     queue.find { it.id == uploadId }?.bytesUploaded = bytesUploaded
   }
 
+  @Synchronized
   fun complete() {
-    val upload = pop()
+    val upload = queue.removeFirst()
 
     upload.bytesUploaded = upload.size
     upload.completed = true
@@ -46,13 +54,21 @@ object UploadQueue {
     completedBytes += upload.size
   }
 
+  @Synchronized
   fun pop() = queue.removeFirst()
 
-  fun remove(uploadId: String) = queue.removeIf { it.id === uploadId }
+  @Synchronized
+  fun cancel(uploadId: String) = queue.removeIf { it.id == uploadId }
 
+  @Synchronized
   fun current() = queue.first()
 
-  fun clear() = queue.clear()
+  @Synchronized
+  fun clear() {
+    queue.clear()
+    completedBytes = 0L
+  }
 
+  @Synchronized
   fun isEmpty() = queue.isEmpty()
 }
\ No newline at end of file

From bb261e50cdef6b4c620e71ade21e11ff8c7a28ad Mon Sep 17 00:00:00 2001
From: thomasvo <thomas.vo@openspace.ai>
Date: Fri, 10 Oct 2025 19:15:07 -0700
Subject: [PATCH 22/28] getting there

---
 .../java/com/vydia/RNUploader/UploadQueue.kt  |  12 +
 .../java/com/vydia/RNUploader/UploadUtils.kt  | 115 +++++++-
 .../java/com/vydia/RNUploader/UploadWorker.kt | 269 ++++++++----------
 .../com/vydia/RNUploader/UploaderModule.kt    |   9 +-
 4 files changed, 238 insertions(+), 167 deletions(-)

diff --git a/android/src/main/java/com/vydia/RNUploader/UploadQueue.kt b/android/src/main/java/com/vydia/RNUploader/UploadQueue.kt
index c6ae240b..98e070d9 100644
--- a/android/src/main/java/com/vydia/RNUploader/UploadQueue.kt
+++ b/android/src/main/java/com/vydia/RNUploader/UploadQueue.kt
@@ -60,6 +60,18 @@ object UploadQueue {
   @Synchronized
   fun cancel(uploadId: String) = queue.removeIf { it.id == uploadId }
 
+
+  @Synchronized
+  fun selectNext(wifiOnly: Boolean): Boolean {
+    val upload = queue.find { it.wifiOnly == wifiOnly } ?: return false
+    queue.remove(upload)
+    queue.addFirst(upload)
+    return true
+  }
+
+  @Synchronized
+  fun allWifiOnly() = !queue.isEmpty() && queue.all { it.wifiOnly }
+
   @Synchronized
   fun current() = queue.first()
 
diff --git a/android/src/main/java/com/vydia/RNUploader/UploadUtils.kt b/android/src/main/java/com/vydia/RNUploader/UploadUtils.kt
index c89e59d3..cc7781dd 100644
--- a/android/src/main/java/com/vydia/RNUploader/UploadUtils.kt
+++ b/android/src/main/java/com/vydia/RNUploader/UploadUtils.kt
@@ -1,9 +1,25 @@
 package com.vydia.RNUploader
 
+import android.app.Notification
+import android.app.PendingIntent
+import android.content.Context
+import android.content.Intent
+import android.os.Build
+import android.widget.RemoteViews
+import androidx.core.app.NotificationCompat
+import kotlinx.coroutines.CancellationException
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
 import kotlinx.coroutines.suspendCancellableCoroutine
-import okhttp3.*
+import okhttp3.Call
+import okhttp3.Callback
 import okhttp3.Headers.Companion.toHeaders
+import okhttp3.OkHttpClient
+import okhttp3.Request
+import okhttp3.RequestBody
 import okhttp3.RequestBody.Companion.asRequestBody
+import okhttp3.Response
 import okio.Buffer
 import okio.BufferedSink
 import okio.ForwardingSink
@@ -27,11 +43,13 @@ data class UploadResponse(
 suspend fun okhttpUpload(
   client: OkHttpClient,
   upload: Upload,
-  file: File,
-  onProgress: (Long) -> Unit
+  onProgress: (Long) -> Unit,
+  isCancelled: () -> Boolean
 ): UploadResponse =
   suspendCancellableCoroutine { continuation ->
-    val requestBody = file.asRequestBody()
+    val requestBody = File(upload.path).asRequestBody()
+
+    // Throttle progress reports
     var lastProgressReport = 0L
     fun throttled(): Boolean {
       val now = System.currentTimeMillis()
@@ -40,6 +58,7 @@ suspend fun okhttpUpload(
       return false
     }
 
+    // Build the request
     val request = Request.Builder()
       .url(upload.url)
       .headers(upload.headers.toHeaders())
@@ -48,20 +67,46 @@ suspend fun okhttpUpload(
       })
       .build()
 
+    // Create the call
     val call = client.newCall(request)
-    continuation.invokeOnCancellation { call.cancel() }
+
+    // Start a polling coroutine to check for cancellation
+    val cancellationCheck = CoroutineScope(continuation.context).launch {
+      while (!call.isCanceled()) {
+        if (isCancelled()) {
+          call.cancel()
+          continuation.resumeWithException(CancellationException("Upload cancelled externally"))
+          break
+        }
+        delay(100) // Poll every 100ms
+      }
+    }
+
+    // cancel everything if the coroutine is cancelled
+    continuation.invokeOnCancellation {
+      call.cancel()
+      cancellationCheck.cancel()
+    }
+
+    // enqueue the call and add the callbacks
     call.enqueue(object : Callback {
-      override fun onFailure(call: Call, e: IOException) =
+      override fun onFailure(call: Call, e: IOException) {
+        cancellationCheck.cancel()
+        if (isCancelled()) return
         continuation.resumeWithException(e)
+      }
 
       override fun onResponse(call: Call, response: Response) {
+        cancellationCheck.cancel()
         response.use { // Automatically closes the response
+          if (isCancelled()) return
+
           val uploadResponse = UploadResponse(
             statusCode = response.code,
             statusMessage = response.message,
             headers = response.headers.toMap(),
-            body = response.body?.string().let {
-              if (it.isNullOrBlank()) response.message else it
+            body = response.body.string().let {
+              it.ifBlank { response.message }
             }
           )
           continuation.resumeWith(Result.success(uploadResponse))
@@ -96,4 +141,56 @@ private fun withProgressListener(
 }
 
 class MissingOptionException(optionName: String) :
-  IllegalArgumentException("Missing '$optionName'")
\ No newline at end of file
+  IllegalArgumentException("Missing '$optionName'")
+
+
+data class Connectivity(val wifi: Boolean, val connected: Boolean)
+
+enum class NotificationConnectivity {
+  NoWifi, NoInternet, Ok
+}
+
+fun buildNotification(context: Context, connectivity: NotificationConnectivity): Pair<Int, Notification> {
+  val progress = UploadQueue.progressPercentage()
+  val progress2Decimals = "%.2f".format(progress)
+  val title = when (connectivity) {
+    NotificationConnectivity.NoWifi -> NotificationConfigs.titleNoWifi
+    NotificationConnectivity.NoInternet -> NotificationConfigs.titleNoInternet
+    NotificationConnectivity.Ok -> NotificationConfigs.title
+  }
+
+  // Custom layout for progress notification.
+  // The default hides the % text. This one shows it on the right,
+  // like most examples in various docs.
+  val content = RemoteViews(context.packageName, R.layout.notification)
+  content.setTextViewText(R.id.notification_title, title)
+  content.setTextViewText(R.id.notification_progress, "${progress2Decimals}%")
+  content.setProgressBar(R.id.notification_progress_bar, 100, progress.toInt(), false)
+
+  val notification = NotificationCompat.Builder(context, NotificationConfigs.channel).run {
+    // Starting Android 12, the notification shows up with a confusing delay of 10s.
+    // This fixes that delay.
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S)
+      foregroundServiceBehavior = Notification.FOREGROUND_SERVICE_IMMEDIATE
+
+    // Required by android. Here we use the system's default upload icon
+    setSmallIcon(android.R.drawable.stat_sys_upload)
+    // These prevent the notification from being force-dismissed or dismissed when pressed
+    setOngoing(true)
+    setAutoCancel(false)
+    // These help show the same custom content when the notification collapses and expands
+    setCustomContentView(content)
+    setCustomBigContentView(content)
+    // opens the app when the notification is pressed
+    setContentIntent(openAppIntent(context))
+    build()
+  }
+
+  return Pair(NotificationConfigs.id, notification)
+}
+
+private fun openAppIntent(context: Context): PendingIntent? {
+  val intent = Intent(context, NotificationReceiver::class.java)
+  val flags = PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
+  return PendingIntent.getBroadcast(context, "RNFileUpload-notification".hashCode(), intent, flags)
+}
diff --git a/android/src/main/java/com/vydia/RNUploader/UploadWorker.kt b/android/src/main/java/com/vydia/RNUploader/UploadWorker.kt
index 02a1c39f..953e925b 100644
--- a/android/src/main/java/com/vydia/RNUploader/UploadWorker.kt
+++ b/android/src/main/java/com/vydia/RNUploader/UploadWorker.kt
@@ -1,22 +1,19 @@
 package com.vydia.RNUploader
 
-import android.app.Notification
 import android.app.NotificationManager
-import android.app.PendingIntent
 import android.content.Context
-import android.content.Intent
 import android.content.pm.ServiceInfo
 import android.net.ConnectivityManager
 import android.net.NetworkCapabilities.NET_CAPABILITY_VALIDATED
 import android.net.NetworkCapabilities.TRANSPORT_WIFI
 import android.os.Build
-import android.widget.RemoteViews
-import androidx.core.app.NotificationCompat
 import androidx.work.CoroutineWorker
 import androidx.work.ForegroundInfo
 import androidx.work.WorkerParameters
 import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
 import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
 import okhttp3.OkHttpClient
 import java.io.File
@@ -40,21 +37,10 @@ private val client = OkHttpClient.Builder()
   .callTimeout(REQUEST_TIMEOUT, REQUEST_TIMEOUT_UNIT)
   .build()
 
-private enum class Connectivity { NoWifi, NoInternet, Ok }
-
 class UploadWorker(private val context: Context, params: WorkerParameters) :
   CoroutineWorker(context, params) {
-
-  private lateinit var upload: Upload
-  private var retries = 0
-  private var connectivity = Connectivity.Ok
   private var foreground = false
 
-  private var lastNotificationUpdate = 0L
-
-  val notificationManager =
-    context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
-
   override suspend fun doWork(): Result = withContext(Dispatchers.IO) {
     try {
       // `setForeground` is recommended for long-running workers.
@@ -65,29 +51,48 @@ class UploadWorker(private val context: Context, params: WorkerParameters) :
       foreground = true
     } catch (error: Throwable) {
       // Should not block the worker if setting foreground fails
+      // TODO report errors
+    }
+
+    // Update notification periodically
+    var notificationJob: Job? = null
+    try {
+      notificationJob = launch {
+        while (true) {
+          try {
+            delay(1000L)
+            updateNotification()
+          } catch (error: Throwable) {
+            if (isStopped) return@launch
+            // TODO report errors
+          }
+        }
+      }
+    } catch (_: Throwable) {
+      // Should not block the worker if notification job setup fails
+      // TODO report errors
     }
 
     try {
       // Keep processing uploads until no more incomplete uploads
-      while (!UploadQueue.isEmpty()) processUpload(UploadQueue.current())
+      while (!UploadQueue.isEmpty()) processUpload()
 
       return@withContext Result.success()
     } finally {
+      notificationJob?.cancel() // Cancel the notification updates when work is done
       UploadQueue.clear()
     }
   }
 
-  private suspend fun processUpload(upload: Upload) = withContext(Dispatchers.IO) {
-    this@UploadWorker.upload = upload
-    retries = 0
-    connectivity = Connectivity.Ok
-
+  private suspend fun processUpload() {
+    val upload = UploadQueue.current()
     // Complex work, errors thrown below here trigger retry.
     // We don't let WorkManager manage retries and network constraints as it's very buggy.
     // i.e. we'd occasionally get BackgroundServiceStartNotAllowedException,
     // or ForegroundServiceStartNotAllowedException, or "isStopped" gets set to "true"
     // for no reason
     var isRetried = false
+    var retriesLeft = upload.maxRetries
     while (true) {
       try {
         // - "delay" should be within the "try" block to account for worker cancellation,
@@ -102,140 +107,112 @@ class UploadWorker(private val context: Context, params: WorkerParameters) :
         if (isRetried) delay(RETRY_DELAY)
         isRetried = true
 
-        val file = File(upload.path)
-
-        // Don't bother to run on an invalid network
-        if (!validateAndReportConnectivity()) continue
+        val connectivity = getConnectivity(context)
 
-        EventReporter.progress(upload.id)
+        // If there's no internet, wait until there is
+        if (!connectivity.connected) continue
 
-        val response = okhttpUpload(client, upload, file) { bytesSentTotal ->
-          UploadQueue.progress(upload.id, bytesSentTotal)
-          EventReporter.progress(upload.id)
-          updateNotification()
+        // If upload requires wifi and we're not on wifi, try to switch to a non-wifi upload
+        if (!connectivity.wifi && upload.wifiOnly) {
+          if (UploadQueue.selectNext(wifiOnly = false)) {
+            // switched to a non-wifi upload
+            return
+          } else {
+            // no non-wifi uploads, wait for wifi
+            continue
+          }
         }
 
-        handleSuccess(upload, response)
-        return@withContext
+        // Start the upload
+        val response = okhttpUpload(
+          client, upload,
+          onProgress = { bytesSentTotal ->
+            UploadQueue.progress(upload.id, bytesSentTotal)
+            EventReporter.progress(upload.id)
+          },
+          isCancelled = {
+            if (isStopped) true
+            else if (UploadQueue.current() != upload) true
+            else if (upload.wifiOnly && !getConnectivity(context).wifi) true
+            else false
+          }
+        )
+
+        // Mark upload as completed
+        UploadQueue.complete()
+        EventReporter.success(upload.id, response)
+        return
       } catch (error: Throwable) {
-        // TODO not necessary anymore?
-        if (checkAndHandleCancellation(upload)) throw error
-        if (checkRetry(upload, error)) continue
-
-        // Log error but continue with next upload
-        UploadQueue.pop()
-        EventReporter.error(upload.id, error)
-        return@withContext
-      }
-    }
-  }
-
-  private fun handleSuccess(upload: Upload, response: UploadResponse) {
-    // Mark as completed on success
-    UploadQueue.complete()
-    EventReporter.success(upload.id, response)
-  }
-
-
-  // Check if cancelled by user or new worker with same ID
-  // Worker won't rerun, perform teardown
-  private fun checkAndHandleCancellation(upload: Upload): Boolean {
-    if (!isStopped) return false
+//        TODO
+//        EventReporter.cancelled(upload.id)
+//        TODO handle cancellations from isCancelled
+        if (isStopped) return
+        if (UploadQueue.current() != upload) return
+
+
+        // High chance error was thrown due to network connection issue
+        // There's a bunch of different errors that can be thrown here,
+        // so just check if the network is connected.
+        if (!getConnectivity(context).connected) continue
+
+        // Due to the flaky nature of networking, sometimes the network is
+        // valid but the URL is still inaccessible, so keep waiting until
+        // the URL is accessible
+        if (error is UnknownHostException) continue
+
+        // There are many IOExceptions that only differ by messages,
+        // so we can't check using class, but theoretically,
+        // only the one caused by file not existing should stop the retry.
+        // The rest should be related to flaky network or flaky file I/O,
+        // where we can retry without limit.
+        if (error is IOException) {
+          try {
+            if (!File(upload.path).exists()) {
+              handleError(upload, error)
+              return
+            }
+          } catch (_: Throwable) {
+            // if this errors, can't do anything but retry
+            continue
+          }
+        }
 
-    EventReporter.cancelled(upload.id)
-    return true
-  }
+        // Only penalize retries for other types of errors
+        retriesLeft--
+        if (retriesLeft > 0) continue
 
-  /** @return whether to retry */
-  private suspend fun checkRetry(upload: Upload, error: Throwable): Boolean {
-    var unlimitedRetry = false
-
-    // Error was thrown due to unmet network preferences.
-    // Also happens every time you switch from one network to any other
-    if (!validateAndReportConnectivity()) unlimitedRetry = true
-    // Due to the flaky nature of networking, sometimes the network is
-    // valid but the URL is still inaccessible, so keep waiting until
-    // the URL is accessible
-    else if (error is UnknownHostException) unlimitedRetry = true
-    // There are many IOExceptions that only differ by messages,
-    // so we can't check using class, but theoretically,
-    // only the one caused by file not existing should stop the retry.
-    // The rest should be related to flaky network or flaky file I/O,
-    // where we can retry without limit.
-    else if (error is IOException) {
-      try {
-        if (!File(upload.path).exists()) return false
-        unlimitedRetry = true
-      } catch (_: Throwable) {
-        // read file error, can't do anything but retry
-        unlimitedRetry = false
+        // Finally, handle the error
+        handleError(upload, error)
+        return
       }
     }
-
-    retries = if (unlimitedRetry) 0 else retries + 1
-    return retries <= upload.maxRetries
   }
 
-  // Checks connection and alerts connection issues
-  private fun validateAndReportConnectivity(): Boolean {
-    this.connectivity = validateConnectivity(context, upload.wifiOnly)
-    // Update notification instead of calling setForeground
-    updateNotification()
-    return this.connectivity == Connectivity.Ok
+  private fun handleError(upload: Upload, error: Throwable) {
+    UploadQueue.pop()
+    EventReporter.error(upload.id, error)
   }
 
+
   private fun updateNotification() {
     if (!foreground) return
 
-    val timeSinceLastUpdate = System.currentTimeMillis() - lastNotificationUpdate
-    if (timeSinceLastUpdate < 1000L) return
-
-    val (id, notification) = buildNotification()
-    notificationManager.notify(id, notification)
-  }
+    val connectivity = getConnectivity(context)
 
-  private fun buildNotification(): Pair<Int, Notification> {
-    val progress = UploadQueue.progressPercentage()
-    val progress2Decimals = "%.2f".format(progress)
-    val title = when (connectivity) {
-      Connectivity.NoWifi -> NotificationConfigs.titleNoWifi
-      Connectivity.NoInternet -> NotificationConfigs.titleNoInternet
-      Connectivity.Ok -> NotificationConfigs.title
-    }
+    val notificationConnectivity =
+      if (!connectivity.connected) NotificationConnectivity.NoInternet
+      else if (UploadQueue.allWifiOnly() && !connectivity.wifi) NotificationConnectivity.NoWifi
+      else NotificationConnectivity.Ok
 
-    // Custom layout for progress notification.
-    // The default hides the % text. This one shows it on the right,
-    // like most examples in various docs.
-    val content = RemoteViews(context.packageName, R.layout.notification)
-    content.setTextViewText(R.id.notification_title, title)
-    content.setTextViewText(R.id.notification_progress, "${progress2Decimals}%")
-    content.setProgressBar(R.id.notification_progress_bar, 100, progress.toInt(), false)
-
-    val notification = NotificationCompat.Builder(context, NotificationConfigs.channel).run {
-      // Starting Android 12, the notification shows up with a confusing delay of 10s.
-      // This fixes that delay.
-      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S)
-        foregroundServiceBehavior = Notification.FOREGROUND_SERVICE_IMMEDIATE
-
-      // Required by android. Here we use the system's default upload icon
-      setSmallIcon(android.R.drawable.stat_sys_upload)
-      // These prevent the notification from being force-dismissed or dismissed when pressed
-      setOngoing(true)
-      setAutoCancel(false)
-      // These help show the same custom content when the notification collapses and expands
-      setCustomContentView(content)
-      setCustomBigContentView(content)
-      // opens the app when the notification is pressed
-      setContentIntent(openAppIntent(context))
-      build()
-    }
-
-    return Pair(NotificationConfigs.id, notification)
+    val (id, notification) = buildNotification(context, notificationConnectivity)
+    val manager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+    manager.notify(id, notification)
   }
 
+
   // builds the notification required to enable Foreground mode
   override suspend fun getForegroundInfo(): ForegroundInfo {
-    val (id, notification) = buildNotification()
+    val (id, notification) = buildNotification(context, NotificationConnectivity.Ok)
 
     // Starting Android 14, FOREGROUND_SERVICE_TYPE_DATA_SYNC is mandatory, otherwise app will crash
     return if (Build.VERSION.SDK_INT > Build.VERSION_CODES.TIRAMISU)
@@ -245,28 +222,12 @@ class UploadWorker(private val context: Context, params: WorkerParameters) :
   }
 }
 
-// This is outside and synchronized to ensure consistent status across workers
-@Synchronized
-private fun validateConnectivity(context: Context, wifiOnly: Boolean): Connectivity {
+private fun getConnectivity(context: Context): Connectivity {
   val manager = context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
   val network = manager.activeNetwork
   val capabilities = manager.getNetworkCapabilities(network)
+  val connected = capabilities?.hasCapability(NET_CAPABILITY_VALIDATED) == true
+  val wifi = capabilities?.hasTransport(TRANSPORT_WIFI) == true
 
-  val hasInternet = capabilities?.hasCapability(NET_CAPABILITY_VALIDATED) == true
-
-  // not wifiOnly, return early
-  if (!wifiOnly) return if (hasInternet) Connectivity.Ok else Connectivity.NoInternet
-
-  // handle wifiOnly
-  return if (hasInternet && capabilities?.hasTransport(TRANSPORT_WIFI) == true)
-    Connectivity.Ok
-  else
-    Connectivity.NoWifi // don't return NoInternet here, more direct to request to join wifi
-}
-
-
-private fun openAppIntent(context: Context): PendingIntent? {
-  val intent = Intent(context, NotificationReceiver::class.java)
-  val flags = PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
-  return PendingIntent.getBroadcast(context, "RNFileUpload-notification".hashCode(), intent, flags)
+  return Connectivity(wifi = wifi, connected = connected)
 }
diff --git a/android/src/main/java/com/vydia/RNUploader/UploaderModule.kt b/android/src/main/java/com/vydia/RNUploader/UploaderModule.kt
index 6b1d036f..6be5521a 100644
--- a/android/src/main/java/com/vydia/RNUploader/UploaderModule.kt
+++ b/android/src/main/java/com/vydia/RNUploader/UploaderModule.kt
@@ -19,7 +19,7 @@ class UploaderModule(context: ReactApplicationContext) :
 
   companion object {
     const val TAG = "RNFileUploader.UploaderModule"
-    const val WORKER_TAG = "RNFileUploader"
+    const val WORKER_ID = "RNFileUploader"
     var reactContext: ReactApplicationContext? = null
       private set
   }
@@ -64,7 +64,7 @@ class UploaderModule(context: ReactApplicationContext) :
         .build()
 
       workManager
-        .beginUniqueWork(WORKER_TAG, ExistingWorkPolicy.KEEP, request)
+        .beginUniqueWork(WORKER_ID, ExistingWorkPolicy.KEEP, request)
         .enqueue()
 
       promise.resolve(upload.id)
@@ -86,7 +86,8 @@ class UploaderModule(context: ReactApplicationContext) :
   fun cancelUpload(uploadId: String, promise: Promise) {
     try {
       // Just remove from queue, worker will handle progress cleanup
-      UploadQueue.remove(uploadId)
+      UploadQueue.cancel(uploadId)
+      if (UploadQueue.isEmpty()) workManager.cancelUniqueWork(WORKER_ID)
       promise.resolve(true)
     } catch (exc: Throwable) {
       exc.printStackTrace()
@@ -102,7 +103,7 @@ class UploaderModule(context: ReactApplicationContext) :
   fun stopAllUploads(promise: Promise) {
     try {
       UploadQueue.clear()
-      workManager.cancelAllWorkByTag(WORKER_TAG)
+      workManager.cancelUniqueWork(WORKER_ID)
       promise.resolve(true)
     } catch (exc: Throwable) {
       exc.printStackTrace()

From 5919d1c240612987604b7e5089c63218724670ba Mon Sep 17 00:00:00 2001
From: thomasvo <thomas.vo@openspace.ai>
Date: Tue, 14 Oct 2025 16:36:22 -0700
Subject: [PATCH 23/28] =?UTF-8?q?small=CB=86?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 android/src/main/java/com/vydia/RNUploader/UploadWorker.kt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/android/src/main/java/com/vydia/RNUploader/UploadWorker.kt b/android/src/main/java/com/vydia/RNUploader/UploadWorker.kt
index 953e925b..619531f3 100644
--- a/android/src/main/java/com/vydia/RNUploader/UploadWorker.kt
+++ b/android/src/main/java/com/vydia/RNUploader/UploadWorker.kt
@@ -201,7 +201,7 @@ class UploadWorker(private val context: Context, params: WorkerParameters) :
 
     val notificationConnectivity =
       if (!connectivity.connected) NotificationConnectivity.NoInternet
-      else if (UploadQueue.allWifiOnly() && !connectivity.wifi) NotificationConnectivity.NoWifi
+      else if (UploadQueue.isAllWifiOnly() && !connectivity.wifi) NotificationConnectivity.NoWifi
       else NotificationConnectivity.Ok
 
     val (id, notification) = buildNotification(context, notificationConnectivity)

From 7fd4256786788e70bf69a5509641a1d3ec6a91af Mon Sep 17 00:00:00 2001
From: thomasvo <thomas.vo@openspace.ai>
Date: Tue, 14 Oct 2025 16:46:49 -0700
Subject: [PATCH 24/28] =?UTF-8?q?small=CB=86?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../java/com/vydia/RNUploader/UploadWorker.kt   | 17 +++++++----------
 1 file changed, 7 insertions(+), 10 deletions(-)

diff --git a/android/src/main/java/com/vydia/RNUploader/UploadWorker.kt b/android/src/main/java/com/vydia/RNUploader/UploadWorker.kt
index 619531f3..7764a9c7 100644
--- a/android/src/main/java/com/vydia/RNUploader/UploadWorker.kt
+++ b/android/src/main/java/com/vydia/RNUploader/UploadWorker.kt
@@ -74,8 +74,8 @@ class UploadWorker(private val context: Context, params: WorkerParameters) :
     }
 
     try {
-      // Keep processing uploads until no more incomplete uploads
-      while (!UploadQueue.isEmpty()) processUpload()
+      // Keep processing uploads until the queue is empty
+      while (!UploadQueue.isEmpty()) uploadCurrent()
 
       return@withContext Result.success()
     } finally {
@@ -84,7 +84,7 @@ class UploadWorker(private val context: Context, params: WorkerParameters) :
     }
   }
 
-  private suspend fun processUpload() {
+  private suspend fun uploadCurrent() {
     val upload = UploadQueue.current()
     // Complex work, errors thrown below here trigger retry.
     // We don't let WorkManager manage retries and network constraints as it's very buggy.
@@ -114,13 +114,10 @@ class UploadWorker(private val context: Context, params: WorkerParameters) :
 
         // If upload requires wifi and we're not on wifi, try to switch to a non-wifi upload
         if (!connectivity.wifi && upload.wifiOnly) {
-          if (UploadQueue.selectNext(wifiOnly = false)) {
-            // switched to a non-wifi upload
-            return
-          } else {
-            // no non-wifi uploads, wait for wifi
-            continue
-          }
+          // switched to a non-wifi upload
+          if (UploadQueue.selectNext(wifiOnly = false)) return
+          // no non-wifi uploads, wait for wifi
+          continue
         }
 
         // Start the upload

From 00942cb0dfe29cf03d51cdaca8cadf1440fe1aa9 Mon Sep 17 00:00:00 2001
From: thomasvo <thomas.vo@openspace.ai>
Date: Tue, 14 Oct 2025 19:13:50 -0700
Subject: [PATCH 25/28] udpates

---
 .../com/vydia/RNUploader/EventReporter.kt     |   7 +
 .../main/java/com/vydia/RNUploader/Upload.kt  |   3 +-
 .../java/com/vydia/RNUploader/UploadQueue.kt  |  29 +--
 .../java/com/vydia/RNUploader/UploadUtils.kt  |   7 +-
 .../java/com/vydia/RNUploader/UploadWorker.kt | 224 +++++++++---------
 .../com/vydia/RNUploader/UploaderModule.kt    |  13 +-
 6 files changed, 153 insertions(+), 130 deletions(-)

diff --git a/android/src/main/java/com/vydia/RNUploader/EventReporter.kt b/android/src/main/java/com/vydia/RNUploader/EventReporter.kt
index 3c4e0af4..085d508d 100644
--- a/android/src/main/java/com/vydia/RNUploader/EventReporter.kt
+++ b/android/src/main/java/com/vydia/RNUploader/EventReporter.kt
@@ -23,6 +23,13 @@ class EventReporter {
         putString("error", exception.message ?: "Unknown exception")
       })
 
+    // TODO expose via JS
+    fun globalError(origin: String, exception: Throwable) =
+      sendEvent("globalError", Arguments.createMap().apply {
+        putString("origin", origin)
+        putString("error", exception.message ?: "Unknown exception")
+      })
+
     fun success(uploadId: String, response: UploadResponse) =
       CoroutineScope(Dispatchers.IO).launch {
         sendEvent("completed", Arguments.createMap().apply {
diff --git a/android/src/main/java/com/vydia/RNUploader/Upload.kt b/android/src/main/java/com/vydia/RNUploader/Upload.kt
index de7c3c25..f1671655 100644
--- a/android/src/main/java/com/vydia/RNUploader/Upload.kt
+++ b/android/src/main/java/com/vydia/RNUploader/Upload.kt
@@ -1,7 +1,7 @@
 package com.vydia.RNUploader
 
 import com.facebook.react.bridge.ReadableMap
-import java.util.*
+import java.util.UUID
 
 // Data model of a single upload
 // Can be created from RN's ReadableMap
@@ -18,7 +18,6 @@ data class Upload(
   // Progress tracking properties
   var bytesUploaded: Long = 0L
   var size: Long = 0L
-  var completed: Boolean = false
 
   companion object {
     fun fromRawOptions(map: ReadableMap) = Upload(
diff --git a/android/src/main/java/com/vydia/RNUploader/UploadQueue.kt b/android/src/main/java/com/vydia/RNUploader/UploadQueue.kt
index 98e070d9..4f31268c 100644
--- a/android/src/main/java/com/vydia/RNUploader/UploadQueue.kt
+++ b/android/src/main/java/com/vydia/RNUploader/UploadQueue.kt
@@ -21,7 +21,7 @@ object UploadQueue {
 
     val totalBytes = queue.sumOf { it.size } + completedBytes
     if (totalBytes == 0L) return 0f
-    val uploadedBytes = current().bytesUploaded + completedBytes
+    val uploadedBytes = (current()?.bytesUploaded ?: 0L) + completedBytes
 
     return uploadedBytes.toFloat() / totalBytes.toFloat() * 100
   }
@@ -40,18 +40,14 @@ object UploadQueue {
   }
 
   @Synchronized
-  fun progress(uploadId: String, bytesUploaded: Long) {
-    queue.find { it.id == uploadId }?.bytesUploaded = bytesUploaded
+  fun progress(bytesUploaded: Long) {
+    current()?.bytesUploaded = bytesUploaded
   }
 
   @Synchronized
   fun complete() {
-    val upload = queue.removeFirst()
-
-    upload.bytesUploaded = upload.size
-    upload.completed = true
-    // Keep completed upload sizes for a while to report overall progress correctly
-    completedBytes += upload.size
+    // Extract size immediately and allow upload object to be garbage collected
+    completedBytes += queue.removeFirst().size
   }
 
   @Synchronized
@@ -62,18 +58,23 @@ object UploadQueue {
 
 
   @Synchronized
-  fun selectNext(wifiOnly: Boolean): Boolean {
-    val upload = queue.find { it.wifiOnly == wifiOnly } ?: return false
-    queue.remove(upload)
+  fun skipWifiOnly(): Boolean {
+    // Find index instead of element to avoid double search
+    val index = queue.indexOfFirst { !it.wifiOnly }
+    if (index == -1) return false
+    if (index == 0) return true // Already at front
+
+    // Remove by index (still O(n) but avoids the find step)
+    val upload = queue.removeAt(index)
     queue.addFirst(upload)
     return true
   }
 
   @Synchronized
-  fun allWifiOnly() = !queue.isEmpty() && queue.all { it.wifiOnly }
+  fun isAllWifiOnly() = !queue.isEmpty() && queue.all { it.wifiOnly }
 
   @Synchronized
-  fun current() = queue.first()
+  fun current() = queue.firstOrNull()
 
   @Synchronized
   fun clear() {
diff --git a/android/src/main/java/com/vydia/RNUploader/UploadUtils.kt b/android/src/main/java/com/vydia/RNUploader/UploadUtils.kt
index cc7781dd..a099a3ce 100644
--- a/android/src/main/java/com/vydia/RNUploader/UploadUtils.kt
+++ b/android/src/main/java/com/vydia/RNUploader/UploadUtils.kt
@@ -144,13 +144,16 @@ class MissingOptionException(optionName: String) :
   IllegalArgumentException("Missing '$optionName'")
 
 
-data class Connectivity(val wifi: Boolean, val connected: Boolean)
+data class Connection(val wifi: Boolean, val connected: Boolean)
 
 enum class NotificationConnectivity {
   NoWifi, NoInternet, Ok
 }
 
-fun buildNotification(context: Context, connectivity: NotificationConnectivity): Pair<Int, Notification> {
+fun buildNotification(
+  context: Context,
+  connectivity: NotificationConnectivity
+): Pair<Int, Notification> {
   val progress = UploadQueue.progressPercentage()
   val progress2Decimals = "%.2f".format(progress)
   val title = when (connectivity) {
diff --git a/android/src/main/java/com/vydia/RNUploader/UploadWorker.kt b/android/src/main/java/com/vydia/RNUploader/UploadWorker.kt
index 7764a9c7..8e1a89a5 100644
--- a/android/src/main/java/com/vydia/RNUploader/UploadWorker.kt
+++ b/android/src/main/java/com/vydia/RNUploader/UploadWorker.kt
@@ -10,6 +10,8 @@ import android.os.Build
 import androidx.work.CoroutineWorker
 import androidx.work.ForegroundInfo
 import androidx.work.WorkerParameters
+import kotlinx.coroutines.CancellationException
+import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.Job
 import kotlinx.coroutines.delay
@@ -21,8 +23,6 @@ import java.io.IOException
 import java.net.UnknownHostException
 import java.util.concurrent.TimeUnit
 
-// Retry delay
-private val RETRY_DELAY = TimeUnit.SECONDS.toMillis(10L)
 
 // Max total time for a single request to complete
 // This is 24hrs so plenty of time for large uploads
@@ -39,7 +39,6 @@ private val client = OkHttpClient.Builder()
 
 class UploadWorker(private val context: Context, params: WorkerParameters) :
   CoroutineWorker(context, params) {
-  private var foreground = false
 
   override suspend fun doWork(): Result = withContext(Dispatchers.IO) {
     try {
@@ -48,75 +47,54 @@ class UploadWorker(private val context: Context, params: WorkerParameters) :
       // of it being killed during low memory or Doze/App Standby situations.
       // ⚠️ This should be called in the foreground
       setForeground(getForegroundInfo())
-      foreground = true
     } catch (error: Throwable) {
-      // Should not block the worker if setting foreground fails
-      // TODO report errors
+      // If we fail to start foreground service, the worker will be stopped shortly after,
+      // which makes it impossible to report errors for all uploads in the queue.
+      // If we report errors here, the client can decide when to retry.
+      handleUnableToStartForeground(error)
+      throw error
     }
 
     // Update notification periodically
     var notificationJob: Job? = null
     try {
-      notificationJob = launch {
-        while (true) {
-          try {
-            delay(1000L)
-            updateNotification()
-          } catch (error: Throwable) {
-            if (isStopped) return@launch
-            // TODO report errors
-          }
-        }
-      }
+      notificationJob = startNotificationUpdateJob()
     } catch (_: Throwable) {
       // Should not block the worker if notification job setup fails
-      // TODO report errors
+      EventReporter.globalError(
+        "UploadWorker.startNotificationUpdateJob",
+        Error("Failed to start notification job")
+      )
     }
 
     try {
       // Keep processing uploads until the queue is empty
-      while (!UploadQueue.isEmpty()) uploadCurrent()
+      while (UploadQueue.current() != null) uploadCurrent()
 
       return@withContext Result.success()
     } finally {
       notificationJob?.cancel() // Cancel the notification updates when work is done
-      UploadQueue.clear()
     }
   }
 
   private suspend fun uploadCurrent() {
-    val upload = UploadQueue.current()
-    // Complex work, errors thrown below here trigger retry.
+    val upload = UploadQueue.current() ?: return
+
     // We don't let WorkManager manage retries and network constraints as it's very buggy.
     // i.e. we'd occasionally get BackgroundServiceStartNotAllowedException,
-    // or ForegroundServiceStartNotAllowedException, or "isStopped" gets set to "true"
-    // for no reason
-    var isRetried = false
-    var retriesLeft = upload.maxRetries
+    // or ForegroundServiceStartNotAllowedException, or workers getting cancelled for no reason.
+    var retries = 0
     while (true) {
       try {
-        // - "delay" should be within the "try" block to account for worker cancellation,
-        // which cancels the delay immediately and throws CancellationException.
-        // - Linear backoff instead of exponential. One reason for this is we retry on
-        // invalid connections. Exponential will take too long. If the server flakes and
-        // returns 500s, we don't retry but consider the request successful.
-        // This is consistent with iOS behavior. User gets notifications for
-        // these server issues and can manually retry. Since 500s are currently rare,
-        // it's likely ok. If they're too frequent, we can consider adding exponential
-        // backoff for them.
-        if (isRetried) delay(RETRY_DELAY)
-        isRetried = true
-
-        val connectivity = getConnectivity(context)
+        // even this delay needs to be part of the try block
+        if (retries > 0) delay(5_000L)
 
         // If there's no internet, wait until there is
-        if (!connectivity.connected) continue
+        val connection = waitForInternet()
 
         // If upload requires wifi and we're not on wifi, try to switch to a non-wifi upload
-        if (!connectivity.wifi && upload.wifiOnly) {
-          // switched to a non-wifi upload
-          if (UploadQueue.selectNext(wifiOnly = false)) return
-          // no non-wifi uploads, wait for wifi
+        if (!connection.wifi && upload.wifiOnly) {
+          if (UploadQueue.skipWifiOnly()) return
           continue
         }
 
@@ -124,13 +102,12 @@ class UploadWorker(private val context: Context, params: WorkerParameters) :
         val response = okhttpUpload(
           client, upload,
           onProgress = { bytesSentTotal ->
-            UploadQueue.progress(upload.id, bytesSentTotal)
+            UploadQueue.progress(bytesSentTotal)
             EventReporter.progress(upload.id)
           },
           isCancelled = {
-            if (isStopped) true
-            else if (UploadQueue.current() != upload) true
-            else if (upload.wifiOnly && !getConnectivity(context).wifi) true
+            if (UploadQueue.current() != upload) true
+            else if (upload.wifiOnly && !checkConnection().wifi) true
             else false
           }
         )
@@ -140,70 +117,98 @@ class UploadWorker(private val context: Context, params: WorkerParameters) :
         EventReporter.success(upload.id, response)
         return
       } catch (error: Throwable) {
-//        TODO
-//        EventReporter.cancelled(upload.id)
-//        TODO handle cancellations from isCancelled
-        if (isStopped) return
-        if (UploadQueue.current() != upload) return
-
-
-        // High chance error was thrown due to network connection issue
-        // There's a bunch of different errors that can be thrown here,
-        // so just check if the network is connected.
-        if (!getConnectivity(context).connected) continue
-
-        // Due to the flaky nature of networking, sometimes the network is
-        // valid but the URL is still inaccessible, so keep waiting until
-        // the URL is accessible
-        if (error is UnknownHostException) continue
-
-        // There are many IOExceptions that only differ by messages,
-        // so we can't check using class, but theoretically,
-        // only the one caused by file not existing should stop the retry.
-        // The rest should be related to flaky network or flaky file I/O,
-        // where we can retry without limit.
-        if (error is IOException) {
-          try {
-            if (!File(upload.path).exists()) {
-              handleError(upload, error)
-              return
-            }
-          } catch (_: Throwable) {
-            // if this errors, can't do anything but retry
-            continue
-          }
+        try {
+          // If the current upload has changed, it means it was cancelled externally
+          if (UploadQueue.current() != upload) return
+
+          // Worker stopped externally. This is unexpected so we need to report errors
+          if (isStopped) return handleUnexpectedStop(error)
+
+          // High chance error was thrown due to network connection issue
+          // There's a bunch of different errors that can be thrown here,
+          // so just check if the network is connected.
+          if (!checkConnection().connected) continue
+
+          // Due to the flaky nature of networking, sometimes the network is
+          // valid but the URL is still inaccessible, so keep waiting until
+          // the URL is accessible
+          if (error is UnknownHostException) continue
+
+          // There are many errors here that come from non-existent files
+          // so we can't check using class, so we just check if the file exists
+          // If the file doesn't exist, no point retrying
+          if (!File(upload.path).exists())
+            return handleError(upload, IOException("File at path ${upload.path} does not exist"))
+
+          // Only penalize retries for other types of errors
+          retries++
+
+          // If we've retried too many times, give up
+          if (retries > upload.maxRetries) return handleError(upload, error)
+        } catch (_: Throwable) {
+          continue
         }
-
-        // Only penalize retries for other types of errors
-        retriesLeft--
-        if (retriesLeft > 0) continue
-
-        // Finally, handle the error
-        handleError(upload, error)
-        return
       }
     }
   }
 
+  private suspend fun waitForInternet(): Connection {
+    while (true) {
+      if (UploadQueue.isEmpty()) throw CancellationException()
+      val connectivity = checkConnection()
+      if (connectivity.connected) return connectivity
+      delay(1000L)
+    }
+  }
+
   private fun handleError(upload: Upload, error: Throwable) {
     UploadQueue.pop()
     EventReporter.error(upload.id, error)
   }
 
+  private fun handleUnexpectedStop(error: Throwable) {
+    val stopReason =
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) this.stopReason else "unknown"
 
-  private fun updateNotification() {
-    if (!foreground) return
+    val error =
+      CancellationException("Worker stopped due to: $stopReason. Original error: ${error.message}")
 
-    val connectivity = getConnectivity(context)
+    while (!UploadQueue.isEmpty()) {
+      val upload = UploadQueue.pop()
+      EventReporter.error(upload.id, error)
+    }
+  }
 
-    val notificationConnectivity =
-      if (!connectivity.connected) NotificationConnectivity.NoInternet
-      else if (UploadQueue.isAllWifiOnly() && !connectivity.wifi) NotificationConnectivity.NoWifi
-      else NotificationConnectivity.Ok
+  private fun handleUnableToStartForeground(error: Throwable) {
+    val error =
+      Error("Failed to start foreground service. Original error: ${error.message}")
 
-    val (id, notification) = buildNotification(context, notificationConnectivity)
-    val manager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
-    manager.notify(id, notification)
+    while (!UploadQueue.isEmpty()) {
+      val upload = UploadQueue.pop()
+      EventReporter.error(upload.id, error)
+    }
+  }
+
+
+  private fun startNotificationUpdateJob() = CoroutineScope(Dispatchers.IO).launch {
+    while (true) {
+      try {
+        delay(1000L)
+
+        val connection = checkConnection()
+
+        val notificationConnectivity =
+          if (!connection.connected) NotificationConnectivity.NoInternet
+          else if (UploadQueue.isAllWifiOnly() && !connection.wifi) NotificationConnectivity.NoWifi
+          else NotificationConnectivity.Ok
+
+        val (id, notification) = buildNotification(context, notificationConnectivity)
+        notificationManager.notify(id, notification)
+      } catch (error: Throwable) {
+        if (isStopped) return@launch
+        EventReporter.globalError("UploadWorker.updateNotification", error)
+      }
+    }
   }
 
 
@@ -217,14 +222,21 @@ class UploadWorker(private val context: Context, params: WorkerParameters) :
     else
       ForegroundInfo(id, notification)
   }
-}
 
-private fun getConnectivity(context: Context): Connectivity {
-  val manager = context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
-  val network = manager.activeNetwork
-  val capabilities = manager.getNetworkCapabilities(network)
-  val connected = capabilities?.hasCapability(NET_CAPABILITY_VALIDATED) == true
-  val wifi = capabilities?.hasTransport(TRANSPORT_WIFI) == true
+  private fun checkConnection(): Connection {
+    val network = connectivityManager.activeNetwork
+    val capabilities = connectivityManager.getNetworkCapabilities(network)
+    val connected = capabilities?.hasCapability(NET_CAPABILITY_VALIDATED) == true
+    val wifi = capabilities?.hasTransport(TRANSPORT_WIFI) == true
+
+    return Connection(wifi = wifi, connected = connected)
+  }
+
 
-  return Connectivity(wifi = wifi, connected = connected)
+  val notificationManager: NotificationManager
+    get() = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+
+  val connectivityManager: ConnectivityManager
+    get() = context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
 }
+
diff --git a/android/src/main/java/com/vydia/RNUploader/UploaderModule.kt b/android/src/main/java/com/vydia/RNUploader/UploaderModule.kt
index 6be5521a..850cf98f 100644
--- a/android/src/main/java/com/vydia/RNUploader/UploaderModule.kt
+++ b/android/src/main/java/com/vydia/RNUploader/UploaderModule.kt
@@ -60,9 +60,9 @@ class UploaderModule(context: ReactApplicationContext) :
       val upload = Upload.fromRawOptions(rawOptions)
       UploadQueue.add(upload)
 
-      val request = OneTimeWorkRequestBuilder<UploadWorker>()
-        .build()
+      val request = OneTimeWorkRequestBuilder<UploadWorker>().build()
 
+      // TODO check if cancelling and starting will keep the queue
       workManager
         .beginUniqueWork(WORKER_ID, ExistingWorkPolicy.KEEP, request)
         .enqueue()
@@ -85,9 +85,8 @@ class UploaderModule(context: ReactApplicationContext) :
   @ReactMethod
   fun cancelUpload(uploadId: String, promise: Promise) {
     try {
-      // Just remove from queue, worker will handle progress cleanup
       UploadQueue.cancel(uploadId)
-      if (UploadQueue.isEmpty()) workManager.cancelUniqueWork(WORKER_ID)
+      EventReporter.cancelled(uploadId)
       promise.resolve(true)
     } catch (exc: Throwable) {
       exc.printStackTrace()
@@ -102,8 +101,10 @@ class UploaderModule(context: ReactApplicationContext) :
   @ReactMethod
   fun stopAllUploads(promise: Promise) {
     try {
-      UploadQueue.clear()
-      workManager.cancelUniqueWork(WORKER_ID)
+      while (!UploadQueue.isEmpty()) {
+        val upload = UploadQueue.pop()
+        EventReporter.cancelled(upload.id)
+      }
       promise.resolve(true)
     } catch (exc: Throwable) {
       exc.printStackTrace()

From 0091c8ff93dfb8181a92a3b721a7ca0e86dee1a9 Mon Sep 17 00:00:00 2001
From: thomasvo <thomas.vo@openspace.ai>
Date: Tue, 14 Oct 2025 19:15:41 -0700
Subject: [PATCH 26/28] fix

---
 android/src/main/java/com/vydia/RNUploader/UploadWorker.kt | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/android/src/main/java/com/vydia/RNUploader/UploadWorker.kt b/android/src/main/java/com/vydia/RNUploader/UploadWorker.kt
index 8e1a89a5..0f6e83e9 100644
--- a/android/src/main/java/com/vydia/RNUploader/UploadWorker.kt
+++ b/android/src/main/java/com/vydia/RNUploader/UploadWorker.kt
@@ -59,11 +59,11 @@ class UploadWorker(private val context: Context, params: WorkerParameters) :
     var notificationJob: Job? = null
     try {
       notificationJob = startNotificationUpdateJob()
-    } catch (_: Throwable) {
+    } catch (error: Throwable) {
       // Should not block the worker if notification job setup fails
       EventReporter.globalError(
         "UploadWorker.startNotificationUpdateJob",
-        Error("Failed to start notification job")
+        Error("Failed to start notification job: ${error.message}")
       )
     }
 

From 21d95ad443b68eb2c2894dc5b4bb5920bd99f233 Mon Sep 17 00:00:00 2001
From: thomasvo <thomas.vo@openspace.ai>
Date: Tue, 14 Oct 2025 19:24:16 -0700
Subject: [PATCH 27/28] exponential backoff

---
 .../main/java/com/vydia/RNUploader/UploadWorker.kt   | 12 ++++++++++--
 1 file changed, 10 insertions(+), 2 deletions(-)

diff --git a/android/src/main/java/com/vydia/RNUploader/UploadWorker.kt b/android/src/main/java/com/vydia/RNUploader/UploadWorker.kt
index 0f6e83e9..02a746de 100644
--- a/android/src/main/java/com/vydia/RNUploader/UploadWorker.kt
+++ b/android/src/main/java/com/vydia/RNUploader/UploadWorker.kt
@@ -22,6 +22,7 @@ import java.io.File
 import java.io.IOException
 import java.net.UnknownHostException
 import java.util.concurrent.TimeUnit
+import kotlin.math.pow
 
 
 // Max total time for a single request to complete
@@ -86,8 +87,8 @@ class UploadWorker(private val context: Context, params: WorkerParameters) :
     var retries = 0
     while (true) {
       try {
-        // even this delay needs to be part of the try block
-        if (retries > 0) delay(5_000L)
+        // delay needs to be part of the try block
+        if (retries > 0) exponentialBackoffDelay(retries)
 
         // If there's no internet, wait until there is
         val connection = waitForInternet()
@@ -152,6 +153,13 @@ class UploadWorker(private val context: Context, params: WorkerParameters) :
     }
   }
 
+  private suspend fun exponentialBackoffDelay(retries: Int) {
+    var time = 5000L // 5 seconds
+    time = (time * (2.toDouble().pow(retries - 1))).toLong()
+    time = time.coerceAtMost(60_000L) // max 5 minutes
+    delay(time)
+  }
+
   private suspend fun waitForInternet(): Connection {
     while (true) {
       if (UploadQueue.isEmpty()) throw CancellationException()

From 7ab26db8f0f7d3ffe53bfc28253141a4243da4b1 Mon Sep 17 00:00:00 2001
From: thomasvo <thomas.vo@openspace.ai>
Date: Wed, 15 Oct 2025 09:15:14 -0700
Subject: [PATCH 28/28] v2

---
 android/build.gradle                          |   1 +
 .../com/vydia/RNUploader/EventReporter.kt     |  26 +-
 .../main/java/com/vydia/RNUploader/Upload.kt  |  27 +-
 .../com/vydia/RNUploader/UploadProgress.kt    |  64 ++++
 .../java/com/vydia/RNUploader/UploadUtils.kt  | 143 +------
 .../java/com/vydia/RNUploader/UploadWorker.kt | 348 ++++++++++--------
 .../com/vydia/RNUploader/UploaderModule.kt    |  82 ++---
 .../com/vydia/RNUploader2/EventReporter.kt    |  67 ++++
 .../NotificationConfigs.kt                    |   2 +-
 .../vydia/RNUploader2/NotificationReceiver.kt |  17 +
 .../main/java/com/vydia/RNUploader2/Upload.kt |  40 ++
 .../UploadQueue.kt                            |   2 +-
 .../java/com/vydia/RNUploader2/UploadUtils.kt | 201 ++++++++++
 .../com/vydia/RNUploader2/UploadWorker.kt     | 250 +++++++++++++
 .../RNUploader2/Uploader2ReactPackage.java    |  35 ++
 .../com/vydia/RNUploader2/UploaderModule2.kt  | 119 ++++++
 16 files changed, 1072 insertions(+), 352 deletions(-)
 create mode 100644 android/src/main/java/com/vydia/RNUploader/UploadProgress.kt
 create mode 100644 android/src/main/java/com/vydia/RNUploader2/EventReporter.kt
 rename android/src/main/java/com/vydia/{RNUploader => RNUploader2}/NotificationConfigs.kt (97%)
 create mode 100644 android/src/main/java/com/vydia/RNUploader2/NotificationReceiver.kt
 create mode 100644 android/src/main/java/com/vydia/RNUploader2/Upload.kt
 rename android/src/main/java/com/vydia/{RNUploader => RNUploader2}/UploadQueue.kt (98%)
 create mode 100644 android/src/main/java/com/vydia/RNUploader2/UploadUtils.kt
 create mode 100644 android/src/main/java/com/vydia/RNUploader2/UploadWorker.kt
 create mode 100644 android/src/main/java/com/vydia/RNUploader2/Uploader2ReactPackage.java
 create mode 100644 android/src/main/java/com/vydia/RNUploader2/UploaderModule2.kt

diff --git a/android/build.gradle b/android/build.gradle
index 7674d13e..64b59248 100755
--- a/android/build.gradle
+++ b/android/build.gradle
@@ -60,4 +60,5 @@ dependencies {
     implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-core:1.10.2'
     implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.10.2'
     implementation "androidx.work:work-runtime-ktx:2.10.5"
+    implementation 'com.google.code.gson:gson:2.13.2'
 }
\ No newline at end of file
diff --git a/android/src/main/java/com/vydia/RNUploader/EventReporter.kt b/android/src/main/java/com/vydia/RNUploader/EventReporter.kt
index 085d508d..32daf999 100644
--- a/android/src/main/java/com/vydia/RNUploader/EventReporter.kt
+++ b/android/src/main/java/com/vydia/RNUploader/EventReporter.kt
@@ -7,6 +7,7 @@ import com.facebook.react.modules.core.DeviceEventManagerModule.RCTDeviceEventEm
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
+import okhttp3.Response
 
 // Sends events to React Native
 class EventReporter {
@@ -23,27 +24,26 @@ class EventReporter {
         putString("error", exception.message ?: "Unknown exception")
       })
 
-    // TODO expose via JS
-    fun globalError(origin: String, exception: Throwable) =
-      sendEvent("globalError", Arguments.createMap().apply {
-        putString("origin", origin)
-        putString("error", exception.message ?: "Unknown exception")
-      })
-
-    fun success(uploadId: String, response: UploadResponse) =
+    fun success(uploadId: String, response: Response) =
       CoroutineScope(Dispatchers.IO).launch {
         sendEvent("completed", Arguments.createMap().apply {
           putString("id", uploadId)
-          putInt("responseCode", response.statusCode)
-          putString("responseBody", response.body)
-          putMap("responseHeaders", Arguments.makeNativeMap(response.headers))
+          putInt("responseCode", response.code)
+          putString("responseBody", response.body?.string().let {
+            if (it.isNullOrBlank()) response.message else it
+          })
+          putMap("responseHeaders", Arguments.createMap().apply {
+            response.headers.names().forEach { name ->
+              putString(name, response.headers.values(name).joinToString(", "))
+            }
+          })
         })
       }
 
-    fun progress(uploadId: String) =
+    fun progress(uploadId: String, bytesSentTotal: Long, contentLength: Long) =
       sendEvent("progress", Arguments.createMap().apply {
         putString("id", uploadId)
-        putDouble("progress", UploadQueue.progressPercentage().toDouble())
+        putDouble("progress", (bytesSentTotal.toDouble() * 100 / contentLength)) //0-100
       })
 
     fun notification() = sendEvent("notification")
diff --git a/android/src/main/java/com/vydia/RNUploader/Upload.kt b/android/src/main/java/com/vydia/RNUploader/Upload.kt
index f1671655..5afdac69 100644
--- a/android/src/main/java/com/vydia/RNUploader/Upload.kt
+++ b/android/src/main/java/com/vydia/RNUploader/Upload.kt
@@ -1,7 +1,7 @@
 package com.vydia.RNUploader
 
 import com.facebook.react.bridge.ReadableMap
-import java.util.UUID
+import java.util.*
 
 // Data model of a single upload
 // Can be created from RN's ReadableMap
@@ -14,13 +14,17 @@ data class Upload(
   val maxRetries: Int,
   val wifiOnly: Boolean,
   val headers: Map<String, String>,
+  val notificationId: String,
+  val notificationTitle: String,
+  val notificationTitleNoInternet: String,
+  val notificationTitleNoWifi: String,
+  val notificationChannel: String,
 ) {
-  // Progress tracking properties
-  var bytesUploaded: Long = 0L
-  var size: Long = 0L
+  class MissingOptionException(optionName: String) :
+    IllegalArgumentException("Missing '$optionName'")
 
   companion object {
-    fun fromRawOptions(map: ReadableMap) = Upload(
+    fun fromReadableMap(map: ReadableMap) = Upload(
       id = map.getString("customUploadId") ?: UUID.randomUUID().toString(),
       url = map.getString(Upload::url.name) ?: throw MissingOptionException(Upload::url.name),
       path = map.getString(Upload::path.name) ?: throw MissingOptionException(Upload::path.name),
@@ -35,6 +39,19 @@ data class Upload(
         }
         return@let map
       },
+      notificationId = map.getString(Upload::notificationId.name)
+        ?: throw MissingOptionException(Upload::notificationId.name),
+      notificationTitle = map.getString(Upload::notificationTitle.name)
+        ?: throw MissingOptionException(Upload::notificationTitle.name),
+      notificationTitleNoInternet = map.getString(Upload::notificationTitleNoInternet.name)
+        ?: throw MissingOptionException(Upload::notificationTitleNoInternet.name),
+      notificationTitleNoWifi = map.getString(Upload::notificationTitleNoWifi.name)
+        ?: throw MissingOptionException(Upload::notificationTitleNoWifi.name),
+      notificationChannel = map.getString(Upload::notificationChannel.name)
+        ?: throw MissingOptionException(Upload::notificationChannel.name),
     )
   }
 }
+
+
+
diff --git a/android/src/main/java/com/vydia/RNUploader/UploadProgress.kt b/android/src/main/java/com/vydia/RNUploader/UploadProgress.kt
new file mode 100644
index 00000000..ee1bd78a
--- /dev/null
+++ b/android/src/main/java/com/vydia/RNUploader/UploadProgress.kt
@@ -0,0 +1,64 @@
+package com.vydia.RNUploader
+
+import android.content.Context
+import android.os.Handler
+import android.os.Looper
+import androidx.work.WorkManager
+import com.vydia.RNUploader.UploaderModule.Companion.WORKER_TAG
+
+// Stores and aggregates total progress from all workers
+class UploadProgress {
+
+  companion object {
+    private fun storage(context: Context) =
+      context.getSharedPreferences("RNFileUpload-Progress", Context.MODE_PRIVATE)
+
+    @Synchronized
+    fun set(context: Context, uploadId: String, bytesUploaded: Long, fileSize: Long) =
+      storage(context).edit()
+        .putLong("$uploadId-uploaded", bytesUploaded)
+        .putLong("$uploadId-size", fileSize)
+        .apply()
+
+    @Synchronized
+    fun remove(context: Context, uploadId: String) =
+      storage(context).edit()
+        .remove("$uploadId-uploaded")
+        .remove("$uploadId-size")
+        .apply()
+
+    @Synchronized
+    fun total(context: Context): Double {
+      val storage = storage(context)
+
+      val totalBytesUploaded = storage.all.keys
+        .filter { it.endsWith("-uploaded") }
+        .sumOf { storage.getLong(it, 0L) }
+
+      val totalFileSize = storage.all.keys
+        .filter { it.endsWith("-size") }
+        .sumOf { storage.getLong(it, 0L) }
+
+      if (totalFileSize == 0L) return 0.0
+      return (totalBytesUploaded.toDouble() * 100 / totalFileSize)
+    }
+
+    private val handler = Handler(Looper.getMainLooper())
+
+    // Attempt to clear in 2 seconds. This is the simplest way to let the
+    // last worker reset the overall progress.
+    // Clearing progress ensures the notification starts at 0% next time.
+    fun scheduleClearing(context: Context) =
+      handler.postDelayed({ clearIfNeeded(context) }, 2000)
+
+    @Synchronized
+    fun clearIfNeeded(context: Context) {
+      val workManager = WorkManager.getInstance(context)
+      val works = workManager.getWorkInfosByTag(WORKER_TAG).get()
+      if (works.any { !it.state.isFinished }) return
+
+      val storage = storage(context)
+      storage.edit().clear().apply()
+    }
+  }
+}
\ No newline at end of file
diff --git a/android/src/main/java/com/vydia/RNUploader/UploadUtils.kt b/android/src/main/java/com/vydia/RNUploader/UploadUtils.kt
index a099a3ce..57da5aac 100644
--- a/android/src/main/java/com/vydia/RNUploader/UploadUtils.kt
+++ b/android/src/main/java/com/vydia/RNUploader/UploadUtils.kt
@@ -1,25 +1,9 @@
 package com.vydia.RNUploader
 
-import android.app.Notification
-import android.app.PendingIntent
-import android.content.Context
-import android.content.Intent
-import android.os.Build
-import android.widget.RemoteViews
-import androidx.core.app.NotificationCompat
-import kotlinx.coroutines.CancellationException
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.delay
-import kotlinx.coroutines.launch
 import kotlinx.coroutines.suspendCancellableCoroutine
-import okhttp3.Call
-import okhttp3.Callback
+import okhttp3.*
 import okhttp3.Headers.Companion.toHeaders
-import okhttp3.OkHttpClient
-import okhttp3.Request
-import okhttp3.RequestBody
 import okhttp3.RequestBody.Companion.asRequestBody
-import okhttp3.Response
 import okio.Buffer
 import okio.BufferedSink
 import okio.ForwardingSink
@@ -31,25 +15,16 @@ import kotlin.coroutines.resumeWithException
 // Throttling interval of progress reports
 private const val PROGRESS_INTERVAL = 500 // milliseconds
 
-// Data class to hold the important response information
-data class UploadResponse(
-  val statusCode: Int,
-  val statusMessage: String,
-  val headers: Map<String, String>,
-  val body: String? = null
-)
 
 // make an upload request using okhttp
 suspend fun okhttpUpload(
   client: OkHttpClient,
   upload: Upload,
-  onProgress: (Long) -> Unit,
-  isCancelled: () -> Boolean
-): UploadResponse =
-  suspendCancellableCoroutine { continuation ->
-    val requestBody = File(upload.path).asRequestBody()
-
-    // Throttle progress reports
+  file: File,
+  onProgress: (Long) -> Unit
+) =
+  suspendCancellableCoroutine<Response> { continuation ->
+    val requestBody = file.asRequestBody()
     var lastProgressReport = 0L
     fun throttled(): Boolean {
       val now = System.currentTimeMillis()
@@ -58,7 +33,6 @@ suspend fun okhttpUpload(
       return false
     }
 
-    // Build the request
     val request = Request.Builder()
       .url(upload.url)
       .headers(upload.headers.toHeaders())
@@ -67,51 +41,14 @@ suspend fun okhttpUpload(
       })
       .build()
 
-    // Create the call
     val call = client.newCall(request)
-
-    // Start a polling coroutine to check for cancellation
-    val cancellationCheck = CoroutineScope(continuation.context).launch {
-      while (!call.isCanceled()) {
-        if (isCancelled()) {
-          call.cancel()
-          continuation.resumeWithException(CancellationException("Upload cancelled externally"))
-          break
-        }
-        delay(100) // Poll every 100ms
-      }
-    }
-
-    // cancel everything if the coroutine is cancelled
-    continuation.invokeOnCancellation {
-      call.cancel()
-      cancellationCheck.cancel()
-    }
-
-    // enqueue the call and add the callbacks
+    continuation.invokeOnCancellation { call.cancel() }
     call.enqueue(object : Callback {
-      override fun onFailure(call: Call, e: IOException) {
-        cancellationCheck.cancel()
-        if (isCancelled()) return
+      override fun onFailure(call: Call, e: IOException) =
         continuation.resumeWithException(e)
-      }
 
-      override fun onResponse(call: Call, response: Response) {
-        cancellationCheck.cancel()
-        response.use { // Automatically closes the response
-          if (isCancelled()) return
-
-          val uploadResponse = UploadResponse(
-            statusCode = response.code,
-            statusMessage = response.message,
-            headers = response.headers.toMap(),
-            body = response.body.string().let {
-              it.ifBlank { response.message }
-            }
-          )
-          continuation.resumeWith(Result.success(uploadResponse))
-        }
-      }
+      override fun onResponse(call: Call, response: Response) =
+        continuation.resumeWith(Result.success(response))
     })
   }
 
@@ -138,62 +75,4 @@ private fun withProgressListener(
     body.writeTo(bufferedSink)
     bufferedSink.flush()
   }
-}
-
-class MissingOptionException(optionName: String) :
-  IllegalArgumentException("Missing '$optionName'")
-
-
-data class Connection(val wifi: Boolean, val connected: Boolean)
-
-enum class NotificationConnectivity {
-  NoWifi, NoInternet, Ok
-}
-
-fun buildNotification(
-  context: Context,
-  connectivity: NotificationConnectivity
-): Pair<Int, Notification> {
-  val progress = UploadQueue.progressPercentage()
-  val progress2Decimals = "%.2f".format(progress)
-  val title = when (connectivity) {
-    NotificationConnectivity.NoWifi -> NotificationConfigs.titleNoWifi
-    NotificationConnectivity.NoInternet -> NotificationConfigs.titleNoInternet
-    NotificationConnectivity.Ok -> NotificationConfigs.title
-  }
-
-  // Custom layout for progress notification.
-  // The default hides the % text. This one shows it on the right,
-  // like most examples in various docs.
-  val content = RemoteViews(context.packageName, R.layout.notification)
-  content.setTextViewText(R.id.notification_title, title)
-  content.setTextViewText(R.id.notification_progress, "${progress2Decimals}%")
-  content.setProgressBar(R.id.notification_progress_bar, 100, progress.toInt(), false)
-
-  val notification = NotificationCompat.Builder(context, NotificationConfigs.channel).run {
-    // Starting Android 12, the notification shows up with a confusing delay of 10s.
-    // This fixes that delay.
-    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S)
-      foregroundServiceBehavior = Notification.FOREGROUND_SERVICE_IMMEDIATE
-
-    // Required by android. Here we use the system's default upload icon
-    setSmallIcon(android.R.drawable.stat_sys_upload)
-    // These prevent the notification from being force-dismissed or dismissed when pressed
-    setOngoing(true)
-    setAutoCancel(false)
-    // These help show the same custom content when the notification collapses and expands
-    setCustomContentView(content)
-    setCustomBigContentView(content)
-    // opens the app when the notification is pressed
-    setContentIntent(openAppIntent(context))
-    build()
-  }
-
-  return Pair(NotificationConfigs.id, notification)
-}
-
-private fun openAppIntent(context: Context): PendingIntent? {
-  val intent = Intent(context, NotificationReceiver::class.java)
-  val flags = PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
-  return PendingIntent.getBroadcast(context, "RNFileUpload-notification".hashCode(), intent, flags)
-}
+}
\ No newline at end of file
diff --git a/android/src/main/java/com/vydia/RNUploader/UploadWorker.kt b/android/src/main/java/com/vydia/RNUploader/UploadWorker.kt
index 02a746de..a3fc701b 100644
--- a/android/src/main/java/com/vydia/RNUploader/UploadWorker.kt
+++ b/android/src/main/java/com/vydia/RNUploader/UploadWorker.kt
@@ -1,29 +1,37 @@
 package com.vydia.RNUploader
 
-import android.app.NotificationManager
+import android.app.Notification
+import android.app.PendingIntent
 import android.content.Context
+import android.content.Intent
 import android.content.pm.ServiceInfo
 import android.net.ConnectivityManager
 import android.net.NetworkCapabilities.NET_CAPABILITY_VALIDATED
 import android.net.NetworkCapabilities.TRANSPORT_WIFI
 import android.os.Build
+import android.widget.RemoteViews
+import androidx.core.app.NotificationCompat
 import androidx.work.CoroutineWorker
 import androidx.work.ForegroundInfo
 import androidx.work.WorkerParameters
-import kotlinx.coroutines.CancellationException
-import kotlinx.coroutines.CoroutineScope
+import com.google.gson.Gson
 import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.Job
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.launch
+import kotlinx.coroutines.sync.Semaphore
 import kotlinx.coroutines.withContext
 import okhttp3.OkHttpClient
+import okhttp3.Response
 import java.io.File
 import java.io.IOException
 import java.net.UnknownHostException
 import java.util.concurrent.TimeUnit
-import kotlin.math.pow
 
+// All workers will start `doWork` immediately but only 1 request is active at a time.
+private const val MAX_CONCURRENCY = 1
+
+// Retry delay
+private val RETRY_DELAY = TimeUnit.SECONDS.toMillis(10L)
 
 // Max total time for a single request to complete
 // This is 24hrs so plenty of time for large uploads
@@ -32,16 +40,34 @@ import kotlin.math.pow
 private const val REQUEST_TIMEOUT = 24L
 private val REQUEST_TIMEOUT_UNIT = TimeUnit.HOURS
 
+// Control max concurrent requests using semaphore to instead of using
+// `maxConnectionsCount` in HttpClient as the latter introduces a delay between requests
+private val semaphore = Semaphore(MAX_CONCURRENCY)
 
 // Use Okhttp as it provides the most standard behaviors even though it's not coroutine friendly
 private val client = OkHttpClient.Builder()
   .callTimeout(REQUEST_TIMEOUT, REQUEST_TIMEOUT_UNIT)
   .build()
 
+private enum class Connectivity { NoWifi, NoInternet, Ok }
+
 class UploadWorker(private val context: Context, params: WorkerParameters) :
   CoroutineWorker(context, params) {
 
+  enum class Input { Params }
+
+  private lateinit var upload: Upload
+  private var retries = 0
+  private var connectivity = Connectivity.Ok
+
   override suspend fun doWork(): Result = withContext(Dispatchers.IO) {
+    // Retrieve the upload. If this throws errors, error reporting won't work.
+    // However, the only way it has errors is the implementation is incorrect,
+    // which can be caught in development
+    val paramsJson = inputData.getString(Input.Params.name) ?: throw Throwable("No Params")
+    upload = Gson().fromJson(paramsJson, Upload::class.java)
+
+    // initialization, errors thrown here won't be retried
     try {
       // `setForeground` is recommended for long-running workers.
       // Foreground mode helps prioritize the worker, reducing the risk
@@ -49,180 +75,179 @@ class UploadWorker(private val context: Context, params: WorkerParameters) :
       // ⚠️ This should be called in the foreground
       setForeground(getForegroundInfo())
     } catch (error: Throwable) {
-      // If we fail to start foreground service, the worker will be stopped shortly after,
-      // which makes it impossible to report errors for all uploads in the queue.
-      // If we report errors here, the client can decide when to retry.
-      handleUnableToStartForeground(error)
+      if (!checkAndHandleCancellation()) handleError(error)
       throw error
     }
 
-    // Update notification periodically
-    var notificationJob: Job? = null
-    try {
-      notificationJob = startNotificationUpdateJob()
-    } catch (error: Throwable) {
-      // Should not block the worker if notification job setup fails
-      EventReporter.globalError(
-        "UploadWorker.startNotificationUpdateJob",
-        Error("Failed to start notification job: ${error.message}")
-      )
-    }
-
-    try {
-      // Keep processing uploads until the queue is empty
-      while (UploadQueue.current() != null) uploadCurrent()
-
-      return@withContext Result.success()
-    } finally {
-      notificationJob?.cancel() // Cancel the notification updates when work is done
-    }
-  }
-
-  private suspend fun uploadCurrent() {
-    val upload = UploadQueue.current() ?: return
 
+    // Complex work, errors thrown below here trigger retry.
     // We don't let WorkManager manage retries and network constraints as it's very buggy.
     // i.e. we'd occasionally get BackgroundServiceStartNotAllowedException,
-    // or ForegroundServiceStartNotAllowedException, or workers getting cancelled for no reason.
-    var retries = 0
+    // or ForegroundServiceStartNotAllowedException, or "isStopped" gets set to "true"
+    // for no reason
+    var isRetried = false
     while (true) {
       try {
-        // delay needs to be part of the try block
-        if (retries > 0) exponentialBackoffDelay(retries)
-
-        // If there's no internet, wait until there is
-        val connection = waitForInternet()
-
-        // If upload requires wifi and we're not on wifi, try to switch to a non-wifi upload
-        if (!connection.wifi && upload.wifiOnly) {
-          if (UploadQueue.skipWifiOnly()) return
-          continue
-        }
-
-        // Start the upload
-        val response = okhttpUpload(
-          client, upload,
-          onProgress = { bytesSentTotal ->
-            UploadQueue.progress(bytesSentTotal)
-            EventReporter.progress(upload.id)
-          },
-          isCancelled = {
-            if (UploadQueue.current() != upload) true
-            else if (upload.wifiOnly && !checkConnection().wifi) true
-            else false
-          }
-        )
-
-        // Mark upload as completed
-        UploadQueue.complete()
-        EventReporter.success(upload.id, response)
-        return
+        // - "delay" should be within the "try" block to account for worker cancellation,
+        // which cancels the delay immediately and throws CancellationException.
+        // - Linear backoff instead of exponential. One reason for this is we retry on
+        // invalid connections. Exponential will take too long. If the server flakes and
+        // returns 500s, we don't retry but consider the request successful.
+        // This is consistent with iOS behavior. User gets notifications for
+        // these server issues and can manually retry. Since 500s are currently rare,
+        // it's likely ok. If they're too frequent, we can consider adding exponential
+        // backoff for them.
+        if (isRetried) delay(RETRY_DELAY)
+        isRetried = true
+
+        val response = upload() ?: continue
+        handleSuccess(response)
+        return@withContext Result.success()
       } catch (error: Throwable) {
-        try {
-          // If the current upload has changed, it means it was cancelled externally
-          if (UploadQueue.current() != upload) return
-
-          // Worker stopped externally. This is unexpected so we need to report errors
-          if (isStopped) return handleUnexpectedStop(error)
-
-          // High chance error was thrown due to network connection issue
-          // There's a bunch of different errors that can be thrown here,
-          // so just check if the network is connected.
-          if (!checkConnection().connected) continue
-
-          // Due to the flaky nature of networking, sometimes the network is
-          // valid but the URL is still inaccessible, so keep waiting until
-          // the URL is accessible
-          if (error is UnknownHostException) continue
-
-          // There are many errors here that come from non-existent files
-          // so we can't check using class, so we just check if the file exists
-          // If the file doesn't exist, no point retrying
-          if (!File(upload.path).exists())
-            return handleError(upload, IOException("File at path ${upload.path} does not exist"))
-
-          // Only penalize retries for other types of errors
-          retries++
-
-          // If we've retried too many times, give up
-          if (retries > upload.maxRetries) return handleError(upload, error)
-        } catch (_: Throwable) {
-          continue
-        }
+        if (checkAndHandleCancellation()) throw error
+        if (checkRetry(error)) continue
+        handleError(error)
+        throw error
       }
     }
-  }
 
-  private suspend fun exponentialBackoffDelay(retries: Int) {
-    var time = 5000L // 5 seconds
-    time = (time * (2.toDouble().pow(retries - 1))).toLong()
-    time = time.coerceAtMost(60_000L) // max 5 minutes
-    delay(time)
+    // This should never happen. Only here to satisfy the type check
+    return@withContext Result.failure()
   }
 
-  private suspend fun waitForInternet(): Connection {
-    while (true) {
-      if (UploadQueue.isEmpty()) throw CancellationException()
-      val connectivity = checkConnection()
-      if (connectivity.connected) return connectivity
-      delay(1000L)
-    }
-  }
+  private suspend fun upload(): Response? = withContext(Dispatchers.IO) {
+    val file = File(upload.path)
+    val size = file.length()
 
-  private fun handleError(upload: Upload, error: Throwable) {
-    UploadQueue.pop()
-    EventReporter.error(upload.id, error)
-  }
+    // Register progress asap so the total progress is accurate
+    // This needs to happen before the semaphore wait
+    handleProgress(0, size)
 
-  private fun handleUnexpectedStop(error: Throwable) {
-    val stopReason =
-      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) this.stopReason else "unknown"
+    // Don't bother to run on an invalid network
+    if (!validateAndReportConnectivity()) return@withContext null
 
-    val error =
-      CancellationException("Worker stopped due to: $stopReason. Original error: ${error.message}")
+    // wait for its turn to run
+    semaphore.acquire()
+
+    try {
+      val response = okhttpUpload(client, upload, file) { progress ->
+        launch { handleProgress(progress, size) }
+      }
 
-    while (!UploadQueue.isEmpty()) {
-      val upload = UploadQueue.pop()
-      EventReporter.error(upload.id, error)
+      handleProgress(size, size)
+      return@withContext response
+    }
+    // don't catch, propagate error up
+    finally {
+      semaphore.release()
     }
   }
 
-  private fun handleUnableToStartForeground(error: Throwable) {
-    val error =
-      Error("Failed to start foreground service. Original error: ${error.message}")
-
-    while (!UploadQueue.isEmpty()) {
-      val upload = UploadQueue.pop()
-      EventReporter.error(upload.id, error)
-    }
+  private suspend fun handleProgress(bytesSentTotal: Long, fileSize: Long) {
+    UploadProgress.set(context, upload.id, bytesSentTotal, fileSize)
+    EventReporter.progress(upload.id, bytesSentTotal, fileSize)
+    setForeground(getForegroundInfo())
   }
 
+  private fun handleSuccess(response: Response) {
+    UploadProgress.scheduleClearing(context)
+    EventReporter.success(upload.id, response)
+  }
 
-  private fun startNotificationUpdateJob() = CoroutineScope(Dispatchers.IO).launch {
-    while (true) {
-      try {
-        delay(1000L)
+  private fun handleError(error: Throwable) {
+    UploadProgress.remove(context, upload.id)
+    UploadProgress.scheduleClearing(context)
+    EventReporter.error(upload.id, error)
+  }
 
-        val connection = checkConnection()
+  // Check if cancelled by user or new worker with same ID
+  // Worker won't rerun, perform teardown
+  private fun checkAndHandleCancellation(): Boolean {
+    if (!isStopped) return false
 
-        val notificationConnectivity =
-          if (!connection.connected) NotificationConnectivity.NoInternet
-          else if (UploadQueue.isAllWifiOnly() && !connection.wifi) NotificationConnectivity.NoWifi
-          else NotificationConnectivity.Ok
+    UploadProgress.remove(context, upload.id)
+    UploadProgress.scheduleClearing(context)
+    EventReporter.cancelled(upload.id)
+    return true
+  }
 
-        val (id, notification) = buildNotification(context, notificationConnectivity)
-        notificationManager.notify(id, notification)
-      } catch (error: Throwable) {
-        if (isStopped) return@launch
-        EventReporter.globalError("UploadWorker.updateNotification", error)
+  /** @return whether to retry */
+  private suspend fun checkRetry(error: Throwable): Boolean {
+    var unlimitedRetry = false
+
+    // Error was thrown due to unmet network preferences.
+    // Also happens every time you switch from one network to any other
+    if (!validateAndReportConnectivity()) unlimitedRetry = true
+    // Due to the flaky nature of networking, sometimes the network is
+    // valid but the URL is still inaccessible, so keep waiting until
+    // the URL is accessible
+    else if (error is UnknownHostException) unlimitedRetry = true
+    // There are many IOExceptions that only differ by messages,
+    // so we can't check using class, but theoretically,
+    // only the one caused by file not existing should stop the retry.
+    // The rest should be related to flaky network or flaky file I/O,
+    // where we can retry without limit.
+    else if (error is IOException) {
+      try {
+        if (!File(upload.path).exists()) return false
+        unlimitedRetry = true
+      } catch (_: Throwable) {
+        // read file error, can't do anything but retry
+        unlimitedRetry = false
       }
     }
+
+    retries = if (unlimitedRetry) 0 else retries + 1
+    return retries <= upload.maxRetries
   }
 
+  // Checks connection and alerts connection issues
+  private suspend fun validateAndReportConnectivity(): Boolean {
+    this.connectivity = validateConnectivity(context, upload.wifiOnly)
+    // alert connectivity mode
+    setForeground(getForegroundInfo())
+    return this.connectivity == Connectivity.Ok
+  }
 
   // builds the notification required to enable Foreground mode
   override suspend fun getForegroundInfo(): ForegroundInfo {
-    val (id, notification) = buildNotification(context, NotificationConnectivity.Ok)
+    // All workers share the same notification that shows the total progress
+    val id = upload.notificationId.hashCode()
+    val channel = upload.notificationChannel
+    val progress = UploadProgress.total(context)
+    val progress2Decimals = "%.2f".format(progress)
+    val title = when (connectivity) {
+      Connectivity.NoWifi -> upload.notificationTitleNoWifi
+      Connectivity.NoInternet -> upload.notificationTitleNoInternet
+      Connectivity.Ok -> upload.notificationTitle
+    }
+
+    // Custom layout for progress notification.
+    // The default hides the % text. This one shows it on the right,
+    // like most examples in various docs.
+    val content = RemoteViews(context.packageName, R.layout.notification)
+    content.setTextViewText(R.id.notification_title, title)
+    content.setTextViewText(R.id.notification_progress, "${progress2Decimals}%")
+    content.setProgressBar(R.id.notification_progress_bar, 100, progress.toInt(), false)
+
+    val notification = NotificationCompat.Builder(context, channel).run {
+      // Starting Android 12, the notification shows up with a confusing delay of 10s.
+      // This fixes that delay.
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S)
+        foregroundServiceBehavior = Notification.FOREGROUND_SERVICE_IMMEDIATE
+
+      // Required by android. Here we use the system's default upload icon
+      setSmallIcon(android.R.drawable.stat_sys_upload)
+      // These prevent the notification from being force-dismissed or dismissed when pressed
+      setOngoing(true)
+      setAutoCancel(false)
+      // These help show the same custom content when the notification collapses and expands
+      setCustomContentView(content)
+      setCustomBigContentView(content)
+      // opens the app when the notification is pressed
+      setContentIntent(openAppIntent(context))
+      build()
+    }
 
     // Starting Android 14, FOREGROUND_SERVICE_TYPE_DATA_SYNC is mandatory, otherwise app will crash
     return if (Build.VERSION.SDK_INT > Build.VERSION_CODES.TIRAMISU)
@@ -230,21 +255,30 @@ class UploadWorker(private val context: Context, params: WorkerParameters) :
     else
       ForegroundInfo(id, notification)
   }
+}
 
-  private fun checkConnection(): Connection {
-    val network = connectivityManager.activeNetwork
-    val capabilities = connectivityManager.getNetworkCapabilities(network)
-    val connected = capabilities?.hasCapability(NET_CAPABILITY_VALIDATED) == true
-    val wifi = capabilities?.hasTransport(TRANSPORT_WIFI) == true
-
-    return Connection(wifi = wifi, connected = connected)
-  }
+// This is outside and synchronized to ensure consistent status across workers
+@Synchronized
+private fun validateConnectivity(context: Context, wifiOnly: Boolean): Connectivity {
+  val manager = context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
+  val network = manager.activeNetwork
+  val capabilities = manager.getNetworkCapabilities(network)
 
+  val hasInternet = capabilities?.hasCapability(NET_CAPABILITY_VALIDATED) == true
 
-  val notificationManager: NotificationManager
-    get() = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+  // not wifiOnly, return early
+  if (!wifiOnly) return if (hasInternet) Connectivity.Ok else Connectivity.NoInternet
 
-  val connectivityManager: ConnectivityManager
-    get() = context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
+  // handle wifiOnly
+  return if (hasInternet && capabilities?.hasTransport(TRANSPORT_WIFI) == true)
+    Connectivity.Ok
+  else
+    Connectivity.NoWifi // don't return NoInternet here, more direct to request to join wifi
 }
 
+
+private fun openAppIntent(context: Context): PendingIntent? {
+  val intent = Intent(context, NotificationReceiver::class.java)
+  val flags = PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
+  return PendingIntent.getBroadcast(context, "RNFileUpload-notification".hashCode(), intent, flags)
+}
diff --git a/android/src/main/java/com/vydia/RNUploader/UploaderModule.kt b/android/src/main/java/com/vydia/RNUploader/UploaderModule.kt
index 850cf98f..0b6db02b 100644
--- a/android/src/main/java/com/vydia/RNUploader/UploaderModule.kt
+++ b/android/src/main/java/com/vydia/RNUploader/UploaderModule.kt
@@ -4,14 +4,9 @@ import android.util.Log
 import androidx.work.ExistingWorkPolicy
 import androidx.work.OneTimeWorkRequestBuilder
 import androidx.work.WorkManager
-import com.facebook.react.bridge.Promise
-import com.facebook.react.bridge.ReactApplicationContext
-import com.facebook.react.bridge.ReactContextBaseJavaModule
-import com.facebook.react.bridge.ReactMethod
-import com.facebook.react.bridge.ReadableMap
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.launch
+import androidx.work.workDataOf
+import com.facebook.react.bridge.*
+import com.google.gson.Gson
 
 
 class UploaderModule(context: ReactApplicationContext) :
@@ -19,7 +14,7 @@ class UploaderModule(context: ReactApplicationContext) :
 
   companion object {
     const val TAG = "RNFileUploader.UploaderModule"
-    const val WORKER_ID = "RNFileUploader"
+    const val WORKER_TAG = "RNFileUploader"
     var reactContext: ReactApplicationContext? = null
       private set
   }
@@ -28,28 +23,15 @@ class UploaderModule(context: ReactApplicationContext) :
 
   init {
     reactContext = context
+    // workers may be killed abruptly for whatever reasons,
+    // so they might not have had a chance to clear the progress data.
+    UploadProgress.clearIfNeeded(context)
   }
 
 
   override fun getName(): String = "RNFileUploader"
 
 
-  @ReactMethod
-  fun initialize(opts: ReadableMap, promise: Promise) =
-    CoroutineScope(Dispatchers.IO).launch {
-      try {
-        NotificationConfigs.update(opts)
-        promise.resolve(true)
-      } catch (exc: Throwable) {
-        if (exc !is MissingOptionException) {
-          exc.printStackTrace()
-          Log.e(TAG, exc.message, exc)
-        }
-        promise.reject(exc)
-      }
-    }
-
-
   /*
    * Starts a file upload.
    * Returns a promise with the string ID of the upload.
@@ -57,19 +39,10 @@ class UploaderModule(context: ReactApplicationContext) :
   @ReactMethod
   fun startUpload(rawOptions: ReadableMap, promise: Promise) {
     try {
-      val upload = Upload.fromRawOptions(rawOptions)
-      UploadQueue.add(upload)
-
-      val request = OneTimeWorkRequestBuilder<UploadWorker>().build()
-
-      // TODO check if cancelling and starting will keep the queue
-      workManager
-        .beginUniqueWork(WORKER_ID, ExistingWorkPolicy.KEEP, request)
-        .enqueue()
-
-      promise.resolve(upload.id)
+      val id = startUpload(rawOptions)
+      promise.resolve(id)
     } catch (exc: Throwable) {
-      if (exc !is MissingOptionException) {
+      if (exc !is Upload.MissingOptionException) {
         exc.printStackTrace()
         Log.e(TAG, exc.message, exc)
       }
@@ -77,6 +50,30 @@ class UploaderModule(context: ReactApplicationContext) :
     }
   }
 
+  /**
+   * @return whether the upload was started
+   */
+  private fun startUpload(options: ReadableMap): String {
+    val upload = Upload.fromReadableMap(options)
+    val data = Gson().toJson(upload)
+
+    val request = OneTimeWorkRequestBuilder<UploadWorker>()
+      .addTag(WORKER_TAG)
+      .setInputData(workDataOf(UploadWorker.Input.Params.name to data))
+      .build()
+
+    workManager
+      // Using KEEP policy to prevent it from cancelling the work if it's already running.
+      // Otherwise, it will emit "cancelled" and then go on to emit "progress" events,
+      // which is confusing and quite difficult to manage. "cancelled" should be reserved for
+      // when the user explicitly cancels the upload.
+      .beginUniqueWork(upload.id, ExistingWorkPolicy.KEEP, request)
+      .enqueue()
+
+    return upload.id
+  }
+
+
   /*
    * Cancels file upload
    * Accepts upload ID as a first argument, this upload will be cancelled
@@ -85,8 +82,7 @@ class UploaderModule(context: ReactApplicationContext) :
   @ReactMethod
   fun cancelUpload(uploadId: String, promise: Promise) {
     try {
-      UploadQueue.cancel(uploadId)
-      EventReporter.cancelled(uploadId)
+      workManager.cancelUniqueWork(uploadId)
       promise.resolve(true)
     } catch (exc: Throwable) {
       exc.printStackTrace()
@@ -95,16 +91,14 @@ class UploaderModule(context: ReactApplicationContext) :
     }
   }
 
+
   /*
    * Cancels all file uploads
    */
   @ReactMethod
   fun stopAllUploads(promise: Promise) {
     try {
-      while (!UploadQueue.isEmpty()) {
-        val upload = UploadQueue.pop()
-        EventReporter.cancelled(upload.id)
-      }
+      workManager.cancelAllWorkByTag(WORKER_TAG)
       promise.resolve(true)
     } catch (exc: Throwable) {
       exc.printStackTrace()
@@ -113,4 +107,6 @@ class UploaderModule(context: ReactApplicationContext) :
     }
   }
 
+
 }
+
diff --git a/android/src/main/java/com/vydia/RNUploader2/EventReporter.kt b/android/src/main/java/com/vydia/RNUploader2/EventReporter.kt
new file mode 100644
index 00000000..9c36cea9
--- /dev/null
+++ b/android/src/main/java/com/vydia/RNUploader2/EventReporter.kt
@@ -0,0 +1,67 @@
+package com.vydia.RNUploader2
+
+import android.util.Log
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.modules.core.DeviceEventManagerModule.RCTDeviceEventEmitter
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+
+// Sends events to React Native
+class EventReporter {
+  companion object {
+    private const val TAG = "UploadReceiver"
+    fun cancelled(uploadId: String) =
+      sendEvent("cancelled", Arguments.createMap().apply {
+        putString("id", uploadId)
+      })
+
+    fun error(uploadId: String, exception: Throwable) =
+      sendEvent("error", Arguments.createMap().apply {
+        putString("id", uploadId)
+        putString("error", exception.message ?: "Unknown exception")
+      })
+
+    // TODO expose via JS
+    fun globalError(origin: String, exception: Throwable) =
+      sendEvent("globalError", Arguments.createMap().apply {
+        putString("origin", origin)
+        putString("error", exception.message ?: "Unknown exception")
+      })
+
+    fun success(uploadId: String, response: UploadResponse) =
+      CoroutineScope(Dispatchers.IO).launch {
+        sendEvent("completed", Arguments.createMap().apply {
+          putString("id", uploadId)
+          putInt("responseCode", response.statusCode)
+          putString("responseBody", response.body)
+          putMap("responseHeaders", Arguments.makeNativeMap(response.headers))
+        })
+      }
+
+    fun progress(uploadId: String) =
+      sendEvent("progress", Arguments.createMap().apply {
+        putString("id", uploadId)
+        putDouble("progress", UploadQueue.progressPercentage().toDouble())
+      })
+
+    fun notification() = sendEvent("notification")
+
+    /** Sends an event to the JS module */
+    private fun sendEvent(eventName: String, params: WritableMap = Arguments.createMap()) {
+      val reactContext = UploaderModule2.reactContext ?: return
+
+      // Right after JS reloads, react instance might not be available yet
+      if (!reactContext.hasActiveReactInstance()) return
+
+      try {
+        val jsModule = reactContext.getJSModule(RCTDeviceEventEmitter::class.java)
+        jsModule.emit("RNFileUploader-$eventName", params)
+      } catch (exc: Throwable) {
+        Log.e(TAG, "sendEvent() failed", exc)
+      }
+    }
+  }
+
+}
diff --git a/android/src/main/java/com/vydia/RNUploader/NotificationConfigs.kt b/android/src/main/java/com/vydia/RNUploader2/NotificationConfigs.kt
similarity index 97%
rename from android/src/main/java/com/vydia/RNUploader/NotificationConfigs.kt
rename to android/src/main/java/com/vydia/RNUploader2/NotificationConfigs.kt
index 4d03be12..b374e840 100644
--- a/android/src/main/java/com/vydia/RNUploader/NotificationConfigs.kt
+++ b/android/src/main/java/com/vydia/RNUploader2/NotificationConfigs.kt
@@ -1,4 +1,4 @@
-package com.vydia.RNUploader
+package com.vydia.RNUploader2
 
 import com.facebook.react.bridge.ReadableMap
 
diff --git a/android/src/main/java/com/vydia/RNUploader2/NotificationReceiver.kt b/android/src/main/java/com/vydia/RNUploader2/NotificationReceiver.kt
new file mode 100644
index 00000000..c10c8e23
--- /dev/null
+++ b/android/src/main/java/com/vydia/RNUploader2/NotificationReceiver.kt
@@ -0,0 +1,17 @@
+package com.vydia.RNUploader2
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+
+// there's no way to directly open the app from the notification without reloading it,
+// so we use a BroadcastReceiver to listen to the notification intent
+class NotificationReceiver : BroadcastReceiver() {
+  override fun onReceive(context: Context?, intent: Intent?) {
+    context ?: return
+    val packageName = context.packageName
+    val launchIntent = context.packageManager.getLaunchIntentForPackage(packageName)
+    context.startActivity(launchIntent)
+    EventReporter.notification()
+  }
+}
diff --git a/android/src/main/java/com/vydia/RNUploader2/Upload.kt b/android/src/main/java/com/vydia/RNUploader2/Upload.kt
new file mode 100644
index 00000000..7ee60cb9
--- /dev/null
+++ b/android/src/main/java/com/vydia/RNUploader2/Upload.kt
@@ -0,0 +1,40 @@
+package com.vydia.RNUploader2
+
+import com.facebook.react.bridge.ReadableMap
+import java.util.UUID
+
+// Data model of a single upload
+// Can be created from RN's ReadableMap
+// Can be used for JSON deserialization
+data class Upload(
+  val id: String,
+  val url: String,
+  val path: String,
+  val method: String,
+  val maxRetries: Int,
+  val wifiOnly: Boolean,
+  val headers: Map<String, String>,
+) {
+  // Progress tracking properties
+  var bytesUploaded: Long = 0L
+  var size: Long = 0L
+
+  companion object {
+    fun fromRawOptions(map: ReadableMap) = Upload(
+      id = map.getString("customUploadId") ?: UUID.randomUUID().toString(),
+      url = map.getString(Upload::url.name) ?: throw MissingOptionException(Upload::url.name),
+      path = map.getString(Upload::path.name) ?: throw MissingOptionException(Upload::path.name),
+      method = map.getString(Upload::method.name) ?: "POST",
+      maxRetries = if (map.hasKey(Upload::maxRetries.name)) map.getInt(Upload::maxRetries.name) else 5,
+      wifiOnly = if (map.hasKey(Upload::wifiOnly.name)) map.getBoolean(Upload::wifiOnly.name) else false,
+      headers = map.getMap(Upload::headers.name).let { headers ->
+        if (headers == null) return@let mapOf()
+        val map = mutableMapOf<String, String>()
+        for (entry in headers.entryIterator) {
+          map[entry.key] = entry.value.toString()
+        }
+        return@let map
+      },
+    )
+  }
+}
diff --git a/android/src/main/java/com/vydia/RNUploader/UploadQueue.kt b/android/src/main/java/com/vydia/RNUploader2/UploadQueue.kt
similarity index 98%
rename from android/src/main/java/com/vydia/RNUploader/UploadQueue.kt
rename to android/src/main/java/com/vydia/RNUploader2/UploadQueue.kt
index 4f31268c..41ff9362 100644
--- a/android/src/main/java/com/vydia/RNUploader/UploadQueue.kt
+++ b/android/src/main/java/com/vydia/RNUploader2/UploadQueue.kt
@@ -1,4 +1,4 @@
-package com.vydia.RNUploader
+package com.vydia.RNUploader2
 
 import java.io.File
 import java.io.FileNotFoundException
diff --git a/android/src/main/java/com/vydia/RNUploader2/UploadUtils.kt b/android/src/main/java/com/vydia/RNUploader2/UploadUtils.kt
new file mode 100644
index 00000000..6b1eef50
--- /dev/null
+++ b/android/src/main/java/com/vydia/RNUploader2/UploadUtils.kt
@@ -0,0 +1,201 @@
+package com.vydia.RNUploader2
+
+import android.R
+import android.app.Notification
+import android.app.PendingIntent
+import android.content.Context
+import android.content.Intent
+import android.os.Build
+import android.widget.RemoteViews
+import androidx.core.app.NotificationCompat
+import kotlinx.coroutines.CancellationException
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.suspendCancellableCoroutine
+import okhttp3.Call
+import okhttp3.Callback
+import okhttp3.Headers.Companion.toHeaders
+import okhttp3.OkHttpClient
+import okhttp3.Request
+import okhttp3.RequestBody
+import okhttp3.RequestBody.Companion.asRequestBody
+import okhttp3.Response
+import okio.Buffer
+import okio.BufferedSink
+import okio.ForwardingSink
+import okio.buffer
+import java.io.File
+import java.io.IOException
+import kotlin.coroutines.resumeWithException
+
+// Throttling interval of progress reports
+private const val PROGRESS_INTERVAL = 500 // milliseconds
+
+// Data class to hold the important response information
+data class UploadResponse(
+  val statusCode: Int,
+  val statusMessage: String,
+  val headers: Map<String, String>,
+  val body: String? = null
+)
+
+// make an upload request using okhttp
+suspend fun okhttpUpload(
+  client: OkHttpClient,
+  upload: Upload,
+  onProgress: (Long) -> Unit,
+  isCancelled: () -> Boolean
+): UploadResponse =
+  suspendCancellableCoroutine { continuation ->
+    val requestBody = File(upload.path).asRequestBody()
+
+    // Throttle progress reports
+    var lastProgressReport = 0L
+    fun throttled(): Boolean {
+      val now = System.currentTimeMillis()
+      if (now - lastProgressReport < PROGRESS_INTERVAL) return true
+      lastProgressReport = now
+      return false
+    }
+
+    // Build the request
+    val request = Request.Builder()
+      .url(upload.url)
+      .headers(upload.headers.toHeaders())
+      .method(upload.method, withProgressListener(requestBody) { progress ->
+        if (!throttled()) onProgress(progress)
+      })
+      .build()
+
+    // Create the call
+    val call = client.newCall(request)
+
+    // Start a polling coroutine to check for cancellation
+    val cancellationCheck = CoroutineScope(continuation.context).launch {
+      while (!call.isCanceled()) {
+        if (isCancelled()) {
+          call.cancel()
+          continuation.resumeWithException(CancellationException("Upload cancelled externally"))
+          break
+        }
+        delay(100) // Poll every 100ms
+      }
+    }
+
+    // cancel everything if the coroutine is cancelled
+    continuation.invokeOnCancellation {
+      call.cancel()
+      cancellationCheck.cancel()
+    }
+
+    // enqueue the call and add the callbacks
+    call.enqueue(object : Callback {
+      override fun onFailure(call: Call, e: IOException) {
+        cancellationCheck.cancel()
+        if (isCancelled()) return
+        continuation.resumeWithException(e)
+      }
+
+      override fun onResponse(call: Call, response: Response) {
+        cancellationCheck.cancel()
+        response.use { // Automatically closes the response
+          if (isCancelled()) return
+
+          val uploadResponse = UploadResponse(
+            statusCode = response.code,
+            statusMessage = response.message,
+            headers = response.headers.toMap(),
+            body = response.body.string().let {
+              it.ifBlank { response.message }
+            }
+          )
+          continuation.resumeWith(Result.success(uploadResponse))
+        }
+      }
+    })
+  }
+
+// create a request body that allows us to listen to progress.
+// okhttp has no built-in way of reporting progress
+private fun withProgressListener(
+  body: RequestBody,
+  onProgress: (Long) -> Unit
+) = object : RequestBody() {
+  override fun contentType() = body.contentType()
+  override fun contentLength() = body.contentLength()
+  override fun writeTo(sink: BufferedSink) {
+    val countingSink = object : ForwardingSink(sink) {
+      var bytesWritten = 0L
+
+      override fun write(source: Buffer, byteCount: Long) {
+        super.write(source, byteCount)
+        bytesWritten += byteCount
+        onProgress(bytesWritten)
+      }
+    }
+
+    val bufferedSink = countingSink.buffer()
+    body.writeTo(bufferedSink)
+    bufferedSink.flush()
+  }
+}
+
+class MissingOptionException(optionName: String) :
+  IllegalArgumentException("Missing '$optionName'")
+
+
+data class Connection(val wifi: Boolean, val connected: Boolean)
+
+enum class NotificationConnectivity {
+  NoWifi, NoInternet, Ok
+}
+
+fun buildNotification(
+  context: Context,
+  connectivity: NotificationConnectivity
+): Pair<Int, Notification> {
+  val progress = UploadQueue.progressPercentage()
+  val progress2Decimals = "%.2f".format(progress)
+  val title = when (connectivity) {
+    NotificationConnectivity.NoWifi -> NotificationConfigs.titleNoWifi
+    NotificationConnectivity.NoInternet -> NotificationConfigs.titleNoInternet
+    NotificationConnectivity.Ok -> NotificationConfigs.title
+  }
+
+  // Custom layout for progress notification.
+  // The default hides the % text. This one shows it on the right,
+  // like most examples in various docs.
+  val content = RemoteViews(context.packageName, R.layout.notification)
+  content.setTextViewText(R.id.notification_title, title)
+  content.setTextViewText(R.id.notification_progress, "${progress2Decimals}%")
+  content.setProgressBar(R.id.notification_progress_bar, 100, progress.toInt(), false)
+
+  val notification = NotificationCompat.Builder(context, NotificationConfigs.channel).run {
+    // Starting Android 12, the notification shows up with a confusing delay of 10s.
+    // This fixes that delay.
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S)
+      NotificationCompat.Builder.setForegroundServiceBehavior =
+        Notification.FOREGROUND_SERVICE_IMMEDIATE
+
+    // Required by android. Here we use the system's default upload icon
+    setSmallIcon(R.drawable.stat_sys_upload)
+    // These prevent the notification from being force-dismissed or dismissed when pressed
+    setOngoing(true)
+    setAutoCancel(false)
+    // These help show the same custom content when the notification collapses and expands
+    setCustomContentView(content)
+    setCustomBigContentView(content)
+    // opens the app when the notification is pressed
+    setContentIntent(openAppIntent(context))
+    build()
+  }
+
+  return Pair(NotificationConfigs.id, notification)
+}
+
+private fun openAppIntent(context: Context): PendingIntent? {
+  val intent = Intent(context, NotificationReceiver::class.java)
+  val flags = PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
+  return PendingIntent.getBroadcast(context, "RNFileUpload-notification".hashCode(), intent, flags)
+}
diff --git a/android/src/main/java/com/vydia/RNUploader2/UploadWorker.kt b/android/src/main/java/com/vydia/RNUploader2/UploadWorker.kt
new file mode 100644
index 00000000..2bfe30ca
--- /dev/null
+++ b/android/src/main/java/com/vydia/RNUploader2/UploadWorker.kt
@@ -0,0 +1,250 @@
+package com.vydia.RNUploader2
+
+import android.app.NotificationManager
+import android.content.Context
+import android.content.pm.ServiceInfo
+import android.net.ConnectivityManager
+import android.net.NetworkCapabilities.NET_CAPABILITY_VALIDATED
+import android.net.NetworkCapabilities.TRANSPORT_WIFI
+import android.os.Build
+import androidx.work.CoroutineWorker
+import androidx.work.ForegroundInfo
+import androidx.work.WorkerParameters
+import kotlinx.coroutines.CancellationException
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+import okhttp3.OkHttpClient
+import java.io.File
+import java.io.IOException
+import java.net.UnknownHostException
+import java.util.concurrent.TimeUnit
+import kotlin.math.pow
+
+
+// Max total time for a single request to complete
+// This is 24hrs so plenty of time for large uploads
+// Worst case is the time maxes out and the upload gets restarted.
+// Not using unlimited time to prevent unexpected behaviors.
+private const val REQUEST_TIMEOUT = 24L
+private val REQUEST_TIMEOUT_UNIT = TimeUnit.HOURS
+
+
+// Use Okhttp as it provides the most standard behaviors even though it's not coroutine friendly
+private val client = OkHttpClient.Builder()
+  .callTimeout(REQUEST_TIMEOUT, REQUEST_TIMEOUT_UNIT)
+  .build()
+
+class UploadWorker(private val context: Context, params: WorkerParameters) :
+  CoroutineWorker(context, params) {
+
+  override suspend fun doWork(): Result = withContext(Dispatchers.IO) {
+    try {
+      // `setForeground` is recommended for long-running workers.
+      // Foreground mode helps prioritize the worker, reducing the risk
+      // of it being killed during low memory or Doze/App Standby situations.
+      // ⚠️ This should be called in the foreground
+      setForeground(getForegroundInfo())
+    } catch (error: Throwable) {
+      // If we fail to start foreground service, the worker will be stopped shortly after,
+      // which makes it impossible to report errors for all uploads in the queue.
+      // If we report errors here, the client can decide when to retry.
+      handleUnableToStartForeground(error)
+      throw error
+    }
+
+    // Update notification periodically
+    var notificationJob: Job? = null
+    try {
+      notificationJob = startNotificationUpdateJob()
+    } catch (error: Throwable) {
+      // Should not block the worker if notification job setup fails
+      EventReporter.globalError(
+        "UploadWorker.startNotificationUpdateJob",
+        Error("Failed to start notification job: ${error.message}")
+      )
+    }
+
+    try {
+      // Keep processing uploads until the queue is empty
+      while (UploadQueue.current() != null) uploadCurrent()
+
+      return@withContext Result.success()
+    } finally {
+      notificationJob?.cancel() // Cancel the notification updates when work is done
+    }
+  }
+
+  private suspend fun uploadCurrent() {
+    val upload = UploadQueue.current() ?: return
+
+    // We don't let WorkManager manage retries and network constraints as it's very buggy.
+    // i.e. we'd occasionally get BackgroundServiceStartNotAllowedException,
+    // or ForegroundServiceStartNotAllowedException, or workers getting cancelled for no reason.
+    var retries = 0
+    while (true) {
+      try {
+        // delay needs to be part of the try block
+        if (retries > 0) exponentialBackoffDelay(retries)
+
+        // If there's no internet, wait until there is
+        val connection = waitForInternet()
+
+        // If upload requires wifi and we're not on wifi, try to switch to a non-wifi upload
+        if (!connection.wifi && upload.wifiOnly) {
+          if (UploadQueue.skipWifiOnly()) return
+          continue
+        }
+
+        // Start the upload
+        val response = okhttpUpload(
+          client, upload,
+          onProgress = { bytesSentTotal ->
+            UploadQueue.progress(bytesSentTotal)
+            EventReporter.progress(upload.id)
+          },
+          isCancelled = {
+            if (UploadQueue.current() != upload) true
+            else if (upload.wifiOnly && !checkConnection().wifi) true
+            else false
+          }
+        )
+
+        // Mark upload as completed
+        UploadQueue.complete()
+        EventReporter.success(upload.id, response)
+        return
+      } catch (error: Throwable) {
+        try {
+          // If the current upload has changed, it means it was cancelled externally
+          if (UploadQueue.current() != upload) return
+
+          // Worker stopped externally. This is unexpected so we need to report errors
+          if (isStopped) return handleUnexpectedStop(error)
+
+          // High chance error was thrown due to network connection issue
+          // There's a bunch of different errors that can be thrown here,
+          // so just check if the network is connected.
+          if (!checkConnection().connected) continue
+
+          // Due to the flaky nature of networking, sometimes the network is
+          // valid but the URL is still inaccessible, so keep waiting until
+          // the URL is accessible
+          if (error is UnknownHostException) continue
+
+          // There are many errors here that come from non-existent files
+          // so we can't check using class, so we just check if the file exists
+          // If the file doesn't exist, no point retrying
+          if (!File(upload.path).exists())
+            return handleError(upload, IOException("File at path ${upload.path} does not exist"))
+
+          // Only penalize retries for other types of errors
+          retries++
+
+          // If we've retried too many times, give up
+          if (retries > upload.maxRetries) return handleError(upload, error)
+        } catch (_: Throwable) {
+          continue
+        }
+      }
+    }
+  }
+
+  private suspend fun exponentialBackoffDelay(retries: Int) {
+    var time = 5000L // 5 seconds
+    time = (time * (2.toDouble().pow(retries - 1))).toLong()
+    time = time.coerceAtMost(60_000L) // max 5 minutes
+    delay(time)
+  }
+
+  private suspend fun waitForInternet(): Connection {
+    while (true) {
+      if (UploadQueue.isEmpty()) throw CancellationException()
+      val connectivity = checkConnection()
+      if (connectivity.connected) return connectivity
+      delay(1000L)
+    }
+  }
+
+  private fun handleError(upload: Upload, error: Throwable) {
+    UploadQueue.pop()
+    EventReporter.error(upload.id, error)
+  }
+
+  private fun handleUnexpectedStop(error: Throwable) {
+    val stopReason =
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) this.stopReason else "unknown"
+
+    val error =
+      CancellationException("Worker stopped due to: $stopReason. Original error: ${error.message}")
+
+    while (!UploadQueue.isEmpty()) {
+      val upload = UploadQueue.pop()
+      EventReporter.error(upload.id, error)
+    }
+  }
+
+  private fun handleUnableToStartForeground(error: Throwable) {
+    val error =
+      Error("Failed to start foreground service. Original error: ${error.message}")
+
+    while (!UploadQueue.isEmpty()) {
+      val upload = UploadQueue.pop()
+      EventReporter.error(upload.id, error)
+    }
+  }
+
+
+  private fun startNotificationUpdateJob() = CoroutineScope(Dispatchers.IO).launch {
+    while (true) {
+      try {
+        delay(1000L)
+
+        val connection = checkConnection()
+
+        val notificationConnectivity =
+          if (!connection.connected) NotificationConnectivity.NoInternet
+          else if (UploadQueue.isAllWifiOnly() && !connection.wifi) NotificationConnectivity.NoWifi
+          else NotificationConnectivity.Ok
+
+        val (id, notification) = buildNotification(context, notificationConnectivity)
+        notificationManager.notify(id, notification)
+      } catch (error: Throwable) {
+        if (isStopped) return@launch
+        EventReporter.globalError("UploadWorker.updateNotification", error)
+      }
+    }
+  }
+
+
+  // builds the notification required to enable Foreground mode
+  override suspend fun getForegroundInfo(): ForegroundInfo {
+    val (id, notification) = buildNotification(context, NotificationConnectivity.Ok)
+
+    // Starting Android 14, FOREGROUND_SERVICE_TYPE_DATA_SYNC is mandatory, otherwise app will crash
+    return if (Build.VERSION.SDK_INT > Build.VERSION_CODES.TIRAMISU)
+      ForegroundInfo(id, notification, ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC)
+    else
+      ForegroundInfo(id, notification)
+  }
+
+  private fun checkConnection(): Connection {
+    val network = connectivityManager.activeNetwork
+    val capabilities = connectivityManager.getNetworkCapabilities(network)
+    val connected = capabilities?.hasCapability(NET_CAPABILITY_VALIDATED) == true
+    val wifi = capabilities?.hasTransport(TRANSPORT_WIFI) == true
+
+    return Connection(wifi = wifi, connected = connected)
+  }
+
+
+  val notificationManager: NotificationManager
+    get() = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+
+  val connectivityManager: ConnectivityManager
+    get() = context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
+}
+
diff --git a/android/src/main/java/com/vydia/RNUploader2/Uploader2ReactPackage.java b/android/src/main/java/com/vydia/RNUploader2/Uploader2ReactPackage.java
new file mode 100644
index 00000000..a7e2cf44
--- /dev/null
+++ b/android/src/main/java/com/vydia/RNUploader2/Uploader2ReactPackage.java
@@ -0,0 +1,35 @@
+package com.vydia.RNUploader2;
+
+import com.facebook.react.ReactPackage;
+import com.facebook.react.bridge.JavaScriptModule;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.uimanager.ViewManager;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * Created by stephen on 12/8/16.
+ */
+public class Uploader2ReactPackage implements ReactPackage {
+
+    // Deprecated in RN 0.47, @todo remove after < 0.47 support remove
+    public List<Class<? extends JavaScriptModule>> createJSModules() {
+        return Collections.emptyList();
+    }
+
+    @Override
+    public List<ViewManager> createViewManagers(ReactApplicationContext reactContext) {
+        return Collections.emptyList();
+    }
+
+    @Override
+    public List<NativeModule> createNativeModules(
+            ReactApplicationContext reactContext) {
+        List<NativeModule> modules = new ArrayList<>();
+        modules.add(new UploaderModule2(reactContext));
+        return modules;
+    }
+}
diff --git a/android/src/main/java/com/vydia/RNUploader2/UploaderModule2.kt b/android/src/main/java/com/vydia/RNUploader2/UploaderModule2.kt
new file mode 100644
index 00000000..0957c202
--- /dev/null
+++ b/android/src/main/java/com/vydia/RNUploader2/UploaderModule2.kt
@@ -0,0 +1,119 @@
+package com.vydia.RNUploader2
+
+import android.util.Log
+import androidx.work.ExistingWorkPolicy
+import androidx.work.OneTimeWorkRequestBuilder
+import androidx.work.WorkManager
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.ReadableMap
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+
+
+class UploaderModule2(context: ReactApplicationContext) :
+  ReactContextBaseJavaModule(context) {
+
+  companion object {
+    const val TAG = "RNFileUploader.UploaderModule"
+    const val WORKER_ID = "RNFileUploader"
+    var reactContext: ReactApplicationContext? = null
+      private set
+  }
+
+  private val workManager = WorkManager.getInstance(context)
+
+  init {
+    reactContext = context
+  }
+
+
+  override fun getName(): String = "RNFileUploader2"
+
+
+  @ReactMethod
+  fun initialize(opts: ReadableMap, promise: Promise) =
+    CoroutineScope(Dispatchers.IO).launch {
+      try {
+        NotificationConfigs.update(opts)
+        promise.resolve(true)
+      } catch (exc: Throwable) {
+        if (exc !is MissingOptionException) {
+          exc.printStackTrace()
+          Log.e(TAG, exc.message, exc)
+        }
+        promise.reject(exc)
+      }
+    }
+
+
+  /*
+   * Starts a file upload.
+   * Returns a promise with the string ID of the upload.
+   */
+  @ReactMethod
+  fun startUpload(rawOptions: ReadableMap, promise: Promise) {
+    try {
+      val upload = Upload.fromRawOptions(rawOptions)
+      UploadQueue.add(upload)
+
+      val request = OneTimeWorkRequestBuilder<UploadWorker>().build()
+
+      // TODO check if cancelling and starting will keep the queue
+      workManager
+        .beginUniqueWork(WORKER_ID, ExistingWorkPolicy.KEEP, request)
+        .enqueue()
+
+      // TODO retry in a bit if the id has never been started and then clear the map
+      //  don't use the upload ID since it can be duplicated
+
+      promise.resolve(upload.id)
+    } catch (exc: Throwable) {
+      if (exc !is MissingOptionException) {
+        exc.printStackTrace()
+        Log.e(TAG, exc.message, exc)
+      }
+      promise.reject(exc)
+    }
+  }
+
+  /*
+   * Cancels file upload
+   * Accepts upload ID as a first argument, this upload will be cancelled
+   * Event "cancelled" will be fired when upload is cancelled.
+   */
+  @ReactMethod
+  fun cancelUpload(uploadId: String, promise: Promise) {
+    try {
+      UploadQueue.cancel(uploadId)
+      EventReporter.cancelled(uploadId)
+      promise.resolve(true)
+    } catch (exc: Throwable) {
+      exc.printStackTrace()
+      Log.e(TAG, exc.message, exc)
+      promise.reject(exc)
+    }
+  }
+
+  /*
+   * Cancels all file uploads
+   */
+  @ReactMethod
+  fun stopAllUploads(promise: Promise) {
+    try {
+      while (!UploadQueue.isEmpty()) {
+        val upload = UploadQueue.pop()
+        EventReporter.cancelled(upload.id)
+      }
+      promise.resolve(true)
+    } catch (exc: Throwable) {
+      exc.printStackTrace()
+      Log.e(TAG, exc.message, exc)
+      promise.reject(exc)
+    }
+  }
+
+}