@capgo/capacitor-uploader 0.0.1

package/CapgoCapacitorUploader.podspec

@@ -0,0 +1,17 @@
+require 'json'
+
+package = JSON.parse(File.read(File.join(__dir__, 'package.json')))
+
+Pod::Spec.new do |s|
+  s.name = 'CapgoCapacitorUploader'
+  s.version = package['version']
+  s.summary = package['description']
+  s.license = package['license']
+  s.homepage = package['repository']['url']
+  s.author = package['author']
+  s.source = { :git => package['repository']['url'], :tag => s.version.to_s }
+  s.source_files = 'ios/Sources/**/*.{swift,h,m,c,cc,mm,cpp}'
+  s.ios.deployment_target  = '13.0'
+  s.dependency 'Capacitor'
+  s.swift_version = '5.1'
+end

package/Package.swift

@@ -0,0 +1,28 @@
+// swift-tools-version: 5.9
+import PackageDescription
+
+let package = Package(
+    name: "CapgoCapacitorUploader",
+    platforms: [.iOS(.v13)],
+    products: [
+        .library(
+            name: "CapgoCapacitorUploader",
+            targets: ["UploaderPlugin"])
+    ],
+    dependencies: [
+        .package(url: "https://github.com/ionic-team/capacitor-swift-pm.git", branch: "main")
+    ],
+    targets: [
+        .target(
+            name: "UploaderPlugin",
+            dependencies: [
+                .product(name: "Capacitor", package: "capacitor-swift-pm"),
+                .product(name: "Cordova", package: "capacitor-swift-pm")
+            ],
+            path: "ios/Sources/UploaderPlugin"),
+        .testTarget(
+            name: "UploaderPluginTests",
+            dependencies: ["UploaderPlugin"],
+            path: "ios/Tests/UploaderPluginTests")
+    ]
+)

package/README.md

@@ -0,0 +1,228 @@
+# @capgo/capacitor-uploader
+  <a href="https://capgo.app/"><img src='https://raw.githubusercontent.com/Cap-go/capgo/main/assets/capgo_banner.png' alt='Capgo - Instant updates for capacitor'/></a>
+  <div align="center">
+<h2><a href="https://capgo.app/">Check out: Capgo — Instant updates for capacitor</a></h2>
+</div>
+
+## Uploader Plugin
+
+This plugin provides a flexible way to upload natively files to various servers, including S3 with presigned URLs.
+
+WIP: this is a work in progress still not ready for use
+
+## Install
+
+```bash
+npm install @capgo/capacitor-uploader
+npx cap sync
+```
+
+## Android:
+
+Add the following to your `AndroidManifest.xml` file:
+
+```xml
+    <uses-permission android:name="android.permission.INTERNET" />
+    <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
+```
+
+## Exemple S3 upload:
+
+
+## Example S3 upload:
+
+```typescript
+import { Uploader } from '@capgo/capacitor-uploader';
+
+async function uploadToS3(filePath: string, presignedUrl: string, fields: Record<string, string>) {
+  try {
+    const { id } = await Uploader.startUpload({
+      filePath: filePath,
+      serverUrl: presignedUrl,
+      method: 'PUT',
+      parameters: fields,
+      notificationTitle: 'Uploading to S3'
+    });
+
+    console.log('Upload started with ID:', id);
+
+    // Listen for upload events
+    Uploader.addListener('events', (event: UploadEvent) => {
+      if (event.name === 'uploading') {
+        console.log(`Upload progress: ${event.payload.percent}%`);
+      } else if (event.name === 'completed') {
+        console.log('Upload completed successfully');
+      } else if (event.name === 'failed') {
+        console.error('Upload failed:', event.payload.error);
+      }
+    });
+
+  } catch (error) {
+    console.error('Failed to start upload:', error);
+  }
+}
+
+```
+
+### Exemple upload to a custom server:
+
+```typescript
+import { Uploader } from '@capgo/capacitor-uploader';
+
+async function uploadToCustomServer(filePath: string, serverUrl: string) {
+  try {
+    // Start the upload
+    const { id } = await Uploader.startUpload({
+      filePath: filePath,
+      serverUrl: serverUrl,
+      method: 'POST',
+      headers: {
+        'Authorization': 'Bearer your-auth-token-here'
+      },
+      parameters: {
+        'user_id': '12345',
+        'file_type': 'image'
+      },
+      notificationTitle: 'Uploading to Custom Server',
+      maxRetries: 3
+    });
+
+    console.log('Upload started with ID:', id);
+
+    // Listen for upload events
+    Uploader.addListener('events', (event) => {
+      switch (event.name) {
+        case 'uploading':
+          console.log(`Upload progress: ${event.payload.percent}%`);
+          break;
+        case 'completed':
+          console.log('Upload completed successfully');
+          console.log('Server response status code:', event.payload.statusCode);
+          break;
+        case 'failed':
+          console.error('Upload failed:', event.payload.error);
+          break;
+      }
+    });
+
+    // Optional: Remove the upload if needed
+    // await Uploader.removeUpload({ id: id });
+
+  } catch (error) {
+    console.error('Failed to start upload:', error);
+  }
+}
+
+// Usage
+const filePath = 'file:///path/to/your/file.jpg';
+const serverUrl = 'https://your-custom-server.com/upload';
+uploadToCustomServer(filePath, serverUrl);
+
+```
+
+## API
+
+<docgen-index>
+
+* [`startUpload(...)`](#startupload)
+* [`removeUpload(...)`](#removeupload)
+* [`addListener('events', ...)`](#addlistenerevents-)
+* [Interfaces](#interfaces)
+
+</docgen-index>
+
+<docgen-api>
+<!--Update the source file JSDoc comments and rerun docgen to update the docs below-->
+
+### startUpload(...)
+
+```typescript
+startUpload(options: uploadOption) => any
+```
+
+| Param         | Type                                                  |
+| ------------- | ----------------------------------------------------- |
+| **`options`** | <code><a href="#uploadoption">uploadOption</a></code> |
+
+**Returns:** <code>any</code>
+
+**Since:** 1.0.0
+
+--------------------
+
+
+### removeUpload(...)
+
+```typescript
+removeUpload(options: { id: string; }) => any
+```
+
+| Param         | Type                         |
+| ------------- | ---------------------------- |
+| **`options`** | <code>{ id: string; }</code> |
+
+**Returns:** <code>any</code>
+
+**Since:** 1.0.0
+
+--------------------
+
+
+### addListener('events', ...)
+
+```typescript
+addListener(eventName: 'events', listenerFunc: (state: UploadEvent) => void) => any
+```
+
+| Param              | Type                                                                    |
+| ------------------ | ----------------------------------------------------------------------- |
+| **`eventName`**    | <code>'events'</code>                                                   |
+| **`listenerFunc`** | <code>(state: <a href="#uploadevent">UploadEvent</a>) =&gt; void</code> |
+
+**Returns:** <code>any</code>
+
+**Since:** 1.0.0
+
+--------------------
+
+
+### Interfaces
+
+
+#### uploadOption
+
+| Prop                    | Type                                    | Default                  | Since |
+| ----------------------- | --------------------------------------- | ------------------------ | ----- |
+| **`filePath`**          | <code>string</code>                     |                          | 1.0.0 |
+| **`serverUrl`**         | <code>string</code>                     |                          | 1.0.0 |
+| **`notificationTitle`** | <code>number</code>                     | <code>'Uploading'</code> | 1.0.0 |
+| **`headers`**           | <code>{ [key: string]: string; }</code> |                          | 1.0.0 |
+| **`method`**            | <code>'PUT' \| 'POST'</code>            | <code>'POST'</code>      | 1.0.0 |
+| **`mimeType`**          | <code>string</code>                     |                          | 1.0.0 |
+| **`parameters`**        | <code>{ [key: string]: string; }</code> |                          | 1.0.0 |
+| **`maxRetries`**        | <code>number</code>                     |                          | 1.0.0 |
+
+
+#### UploadEvent
+
+| Prop          | Type                                                                    | Description                                  | Since |
+| ------------- | ----------------------------------------------------------------------- | -------------------------------------------- | ----- |
+| **`name`**    | <code>'uploading' \| 'completed' \| 'failed'</code>                     | Current status of upload, between 0 and 100. |       |
+| **`payload`** | <code>{ percent?: number; error?: string; statusCode?: number; }</code> |                                              | 1.0.0 |
+| **`id`**      | <code>string</code>                                                     |                                              | 1.0.0 |
+
+
+#### PluginListenerHandle
+
+| Prop         | Type                      |
+| ------------ | ------------------------- |
+| **`remove`** | <code>() =&gt; any</code> |
+
+</docgen-api>
+
+### Credits:
+
+For the inspiration and the code on ios: https://github.com/Vydia/react-native-background-upload/tree/master
+For the API definition: https://www.npmjs.com/package/cordova-plugin-background-upload-put-s3
+

package/android/build.gradle

@@ -0,0 +1,59 @@
+ext {
+    junitVersion = project.hasProperty('junitVersion') ? rootProject.ext.junitVersion : '4.13.2'
+    androidxAppCompatVersion = project.hasProperty('androidxAppCompatVersion') ? rootProject.ext.androidxAppCompatVersion : '1.6.1'
+    androidxJunitVersion = project.hasProperty('androidxJunitVersion') ? rootProject.ext.androidxJunitVersion : '1.1.5'
+    androidxEspressoCoreVersion = project.hasProperty('androidxEspressoCoreVersion') ? rootProject.ext.androidxEspressoCoreVersion : '3.5.1'
+}
+
+buildscript {
+    repositories {
+        google()
+        mavenCentral()
+    }
+    dependencies {
+        classpath 'com.android.tools.build:gradle:8.2.1'
+    }
+}
+
+apply plugin: 'com.android.library'
+
+android {
+    namespace "ee.forgr.capacitor.uploader"
+    compileSdk project.hasProperty('compileSdkVersion') ? rootProject.ext.compileSdkVersion : 34
+    defaultConfig {
+        minSdkVersion project.hasProperty('minSdkVersion') ? rootProject.ext.minSdkVersion : 22
+        targetSdkVersion project.hasProperty('targetSdkVersion') ? rootProject.ext.targetSdkVersion : 34
+        versionCode 1
+        versionName "1.0"
+        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
+    }
+    buildTypes {
+        release {
+            minifyEnabled false
+            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
+        }
+    }
+    lintOptions {
+        abortOnError false
+    }
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_17
+        targetCompatibility JavaVersion.VERSION_17
+    }
+}
+
+repositories {
+    google()
+    mavenCentral()
+}
+
+
+dependencies {
+    implementation fileTree(dir: 'libs', include: ['*.jar'])
+    implementation project(':capacitor-android')
+    implementation "androidx.appcompat:appcompat:$androidxAppCompatVersion"
+    implementation 'net.gotev:uploadservice:4.7.0'
+    testImplementation "junit:junit:$junitVersion"
+    androidTestImplementation "androidx.test.ext:junit:$androidxJunitVersion"
+    androidTestImplementation "androidx.test.espresso:espresso-core:$androidxEspressoCoreVersion"
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,33 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="ee.forgr.capacitor.uploader">
+
+    <application>
+        <service
+            android:name="net.gotev.uploadservice.UploadService"
+            android:enabled="true"
+            android:exported="false"
+            android:foregroundServiceType="dataSync">
+            <intent-filter>
+                <action android:name="android.intent.action.RUN" />
+            </intent-filter>
+        </service>
+
+        <service
+            android:name="net.gotev.uploadservice.UploadJobService"
+            android:enabled="true"
+            android:exported="false"
+            android:permission="android.permission.BIND_JOB_SERVICE">
+        </service>
+
+        <receiver
+            android:name="net.gotev.uploadservice.UploadServiceBroadcastReceiver"
+            android:enabled="true"
+            android:exported="false">
+            <intent-filter>
+                <action android:name="net.gotev.uploadservice.broadcast.status" />
+            </intent-filter>
+        </receiver>
+    </application>
+
+</manifest>

package/android/src/main/java/ee/forgr/capacitor/uploader/Uploader.java

@@ -0,0 +1,123 @@
+package ee.forgr.capacitor.uploader;
+
+import android.app.Application;
+import android.content.Context;
+import android.net.Uri;
+import android.provider.OpenableColumns;
+import android.database.Cursor;
+
+import net.gotev.uploadservice.UploadServiceConfig;
+import net.gotev.uploadservice.data.UploadNotificationConfig;
+import net.gotev.uploadservice.data.UploadNotificationStatusConfig;
+import net.gotev.uploadservice.protocols.multipart.MultipartUploadRequest;
+import net.gotev.uploadservice.observer.request.RequestObserverDelegate;
+
+import java.util.Map;
+
+public class Uploader {
+
+    private final Context context;
+    private final RequestObserverDelegate delegate;
+
+    public Uploader(Context context, RequestObserverDelegate delegate) {
+        this.context = context;
+        this.delegate = delegate;
+        initializeUploadService(context);
+    }
+
+    private void initializeUploadService(Context context) {
+        Application application = getApplication(context);
+        if (application != null) {
+            UploadServiceConfig.initialize(application, "ee.forgr.capacitor.uploader.notification_channel_id", true);
+        } else {
+            throw new IllegalStateException("Unable to get Application instance");
+        }
+    }
+
+    private Application getApplication(Context context) {
+        if (context == null) {
+            return null;
+        } else if (context instanceof Application) {
+            return (Application) context;
+        } else {
+            return getApplication(context.getApplicationContext());
+        }
+    }
+
+    public String startUpload(String filePath, String serverUrl, Map<String, String> headers, Map<String, String> parameters, 
+                            String httpMethod, String notificationTitle, int maxRetries, String mimeType) throws Exception {
+        UploadNotificationConfig notificationConfig = createNotificationConfig(notificationTitle);
+
+        MultipartUploadRequest request = new MultipartUploadRequest(context, serverUrl)
+            .setMethod(httpMethod)
+            .addFileToUpload(filePath, "file", mimeType) // Updated this line
+            .setNotificationConfig((ctx, uploadId) -> notificationConfig)
+            .setMaxRetries(maxRetries);
+
+        // Add headers
+        for (Map.Entry<String, String> entry : headers.entrySet()) {
+            request.addHeader(entry.getKey(), entry.getValue());
+        }
+
+        // Add parameters
+        for (Map.Entry<String, String> entry : parameters.entrySet()) {
+            request.addParameter(entry.getKey(), entry.getValue());
+        }
+
+        // Set file name if it's a content URI
+        if (filePath.startsWith("content://")) {
+            Uri uri = Uri.parse(filePath);
+            String fileName = getFileNameFromUri(uri);
+            if (fileName != null) {
+                request.addParameter("filename", fileName);
+            }
+        }
+
+        // Start the upload
+        return request.startUpload();
+    }
+
+    public void removeUpload(String uploadId) {
+        net.gotev.uploadservice.UploadService.stopUpload(uploadId);
+    }
+
+    private UploadNotificationConfig createNotificationConfig(String notificationTitle) {
+        UploadNotificationStatusConfig progress = new UploadNotificationStatusConfig(notificationTitle, notificationTitle + " - In Progress");
+        UploadNotificationStatusConfig success = new UploadNotificationStatusConfig(notificationTitle, notificationTitle + " - Completed");
+        UploadNotificationStatusConfig error = new UploadNotificationStatusConfig(notificationTitle, notificationTitle + " - Error");
+        UploadNotificationStatusConfig cancelled = new UploadNotificationStatusConfig(notificationTitle, notificationTitle + " - Cancelled");
+
+        return new UploadNotificationConfig(
+            "ee.forgr.capacitor.uploader.notification_channel_id",
+            false,
+            progress,
+            success,
+            error,
+            cancelled
+        );
+    }
+
+    private String getFileNameFromUri(Uri uri) {
+        String result = null;
+        if (uri.getScheme().equals("content")) {
+            try (Cursor cursor = context.getContentResolver().query(uri, null, null, null, null)) {
+                if (cursor != null && cursor.moveToFirst()) {
+                    int index = cursor.getColumnIndex(OpenableColumns.DISPLAY_NAME);
+                    if (index != -1) {
+                        result = cursor.getString(index);
+                    }
+                }
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        }
+        if (result == null) {
+            result = uri.getPath();
+            int cut = result.lastIndexOf('/');
+            if (cut != -1) {
+                result = result.substring(cut + 1);
+            }
+        }
+        return result;
+    }
+}

package/android/src/main/java/ee/forgr/capacitor/uploader/UploaderPlugin.java

@@ -0,0 +1,116 @@
+package ee.forgr.capacitor.uploader;
+
+import android.content.Context;
+import com.getcapacitor.JSObject;
+import com.getcapacitor.Plugin;
+import com.getcapacitor.PluginCall;
+import com.getcapacitor.PluginMethod;
+import com.getcapacitor.annotation.CapacitorPlugin;
+
+import net.gotev.uploadservice.data.UploadInfo;
+import net.gotev.uploadservice.network.ServerResponse;
+import net.gotev.uploadservice.observer.request.RequestObserverDelegate;
+
+import java.util.Map;
+import java.util.HashMap;
+import java.util.Iterator;
+
+@CapacitorPlugin(name = "Uploader")
+public class UploaderPlugin extends Plugin {
+
+    private Uploader implementation;
+
+    @Override
+    public void load() {
+        implementation = new Uploader(getContext(), new RequestObserverDelegate() {
+            @Override
+            public void onProgress(Context context, UploadInfo uploadInfo) {
+                JSObject event = new JSObject();
+                event.put("name", "uploading");
+                JSObject payload = new JSObject();
+                payload.put("percent", uploadInfo.getProgressPercent());
+                event.put("payload", payload);
+                event.put("id", uploadInfo.getUploadId());
+                notifyListeners("events", event);
+            }
+
+            @Override
+            public void onSuccess(Context context, UploadInfo uploadInfo, ServerResponse serverResponse) {
+                JSObject event = new JSObject();
+                event.put("name", "completed");
+                JSObject payload = new JSObject();
+                payload.put("statusCode", serverResponse.getCode());
+                event.put("payload", payload);
+                event.put("id", uploadInfo.getUploadId());
+                notifyListeners("events", event);
+            }
+
+            @Override
+            public void onError(Context context, UploadInfo uploadInfo, Throwable exception) {
+                JSObject event = new JSObject();
+                event.put("name", "failed");
+                JSObject payload = new JSObject();
+                payload.put("error", exception.getMessage());
+                event.put("payload", payload);
+                event.put("id", uploadInfo.getUploadId());
+                notifyListeners("events", event);
+            }
+
+            @Override
+            public void onCompleted(Context context, UploadInfo uploadInfo) {
+                // This method is called after onSuccess or onError
+            }
+
+            @Override
+            public void onCompletedWhileNotObserving() {
+                // This method is called when the upload completes while the observer is not registered
+            }
+        });
+    }
+
+    @PluginMethod
+    public void startUpload(PluginCall call) {
+        String filePath = call.getString("filePath");
+        String serverUrl = call.getString("serverUrl");
+        JSObject headersObj = call.getObject("headers", new JSObject());
+        JSObject parametersObj = call.getObject("parameters", new JSObject());
+        String httpMethod = call.getString("method", "POST");
+        String notificationTitle = call.getString("notificationTitle", "File Upload");
+        int maxRetries = call.getInt("maxRetries", 2);
+        String mimeType = call.getString("mimeType"); // Add this line
+
+        Map<String, String> headers = JSObjectToMap(headersObj);
+        Map<String, String> parameters = JSObjectToMap(parametersObj);
+
+        try {
+            String id = implementation.startUpload(filePath, serverUrl, headers, parameters, httpMethod, notificationTitle, maxRetries, mimeType);
+            JSObject result = new JSObject();
+            result.put("id", id);
+            call.resolve(result);
+        } catch (Exception e) {
+            call.reject(e.getMessage());
+        }
+    }
+
+    @PluginMethod
+    public void removeUpload(PluginCall call) {
+        String id = call.getString("id");
+        try {
+            implementation.removeUpload(id);
+            call.resolve();
+        } catch (Exception e) {
+            call.reject(e.getMessage());
+        }
+    }
+
+    private Map<String, String> JSObjectToMap(JSObject object) {
+        Map<String, String> map = new HashMap<>();
+        if (object != null) {
+            for (Iterator<String> it = object.keys(); it.hasNext(); ) {
+                String key = it.next();
+                map.put(key, object.getString(key));
+            }
+        }
+        return map;
+    }
+}