Merge pull request #202 from pkwak-sf/long-multipart-upload

wkh237 · web-flow · commit 0e335abee29f · 2016-11-30T12:53:55.000+08:00
Long multipart upload
diff --git a/README.md b/README.md
@@ -381,6 +381,48 @@ What if you want to append a file to form data ? Just like [upload a file from s
   })
 ```
 
+When you append files to form-data and you want to continue uploading while the app is in background on Android, you can use IntentService to upload by adding `multipartFileUpload` flag to config.
+
+```js
+
+  RNFetchBlob.config({
+    multipartFileUpload: true,
+  })
+  .fetch('POST', 'http://www.example.com/upload-form', {
+    Authorization : "Bearer access-token",
+    otherHeader : "foo",
+    // this is required, otherwise it won't be process as a multipart/form-data request
+    'Content-Type' : 'multipart/form-data',
+  }, [
+    // append field data from file path
+    {
+      name : 'avatar',
+      filename : 'avatar.png',
+      // Change BASE64 encoded data to a file path with prefix `RNFetchBlob-file://`.
+      // Or simply wrap the file path with RNFetchBlob.wrap().
+      data: RNFetchBlob.wrap(PATH_TO_THE_FILE)
+    },
+    {
+      name : 'ringtone',
+      filename : 'ring.mp3',
+      // use custom MIME type
+      type : 'application/mp3',
+      // upload a file from asset is also possible in version >= 0.6.2
+      data : RNFetchBlob.wrap(RNFetchBlob.fs.asset('default-ringtone.mp3'))
+    }
+    // elements without property `filename` will be sent as plain text
+    { name : 'name', data : 'user'},
+    { name : 'info', data : JSON.stringify({
+      mail : 'example@example.com',
+      tel : '12345678'
+    })},
+  ]).then((resp) => {
+    // ...
+  }).catch((err) => {
+    // ...
+  })
+```
+
 ### Upload/Download progress
 
 In `version >= 0.4.2` it is possible to know the upload/download progress. After `0.7.0` IOS and Android upload progress are also supported.
diff --git a/src/android/src/main/AndroidManifest.xml b/src/android/src/main/AndroidManifest.xml
@@ -6,6 +6,10 @@
         android:label="@string/app_name"
         android:supportsRtl="true">
 
+        <service
+            android:name=".RNFetchBlobService"
+            >
+        </service>
     </application>
 
 </manifest>
diff --git a/src/android/src/main/java/com/RNFetchBlob/RNFetchBlobConfig.java b/src/android/src/main/java/com/RNFetchBlob/RNFetchBlobConfig.java
@@ -20,6 +20,7 @@ public class RNFetchBlobConfig {
     public long timeout = 60000;
     public Boolean increment = false;
     public ReadableArray binaryContentTypes = null;
+    public boolean multipartFileUpload;
 
     RNFetchBlobConfig(ReadableMap options) {
         if(options == null)
@@ -46,6 +47,7 @@ public class RNFetchBlobConfig {
         if(options.hasKey("timeout")) {
             this.timeout = options.getInt("timeout");
         }
+        this.multipartFileUpload = options.hasKey("multipartFileUpload") ? options.getBoolean("multipartFileUpload") : false;
     }
 
 }
diff --git a/src/android/src/main/java/com/RNFetchBlob/RNFetchBlobReq.java b/src/android/src/main/java/com/RNFetchBlob/RNFetchBlobReq.java
@@ -7,6 +7,7 @@
 import android.content.IntentFilter;
 import android.database.Cursor;
 import android.net.Uri;
+import android.os.Bundle;
 import android.util.Base64;
 
 import com.RNFetchBlob.Response.RNFetchBlobDefaultResp;
@@ -18,6 +19,7 @@
 import com.facebook.react.bridge.ReadableArray;
 import com.facebook.react.bridge.ReadableMap;
 import com.facebook.react.bridge.ReadableMapKeySetIterator;
+import com.facebook.react.bridge.ReadableNativeArray;
 import com.facebook.react.bridge.WritableArray;
 import com.facebook.react.bridge.WritableMap;
 import com.facebook.react.modules.core.DeviceEventManagerModule;
@@ -165,6 +167,39 @@ public void run() {
 
         }
 
+        if(this.options.multipartFileUpload) {
+            HashMap<String, String> mheaders = new HashMap<>();
+            // set headers
+            if (headers != null) {
+                ReadableMapKeySetIterator it = headers.keySetIterator();
+                while (it.hasNextKey()) {
+                    String key = it.nextKey();
+                    String value = headers.getString(key);
+                    mheaders.put(key, value);
+                }
+            }
+
+            Bundle bundle = new Bundle();
+            bundle.putString("taskId", taskId);
+            bundle.putString("url", url);
+            bundle.putSerializable("mheaders", mheaders);
+            bundle.putSerializable("requestBodyArray", ((ReadableNativeArray)rawRequestBodyArray).toArrayList());
+
+            Context appCtx = RNFetchBlob.RCTContext.getApplicationContext();
+
+            IntentFilter filter = new IntentFilter(RNFetchBlobService.RNFetchBlobServiceBroadcast);
+            filter.addCategory(RNFetchBlobService.CategoryProgress);
+            filter.addCategory(RNFetchBlobService.CategorySuccess);
+            filter.addCategory(RNFetchBlobService.CategoryFail);
+            appCtx.registerReceiver(this, filter);
+
+            Intent intent = new Intent(appCtx, RNFetchBlobService.class);
+            intent.putExtras(bundle);
+            appCtx.startService(intent);
+
+            return;
+        }
+
         // find cached result if `key` property exists
         String cacheKey = this.taskId;
         String ext = this.options.appendExt.isEmpty() ? "" : "." + this.options.appendExt;
@@ -662,8 +697,38 @@ public void onReceive(Context context, Intent intent) {
                 }
 
             }
+        } else if (RNFetchBlobService.RNFetchBlobServiceBroadcast.equals(action)) {
+            String _taskId = intent.getStringExtra(RNFetchBlobService.BroadcastTaskId);
+            if (this.taskId.equals(_taskId)) {
+                if (intent.hasCategory(RNFetchBlobService.CategoryProgress)) {
+                    HashMap map = (HashMap) intent.getSerializableExtra(RNFetchBlobService.BroadcastProgressMap);
+
+                    WritableMap args = Arguments.createMap();
+                    args.putString("taskId", _taskId);
+                    args.putString("written", String.valueOf(map.get(RNFetchBlobService.KeyWritten)));
+                    args.putString("total", String.valueOf(map.get(RNFetchBlobService.KeyTotal)));
+
+                    // emit event to js context
+                    RNFetchBlob.RCTContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+                            .emit(RNFetchBlobConst.EVENT_UPLOAD_PROGRESS, args);
+                } else if (intent.hasCategory(RNFetchBlobService.CategorySuccess)) {
+                    // Could be fail.
+                    try {
+                        byte[] bytes = intent.getByteArrayExtra(RNFetchBlobService.BroadcastMsg);
+                        callback.invoke(null, RNFetchBlobConst.RNFB_RESPONSE_UTF8, new String(bytes, "UTF-8"));
+                    } catch (IOException e) {
+                        callback.invoke("RNFetchBlob failed to encode response data to UTF8 string.", null);
+                    } finally {
+                        // lets unregister.
+                        Context appCtx = RNFetchBlob.RCTContext.getApplicationContext();
+                        appCtx.unregisterReceiver(this);
+                    }
+                } else if (intent.hasCategory(RNFetchBlobService.CategoryFail)) {
+                    callback.invoke("Request failed.", null, null);
+                    Context appCtx = RNFetchBlob.RCTContext.getApplicationContext();
+                    appCtx.unregisterReceiver(this);
+                }
+            }
         }
     }
-
-
 }
diff --git a/src/android/src/main/java/com/RNFetchBlob/RNFetchBlobService.java b/src/android/src/main/java/com/RNFetchBlob/RNFetchBlobService.java
@@ -0,0 +1,187 @@
+package com.RNFetchBlob;
+
+import android.app.IntentService;
+import android.content.Intent;
+import android.net.Uri;
+import android.os.Bundle;
+import android.text.TextUtils;
+
+import com.facebook.react.modules.network.*;
+
+import java.io.File;
+import java.io.IOException;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.concurrent.TimeUnit;
+
+import okhttp3.Call;
+import okhttp3.Headers;
+import okhttp3.MediaType;
+import okhttp3.MultipartBody;
+import okhttp3.OkHttpClient;
+import okhttp3.Request;
+import okhttp3.RequestBody;
+import okhttp3.Response;
+
+/**
+ * Created by pkwak on 11/15/16.
+ * IntentService for POSTing multi-form data. Designed for long-uploads with file
+ * (but can use data body).
+ */
+
+public class RNFetchBlobService extends IntentService implements ProgressListener {
+    public static String RNFetchBlobServiceBroadcast = "RNFetchBlobServiceBroadcast";
+
+    public static String CategorySuccess = "CategorySuccess";
+    public static String CategoryFail = "CategoryFail";
+    public static String CategoryProgress = "CategoryProgress";
+
+    public static String BroadcastMsg = "BroadcastMsg";
+    public static String BroadcastProgressMap = "BroadcastProgressMap";
+    public static String BroadcastTaskId = "BroadcastTaskId";
+
+    public static String KeyWritten = "KeyWritten";
+    public static String KeyTotal = "KeyTotal";
+
+    /**
+     * Creates an IntentService.  Invoked by your subclass's constructor.
+     */
+    public RNFetchBlobService() {
+        super("RNFetchBlobService");
+    }
+
+    private String _taskId = null;
+    @Override
+    protected void onHandleIntent(final Intent intent) {
+
+        Bundle bundle = intent.getExtras();
+        _taskId = bundle.getString("taskId");
+        String url = bundle.getString("url");
+        HashMap<String, String> mheaders = (HashMap<String, String>)bundle.getSerializable("mheaders");
+        ArrayList<Object> requestBodyArray = (ArrayList<Object>)bundle.getSerializable("requestBodyArray");
+
+        MultipartBody.Builder requestBuilder = new MultipartBody.Builder()
+                .setType(MultipartBody.FORM);
+        for(Object bodyPart : requestBodyArray) {
+            if (bodyPart instanceof HashMap) {
+                HashMap<String, String> bodyMap = (HashMap<String, String>)bodyPart;
+                String name = bodyMap.get("name");
+                String type = bodyMap.get("type");
+                String filename = bodyMap.get("filename");
+                String data = bodyMap.get("data");
+                File file = null;
+                MediaType mediaType = type != null
+                    ? MediaType.parse(type)
+                    : filename == null
+                        ? MediaType.parse("text/plain")
+                        : MediaType.parse("application/octet-stream");
+                if(filename != null && data.startsWith("RNFetchBlob-")) {
+                    try {
+                        String normalizedUri = RNFetchBlobFS.normalizePath(data.replace(RNFetchBlobConst.FILE_PREFIX, ""));
+                        file = new File(String.valueOf(Uri.parse(normalizedUri)));
+                    } catch (Exception e) {
+                        file = null;
+                    }
+                }
+
+                String contentDisposition = "form-data"
+                        + (!TextUtils.isEmpty(name) ? "; name=" + name : "")
+                        + (!TextUtils.isEmpty(filename) ? "; filename=" + filename : "");
+
+                requestBuilder.addPart(
+                        Headers.of("Content-Disposition", contentDisposition),
+                        file != null
+                                ? RequestBody.create(mediaType, file)
+                                : RequestBody.create(mediaType, data)
+                );
+            }
+        }
+        RequestBody innerRequestBody = requestBuilder.build();
+
+        ProgressRequestBody requestBody = new ProgressRequestBody(innerRequestBody, this);
+
+        final Request.Builder builder = new Request.Builder();
+        try {
+            builder.url(new URL(url));
+        } catch (MalformedURLException e) {
+            Intent broadcastIntent = new Intent();
+            broadcastIntent.setAction(RNFetchBlobServiceBroadcast);
+            broadcastIntent.addCategory(CategoryFail);
+            broadcastIntent.putExtra(BroadcastMsg, "Could not create URL : " + e.getMessage().getBytes());
+            sendBroadcast(broadcastIntent);
+            return;
+        }
+
+        builder.post(requestBody);
+        for(String key : mheaders.keySet()) {
+            builder.addHeader(key, mheaders.get(key));
+        }
+
+        OkHttpClient client = new OkHttpClient.Builder()
+                .writeTimeout(24, TimeUnit.HOURS)
+                .readTimeout(24, TimeUnit.HOURS)
+                .build();
+
+        final Call call =  client.newCall(builder.build());
+        call.enqueue(new okhttp3.Callback() {
+
+            @Override
+            public void onFailure(Call call, IOException e) {
+                Intent broadcastIntent = new Intent();
+                broadcastIntent.setAction(RNFetchBlobServiceBroadcast);
+                broadcastIntent.addCategory(CategoryFail);
+                broadcastIntent.putExtra(BroadcastMsg, e.getMessage().getBytes());
+                broadcastIntent.putExtra(BroadcastTaskId, _taskId);
+                sendBroadcast(broadcastIntent);
+                call.cancel();
+            }
+
+            @Override
+            public void onResponse(Call call, Response response) throws IOException {
+                // This is http-response success. Can be 2xx/4xx/5xx/etc.
+                Intent broadcastIntent = new Intent();
+                broadcastIntent.setAction(RNFetchBlobServiceBroadcast);
+                broadcastIntent.addCategory(CategorySuccess);
+                broadcastIntent.putExtra(BroadcastMsg, response.body().bytes());
+                broadcastIntent.putExtra(BroadcastTaskId, _taskId);
+                sendBroadcast(broadcastIntent);
+
+                response.body().close();
+
+            }
+
+        });
+    }
+
+    private int _progressPercent = 0;
+    private long _lastProgressTime = 0;
+    @Override
+    public void onProgress(long bytesWritten, long contentLength, boolean done) {
+
+        // no more than once per %
+        int currentPercent = (int)((bytesWritten * 100) / contentLength);
+        if (currentPercent <= _progressPercent) {
+            return;
+        }
+        _progressPercent = currentPercent;
+
+        // no more than twice a second.
+        long now = System.currentTimeMillis();
+        if (_lastProgressTime + 500 > now) {
+            return;
+        }
+        _lastProgressTime = now;
+
+        Intent broadcastIntent = new Intent();
+        broadcastIntent.setAction(RNFetchBlobServiceBroadcast);
+        broadcastIntent.addCategory(CategoryProgress);
+        broadcastIntent.putExtra(BroadcastTaskId, _taskId);
+        HashMap map = new HashMap();
+        map.put(KeyWritten, Long.valueOf(bytesWritten));
+        map.put(KeyTotal, Long.valueOf(contentLength));
+        broadcastIntent.putExtra(BroadcastProgressMap, map);
+        sendBroadcast(broadcastIntent);
+    }
+}
diff --git a/src/ios/RNFetchBlobNetwork.m b/src/ios/RNFetchBlobNetwork.m
@@ -223,6 +223,9 @@ - (void) sendRequest:(__weak NSDictionary  * _Nullable )options
     {
         defaultConfigObject.timeoutIntervalForRequest = timeout/1000;
     }
+    
+    defaultConfigObject.sessionSendsLaunchEvents = YES;
+    
     defaultConfigObject.HTTPMaximumConnectionsPerHost = 10;
     session = [NSURLSession sessionWithConfiguration:defaultConfigObject delegate:self delegateQueue:taskQueue];
     if(path != nil || [self.options valueForKey:CONFIG_USE_TEMP]!= nil)
@@ -254,7 +257,13 @@ - (void) sendRequest:(__weak NSDictionary  * _Nullable )options
         respFile = NO;
     }
 
-    __block NSURLSessionDataTask * task = [session dataTaskWithRequest:req];
+    __block NSURLSessionDataTask * task;
+    if (path && req.HTTPMethod == @"POST") {
+        task = [session uploadTaskWithRequest:req fromFile:path];
+    } else {
+        task = [session dataTaskWithRequest:req];
+    }
+    
     [taskTable setObject:task forKey:taskId];
     [task resume];
 

Original file line number	Diff line number	Diff line change
`@@ -20,6 +20,7 @@ public class RNFetchBlobConfig {`
`20`	`20`	`public long timeout = 60000;`
`21`	`21`	`public Boolean increment = false;`
`22`	`22`	`public ReadableArray binaryContentTypes = null;`
	`23`	`+ public boolean multipartFileUpload;`
`23`	`24`
`24`	`25`	`RNFetchBlobConfig(ReadableMap options) {`
`25`	`26`	`if(options == null)`
`@@ -46,6 +47,7 @@ public class RNFetchBlobConfig {`
`46`	`47`	`if(options.hasKey("timeout")) {`
`47`	`48`	`this.timeout = options.getInt("timeout");`
`48`	`49`	`}`
	`50`	`+ this.multipartFileUpload = options.hasKey("multipartFileUpload") ? options.getBoolean("multipartFileUpload") : false;`
`49`	`51`	`}`
`50`	`52`
`51`	`53`	`}`