Merge branch 'master' of https://github.com/joltup/rn-fetch-blob into hash-fix

# Conflicts:
#	android/src/main/java/com/RNFetchBlob/RNFetchBlobFS.java

README.md

 * [Installation](#user-content-installation)
 * [HTTP Data Transfer](#user-content-http-data-transfer)
  * [Regular Request](#user-content-regular-request)
- * [Download file](#user-content-download-example--fetch-files-that-needs-authorization-token)
+ * [Download file](#download-example-fetch-files-that-need-authorization-token)
  * [Upload file](#user-content-upload-example--dropbox-files-upload-api)
  * [Multipart/form upload](#user-content-multipartform-data-example--post-form-data-with-file-and-data)
  * [Upload/Download progress](#user-content-uploaddownload-progress)
 For 0.29.2+ projects, simply link native packages via the following command (note: rnpm has been merged into react-native)
 
 ```
-react-native link
+react-native link rn-fetch-blob
 ```
 
 As for projects < 0.29 you need `rnpm` to link native packages
 Optionally, use the following command to add Android permissions to `AndroidManifest.xml` automatically
 
 ```sh
-RNFB_ANDROID_PERMISSIONS=true react-native link
+RNFB_ANDROID_PERMISSIONS=true react-native link rn-fetch-blob
 ```
 
 pre 0.29 projects

android/src/main/java/com/RNFetchBlob/RNFetchBlob.java

 
                 // Set flag to give temporary permission to external app to use FileProvider
                 intent.setFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);
+                 // All the activity to be opened outside of an activity
+                intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
 
+                // All the activity to be opened outside of an activity
+                intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
                 // Validate that the device can open the file
                 PackageManager pm = getCurrentActivity().getPackageManager();
                 if (intent.resolveActivity(pm) != null) {
     public void getSDCardApplicationDir(Promise promise) {
         RNFetchBlobFS.getSDCardApplicationDir(this.getReactApplicationContext(), promise);
     }
-}
+}

android/src/main/java/com/RNFetchBlob/RNFetchBlobFS.java

 import com.facebook.react.modules.core.DeviceEventManagerModule;
 
 import java.io.*;
-import java.nio.ByteBuffer;
 import java.nio.charset.Charset;
-import java.nio.charset.CharsetEncoder;
 import java.security.MessageDigest;
 import java.util.ArrayList;
 import java.util.HashMap;
                 }
             }
 
-            FileOutputStream fout = new FileOutputStream(f, append);
             // write data from a file
             if(encoding.equalsIgnoreCase(RNFetchBlobConst.DATA_ENCODE_URI)) {
                 String normalizedData = normalizePath(data);
                 File src = new File(normalizedData);
                 if (!src.exists()) {
                     promise.reject("ENOENT", "No such file '" + path + "' " + "('" + normalizedData + "')");
-                    fout.close();
                     return;
                 }
-                FileInputStream fin = new FileInputStream(src);
                 byte[] buffer = new byte [10240];
                 int read;
                 written = 0;
-                while((read = fin.read(buffer)) > 0) {
-                    fout.write(buffer, 0, read);
-                    written += read;
+                FileInputStream fin = null;
+                FileOutputStream fout = null;
+                try {
+                    fin = new FileInputStream(src);
+                    fout = new FileOutputStream(f, append);
+                    while ((read = fin.read(buffer)) > 0) {
+                        fout.write(buffer, 0, read);
+                        written += read;
+                    }
+                } finally {
+                    if (fin != null) {
+                        fin.close();
+                    }
+                    if (fout != null) {
+                        fout.close();
+                    }
                 }
-                fin.close();
             }
             else {
                 byte[] bytes = stringToBytes(data, encoding);
-                fout.write(bytes);
-                written = bytes.length;
+                FileOutputStream fout = new FileOutputStream(f, append);
+                try {
+                    fout.write(bytes);
+                    written = bytes.length;
+                } finally {
+                    fout.close();
+                }
             }
-            fout.close();
             promise.resolve(written);
         } catch (FileNotFoundException e) {
             // According to https://docs.oracle.com/javase/7/docs/api/java/io/FileOutputStream.html
             }
 
             FileOutputStream os = new FileOutputStream(f, append);
-            byte[] bytes = new byte[data.size()];
-            for(int i=0;i<data.size();i++) {
-                bytes[i] = (byte) data.getInt(i);
+            try {
+                byte[] bytes = new byte[data.size()];
+                for (int i = 0; i < data.size(); i++) {
+                    bytes[i] = (byte) data.getInt(i);
+                }
+                os.write(bytes);
+            } finally {
+                os.close();
             }
-            os.write(bytes);
-            os.close();
             promise.resolve(data.size());
         } catch (FileNotFoundException e) {
             // According to https://docs.oracle.com/javase/7/docs/api/java/io/FileOutputStream.html
             boolean error = false;
 
             if (encoding.equalsIgnoreCase("utf8")) {
-                CharsetEncoder encoder = Charset.forName("UTF-8").newEncoder();
                 while ((cursor = fs.read(buffer)) != -1) {
-                    encoder.encode(ByteBuffer.wrap(buffer).asCharBuffer());
                     String chunk = new String(buffer, 0, cursor);
                     emitStreamEvent(streamId, "data", chunk);
                     if(tick > 0)
     static void mkdir(String path, Promise promise) {
         File dest = new File(path);
         if(dest.exists()) {
-            promise.reject("EEXIST", dest.isDirectory() ? "Folder" : "File" + " '" + path + "' already exists");
+            promise.reject("EEXIST", (dest.isDirectory() ? "Folder" : "File") + " '" + path + "' already exists");
             return;
         }
         try {
             MessageDigest md = MessageDigest.getInstance(algorithms.get(algorithm));
 
             FileInputStream inputStream = new FileInputStream(path);
-            byte[] buffer = new byte[(int)file.length()];
+            int chunkSize = 4096 * 256; // 1Mb
+            byte[] buffer = new byte[chunkSize];
 
             if(file.length() != 0) {
-                int read;
-                while ((read = inputStream.read(buffer)) != -1) {
-                    md.update(buffer, 0, read);
+                int bytesRead;
+                while ((bytesRead = inputStream.read(buffer)) != -1) {
+                    md.update(buffer, 0, bytesRead);
                 }
             }
 

android/src/main/java/com/RNFetchBlob/RNFetchBlobReq.java

 import java.net.SocketException;
 import java.net.SocketTimeoutException;
 import java.net.URL;
-import java.nio.ByteBuffer;
-import java.nio.charset.CharacterCodingException;
-import java.nio.charset.Charset;
-import java.nio.charset.CharsetEncoder;
 import java.security.KeyStore;
 import java.util.ArrayList;
 import java.util.Arrays;
                         // encoding will somehow break the UTF8 string format, to encode UTF8
                         // string correctly, we should do URL encoding before BASE64.
                         byte[] b = resp.body().bytes();
-                        CharsetEncoder encoder = Charset.forName("UTF-8").newEncoder();
                         if(responseFormat == ResponseFormat.BASE64) {
                             callback.invoke(null, RNFetchBlobConst.RNFB_RESPONSE_BASE64, android.util.Base64.encodeToString(b, Base64.NO_WRAP));
                             return;
                         }
-                        try {
-                            encoder.encode(ByteBuffer.wrap(b).asCharBuffer());
-                            // if the data contains invalid characters the following lines will be
-                            // skipped.
-                            String utf8 = new String(b);
-                            callback.invoke(null, RNFetchBlobConst.RNFB_RESPONSE_UTF8, utf8);
-                        }
-                        // This usually mean the data is contains invalid unicode characters, it's
-                        // binary data
-                        catch(CharacterCodingException ignored) {
-                            if(responseFormat == ResponseFormat.UTF8) {
-                                callback.invoke(null, RNFetchBlobConst.RNFB_RESPONSE_UTF8, "");
-                            }
-                            else {
-                                callback.invoke(null, RNFetchBlobConst.RNFB_RESPONSE_BASE64, android.util.Base64.encodeToString(b, Base64.NO_WRAP));
-                            }
-                        }
+                        String utf8 = new String(b);
+                        callback.invoke(null, RNFetchBlobConst.RNFB_RESPONSE_UTF8, utf8);
                     }
                 } catch (IOException e) {
                     callback.invoke("RNFetchBlob failed to encode response data to BASE64 string.", null);
                 }
                 break;
             case FileStorage:
+                ResponseBody responseBody = resp.body();
+
                 try {
                     // In order to write response data to `destPath` we have to invoke this method.
                     // It uses customized response body which is able to report download progress
                     // and write response data to destination path.
-                    resp.body().bytes();
+                    responseBody.bytes();
                 } catch (Exception ignored) {
 //                    ignored.printStackTrace();
                 }
-                this.destPath = this.destPath.replace("?append=true", "");
-                callback.invoke(null, RNFetchBlobConst.RNFB_RESPONSE_PATH, this.destPath);
+
+                RNFetchBlobFileResp rnFetchBlobFileResp = (RNFetchBlobFileResp) responseBody;
+
+                if(rnFetchBlobFileResp != null && rnFetchBlobFileResp.isDownloadComplete() == false){
+                    callback.invoke("RNFetchBlob failed. Download interrupted.", null);
+                }
+                else {
+                    this.destPath = this.destPath.replace("?append=true", "");
+                    callback.invoke(null, RNFetchBlobConst.RNFB_RESPONSE_PATH, this.destPath);
+                }
                 break;
             default:
                 try {
                 DownloadManager dm = (DownloadManager) appCtx.getSystemService(Context.DOWNLOAD_SERVICE);
                 dm.query(query);
                 Cursor c = dm.query(query);
-
+                // #236 unhandled null check for DownloadManager.query() return value
+                if (c == null) {
+                    this.callback.invoke("Download manager failed to download from  " + this.url + ". Query was unsuccessful ", null, null);
+                    return;
+                }
 
                 String filePath = null;
-                // the file exists in media content database
-                if (c.moveToFirst()) {
-                    // #297 handle failed request
-                    int statusCode = c.getInt(c.getColumnIndex(DownloadManager.COLUMN_STATUS));
-                    if(statusCode == DownloadManager.STATUS_FAILED) {
-                        this.callback.invoke("Download manager failed to download from  " + this.url + ". Status Code = " + statusCode, null, null);
-                        return;
-                    }
-                    String contentUri = c.getString(c.getColumnIndex(DownloadManager.COLUMN_LOCAL_URI));
-                    if ( contentUri != null &&
-                            options.addAndroidDownloads.hasKey("mime") &&
-                            options.addAndroidDownloads.getString("mime").contains("image")) {
-                        Uri uri = Uri.parse(contentUri);
-                        Cursor cursor = appCtx.getContentResolver().query(uri, new String[]{android.provider.MediaStore.Images.ImageColumns.DATA}, null, null, null);
-                        // use default destination of DownloadManager
-                        if (cursor != null) {
-                            cursor.moveToFirst();
-                            filePath = cursor.getString(0);
-                            cursor.close();
+                try {    
+                    // the file exists in media content database
+                    if (c.moveToFirst()) {
+                        // #297 handle failed request
+                        int statusCode = c.getInt(c.getColumnIndex(DownloadManager.COLUMN_STATUS));
+                        if(statusCode == DownloadManager.STATUS_FAILED) {
+                            this.callback.invoke("Download manager failed to download from  " + this.url + ". Status Code = " + statusCode, null, null);
+                            return;
+                        }
+                        String contentUri = c.getString(c.getColumnIndex(DownloadManager.COLUMN_LOCAL_URI));
+                        if ( contentUri != null &&
+                                options.addAndroidDownloads.hasKey("mime") &&
+                                options.addAndroidDownloads.getString("mime").contains("image")) {
+                            Uri uri = Uri.parse(contentUri);
+                            Cursor cursor = appCtx.getContentResolver().query(uri, new String[]{android.provider.MediaStore.Images.ImageColumns.DATA}, null, null, null);
+                            // use default destination of DownloadManager
+                            if (cursor != null) {
+                                cursor.moveToFirst();
+                                filePath = cursor.getString(0);
+                                cursor.close();
+                            }
                         }
                     }
+                } finally {
+                    if (c != null) {
+                        c.close();
+                    }
                 }
 
                 // When the file is not found in media content database, check if custom path exists

android/src/main/java/com/RNFetchBlob/Response/RNFetchBlobFileResp.java

         return originalBody.contentLength();
     }
 
+    public boolean isDownloadComplete() {
+        return bytesDownloaded == contentLength();
+    }
+
     @Override
     public BufferedSource source() {
         ProgressReportingSource countable = new ProgressReportingSource();

android/src/main/java/com/RNFetchBlob/Utils/PathResolver.java

             }
             // DownloadsProvider
             else if (isDownloadsDocument(uri)) {
+                try {
+                    final String id = DocumentsContract.getDocumentId(uri);
+                    //Starting with Android O, this "id" is not necessarily a long (row number),
+                    //but might also be a "raw:/some/file/path" URL
+                    if (id != null && id.startsWith("raw:/")) {
+                        Uri rawuri = Uri.parse(id);
+                        String path = rawuri.getPath();
+                        return path;
+                    }
+                    final Uri contentUri = ContentUris.withAppendedId(
+                            Uri.parse("content://downloads/public_downloads"), Long.valueOf(id));
 
-                final String id = DocumentsContract.getDocumentId(uri);
-                final Uri contentUri = ContentUris.withAppendedId(
-                        Uri.parse("content://downloads/public_downloads"), Long.valueOf(id));
-
-                return getDataColumn(context, contentUri, null, null);
+                    return getDataColumn(context, contentUri, null, null);
+                }
+                catch (Exception ex) {
+                    //something went wrong, but android should still be able to handle the original uri by returning null here (see readFile(...))
+                    return null;
+                }
+                
             }
             // MediaProvider
             else if (isMediaDocument(uri)) {

android/src/main/res/xml/provider_paths.xml

     <files-path
         name="files-path"
         path="." /> <!-- Used to access into application data files -->
-</paths>
+    <cache-path
+        name="cache-path"
+        path="." /> <!-- Used to access files in cache directory -->
+</paths>

fs.js

   return RNFetchBlob.pathForAppGroup(groupName)
 }
 
+/**
+ * Returns the path for the app group synchronous.
+ * @param  {string} groupName Name of app group
+ * @return {string} Path of App Group dir
+ */
+function syncPathAppGroup(groupName: string): string {
+  if (Platform.OS === 'ios') {
+    return RNFetchBlob.syncPathAppGroup(groupName);
+  } else {
+    return '';
+  }
+}
+
 /**
  * Wrapper method of readStream.
  * @param  {string} path Path of the file.
   writeFile,
   appendFile,
   pathForAppGroup,
+  syncPathAppGroup,
   readFile,
   hash,
   exists,

index.d.ts

      */
     flush(): void;
     respInfo: RNFetchBlobResponseInfo;
+    info(): RNFetchBlobResponseInfo;
     session(name: string): RNFetchBlobSession | null;
     /**
      * Read file content with given encoding, if the response does not contains
     removeCookies(domain?: string): Promise<null>;
 }
 
+type HashAlgorithm = "md5" | "sha1" | "sha224" | "sha256" | "sha384" | "sha512";
 export interface FS {
     RNFetchBlobSession: RNFetchBlobSession;
 
 
     ls(path: string): Promise<string[]>;
 
+    /**
+     * Read the file from the given path and calculate a cryptographic hash sum over its contents.
+     *
+     * @param path Path to the file
+     * @param algorithm The hash algorithm to use
+     */
+    hash(path: string, algorithm: HashAlgorithm): Promise<string>;
+
     /**
      * Create file stream from file at `path`.
      * @param  path   The file path.

index.js

     return fetchFile(options, method, url, headers, body)
   }
 
+  let promiseResolve;
+  let promiseReject;
+
   // from remote HTTP(S)
   let promise = new Promise((resolve, reject) => {
+    promiseResolve = resolve;
+    promiseReject = reject;
+
     let nativeMethodName = Array.isArray(body) ? 'fetchBlobForm' : 'fetchBlob'
 
     // on progress event listener
     subscriptionUpload.remove()
     stateEvent.remove()
     RNFetchBlob.cancelRequest(taskId, fn)
+    promiseReject(new Error("canceled"))
   }
   promise.taskId = taskId
 

ios/RNFetchBlob/RNFetchBlob.m

 - (NSDictionary *)constantsToExport
 {
     return @{
-             @"MainBundleDir" : [RNFetchBlobFS getMainBundleDir],
+             @"CacheDir" : [RNFetchBlobFS getCacheDir],
              @"DocumentDir": [RNFetchBlobFS getDocumentDir],
-             @"CacheDir" : [RNFetchBlobFS getCacheDir]
+             @"DownloadDir" : [RNFetchBlobFS getDownloadDir],
+             @"LibraryDir" : [RNFetchBlobFS getLibraryDir],
+             @"MainBundleDir" : [RNFetchBlobFS getMainBundleDir],
+             @"MovieDir" : [RNFetchBlobFS getMovieDir],
+             @"MusicDir" : [RNFetchBlobFS getMusicDir],
+             @"PictureDir" : [RNFetchBlobFS getPictureDir],
              };
 }
 
     }
 }
 
+#pragma mark - fs.syncPathAppGroup
+RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(syncPathAppGroup:(NSString *)groupName) {
+    NSURL *pathUrl = [[NSFileManager defaultManager] containerURLForSecurityApplicationGroupIdentifier:groupName];
+    NSString *path = [pathUrl path];
+
+    if(path) {
+        return path;
+    } else {
+        return @"";
+    }
+}
+
 #pragma mark - fs.exists
 RCT_EXPORT_METHOD(exists:(NSString *)path callback:(RCTResponseSenderBlock)callback) {
     [RNFetchBlobFS exists:path callback:callback];

ios/RNFetchBlobFS.h

 @property (nonatomic) BOOL appendData;
 
 // get dirs
-+ (NSString *) getMainBundleDir;
-+ (NSString *) getTempPath;
 + (NSString *) getCacheDir;
 + (NSString *) getDocumentDir;
++ (NSString *) getDownloadDir;
++ (NSString *) getLibraryDir;
++ (NSString *) getMainBundleDir;
++ (NSString *) getMovieDir;
++ (NSString *) getMusicDir;
++ (NSString *) getPictureDir;
++ (NSString *) getTempPath;
 + (NSString *) getTempPath:(NSString*)taskId withExtension:(NSString *)ext;
 + (NSString *) getPathOfAsset:(NSString *)assetURI;
 + (NSString *) getPathForAppGroup:(NSString *)groupName;

ios/RNFetchBlobFS.m

     return [NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES) firstObject];
 }
 
++ (NSString *) getDownloadDir {
+    return [NSSearchPathForDirectoriesInDomains(NSDownloadsDirectory, NSUserDomainMask, YES) firstObject];
+}
+
++ (NSString *) getLibraryDir {
+    return [NSSearchPathForDirectoriesInDomains(NSLibraryDirectory, NSUserDomainMask, YES) firstObject];
+}
+
 + (NSString *) getMusicDir {
     return [NSSearchPathForDirectoriesInDomains(NSMusicDirectory, NSUserDomainMask, YES) firstObject];
 }

ios/RNFetchBlobReqBuilder.m

                 [mheaders setValue:[NSString stringWithFormat:@"%lu",[postData length]] forKey:@"Content-Length"];
                 [mheaders setValue:@"100-continue" forKey:@"Expect"];
                 // appaned boundary to content-type
-                [mheaders setValue:[NSString stringWithFormat:@"multipart/form-data; charset=utf-8; boundary=%@", boundary] forKey:@"content-type"];
+                [mheaders setValue:[NSString stringWithFormat:@"multipart/form-data; boundary=%@", boundary] forKey:@"content-type"];
                 [request setHTTPMethod: method];
                 [request setAllHTTPHeaderFields:mheaders];
                 onComplete(request, [formData length]);

package.json

 {
   "name": "rn-fetch-blob",
-  "version": "0.10.16",
+  "version": "0.11.1",
   "description": "A module provides upload, download, and files access API. Supports file stream read/write for process large files.",
   "main": "index.js",
   "scripts": {
     "filestream",
     "image header"
   ],
-  "rnpm": {
-    "commands": {
-      "prelink": "node ./node_modules/rn-fetch-blob/scripts/prelink.js"
-    }
-  },
   "repository": {
     "url": "https://github.com/joltup/rn-fetch-blob.git"
   },

react-native.config.js

+module.exports = {
+  dependency: {
+    hooks: {
+      prelink: 'node ./node_modules/rn-fetch-blob/scripts/prelink.js',
+    },
+  },
+};

rn-fetch-blob.podspec

+require "json"
+package = JSON.parse(File.read('package.json'))
+
 Pod::Spec.new do |s|
-  s.name             = "rn-fetch-blob"
-  s.version          = "0.10.16"
-  s.summary          = "A project committed to make file acess and data transfer easier, effiecient for React Native developers."
+  s.name             = package['name']
+  s.version          = package['version']
+  s.summary          = package['description']
   s.requires_arc = true
   s.license      = 'MIT'
   s.homepage     = 'n/a'
-  s.source       = { :git => "https://github.com/joltup/rn-fetch-blob", :tag => 'v0.10.16'}
+  s.source       = { :git => "https://github.com/joltup/rn-fetch-blob" }
   s.author       = 'Joltup'
   s.source_files = 'ios/**/*.{h,m}'
   s.platform     = :ios, "8.0"