react-native-blob-util 0.14.0 → 0.16.0

package/android/src/main/java/com/ReactNativeBlobUtil/ReactNativeBlobUtilMediaCollection.java

@@ -10,11 +10,10 @@ import android.os.ParcelFileDescriptor;
 import android.provider.MediaStore;
 import android.util.Base64;
 
-import androidx.annotation.RequiresApi;
-
 import com.ReactNativeBlobUtil.Utils.FileDescription;
 import com.facebook.react.bridge.Arguments;
 import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.bridge.WritableArray;
 
 import java.io.File;
@@ -62,21 +61,29 @@ public class ReactNativeBlobUtilMediaCollection {
         return res;
     }
 
-    private static String getRelativePath(MediaType mt) {
-        if (mt == MediaType.Audio) return Environment.DIRECTORY_MUSIC;
-        if (mt == MediaType.Video) return Environment.DIRECTORY_MOVIES;
-        if (mt == MediaType.Image) return Environment.DIRECTORY_PICTURES;
-        if (mt == MediaType.Download) return Environment.DIRECTORY_DOWNLOADS;
-        return Environment.DIRECTORY_DOWNLOADS;
+    private static String getRelativePath(MediaType mt, ReactApplicationContext ctx) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+            if (mt == MediaType.Audio) return Environment.DIRECTORY_MUSIC;
+            if (mt == MediaType.Video) return Environment.DIRECTORY_MOVIES;
+            if (mt == MediaType.Image) return Environment.DIRECTORY_PICTURES;
+            if (mt == MediaType.Download) return Environment.DIRECTORY_DOWNLOADS;
+            return Environment.DIRECTORY_DOWNLOADS;
+        } else {
+            if (mt == MediaType.Audio) return ReactNativeBlobUtilFS.getExternalFilesDirPath(ctx, Environment.DIRECTORY_MUSIC);
+            if (mt == MediaType.Video) return ReactNativeBlobUtilFS.getExternalFilesDirPath(ctx, Environment.DIRECTORY_MOVIES);
+            if (mt == MediaType.Image) return ReactNativeBlobUtilFS.getExternalFilesDirPath(ctx, Environment.DIRECTORY_PICTURES);
+            if (mt == MediaType.Download) return ReactNativeBlobUtilFS.getExternalFilesDirPath(ctx, Environment.DIRECTORY_DOWNLOADS);
+            return ReactNativeBlobUtilFS.getExternalFilesDirPath(ctx, Environment.DIRECTORY_DOWNLOADS);
+        }
     }
 
-    public static Uri createNewMediaFile(FileDescription file, MediaType mt) {
+    public static Uri createNewMediaFile(FileDescription file, MediaType mt, ReactApplicationContext ctx) {
         // Add a specific media item.
         Context appCtx = ReactNativeBlobUtil.RCTContext.getApplicationContext();
         ContentResolver resolver = appCtx.getContentResolver();
 
         ContentValues fileDetails = new ContentValues();
-        String relativePath = getRelativePath(mt);
+        String relativePath = getRelativePath(mt, ctx);
         String mimeType = file.mimeType;
 
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
@@ -91,12 +98,24 @@ public class ReactNativeBlobUtilMediaCollection {
             // Keeps a handle to the new file's URI in case we need to modify it later.
             return resolver.insert(mediauri, fileDetails);
         } else {
-            File directory = Environment.getExternalStoragePublicDirectory(relativePath);
-            if (directory.canWrite()) {
-                File f = new File(relativePath + '/' + file.getFullPath());
+            File f = new File(relativePath + file.getFullPath());
+            if (true) {
                 if (!f.exists()) {
-                    boolean result = f.mkdirs();
-                    if (result) return Uri.fromFile(f);
+                    File parent = f.getParentFile();
+                    if (parent != null && !parent.exists() && !parent.mkdirs()) {
+                        return null;
+                    }
+                    try {
+                        if (f.createNewFile()) ;
+                        {
+                            return Uri.fromFile(f);
+                        }
+                    } catch (IOException ioException) {
+                        return null;
+                    }
+
+                } else {
+                    return Uri.fromFile(f);
                 }
 
             }
@@ -105,83 +124,99 @@ public class ReactNativeBlobUtilMediaCollection {
         return null;
     }
 
-    @RequiresApi(api = Build.VERSION_CODES.Q)
-    public static boolean writeToMediaFile(Uri fileUri, String data, Promise promise) {
-        try {
-            Context appCtx = ReactNativeBlobUtil.RCTContext.getApplicationContext();
-            ContentResolver resolver = appCtx.getContentResolver();
+    public static boolean writeToMediaFile(Uri fileUri, String data, boolean transformFile, Promise promise) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+            try {
+                Context appCtx = ReactNativeBlobUtil.RCTContext.getApplicationContext();
+                ContentResolver resolver = appCtx.getContentResolver();
 
-            // set pending
-            ContentValues contentValues = new ContentValues();
-            contentValues.put(MediaStore.MediaColumns.IS_PENDING, 1);
-            resolver.update(fileUri, contentValues, null, null);
+                // set pending doesn't work right now. We would have to requery for the item
+                //ContentValues contentValues = new ContentValues();
+                //contentValues.put(MediaStore.MediaColumns.IS_PENDING, 1);
+                //resolver.update(fileUri, contentValues, null, null);
 
-            // write data
-            OutputStream stream = null;
-            Uri uri = null;
+                // write data
+                OutputStream stream = null;
+                Uri uri = null;
 
-            try {
-                ParcelFileDescriptor descr;
                 try {
-                    assert fileUri != null;
-                    descr = appCtx.getContentResolver().openFileDescriptor(fileUri, "w");
-                    assert descr != null;
-                    String normalizedData = ReactNativeBlobUtilUtils.normalizePath(data);
-                    File src = new File(normalizedData);
-                    if (!src.exists()) {
-                        promise.reject("ENOENT", "No such file ('" + normalizedData + "')");
+                    ParcelFileDescriptor descr;
+                    try {
+                        assert fileUri != null;
+                        descr = appCtx.getContentResolver().openFileDescriptor(fileUri, "w");
+                        assert descr != null;
+                        String normalizedData = ReactNativeBlobUtilUtils.normalizePath(data);
+                        File src = new File(normalizedData);
+                        if (!src.exists()) {
+                            promise.reject("ENOENT", "No such file ('" + normalizedData + "')");
+                            return false;
+                        }
+
+
+                        FileInputStream fin = new FileInputStream(src);
+                        FileOutputStream out = new FileOutputStream(descr.getFileDescriptor());
+
+                        if (transformFile) {
+                            // in order to transform file, we must load the entire file onto memory
+                            int length = (int) src.length();
+                            byte[] bytes = new byte[length];
+                            fin.read(bytes);
+                            if (ReactNativeBlobUtilFileTransformer.sharedFileTransformer == null) {
+                                throw new IllegalStateException("Write to media file with transform was specified but the shared file transformer is not set");
+                            }
+                            byte[] transformedBytes = ReactNativeBlobUtilFileTransformer.sharedFileTransformer.onWriteFile(bytes);
+                            out.write(transformedBytes);
+                        } else  {
+                            byte[] buf = new byte[10240];
+                            int read;
+
+                            while ((read = fin.read(buf)) > 0) {
+                                out.write(buf, 0, read);
+                            }
+                        }
+
+
+                        fin.close();
+                        out.close();
+                        descr.close();
+                    } catch (Exception e) {
+                        e.printStackTrace();
+                        promise.reject(new IOException("Failed to get output stream."));
                         return false;
                     }
-                    byte[] buf = new byte[10240];
-                    int read;
-                    int written = 0;
-
-                    FileInputStream fin = new FileInputStream(src);
-                    FileOutputStream out = new FileOutputStream(descr.getFileDescriptor());
 
-                    while ((read = fin.read(buf)) > 0) {
-                        out.write(buf, 0, read);
+                    //contentValues.clear();
+                    //contentValues.put(MediaStore.Video.Media.IS_PENDING, 0);
+                    //appCtx.getContentResolver().update(fileUri, contentValues, null, null);
+                    stream = resolver.openOutputStream(fileUri);
+                    if (stream == null) {
+                        promise.reject(new IOException("Failed to get output stream."));
+                        return false;
                     }
-
-                    fin.close();
-                    out.close();
-                    descr.close();
-                } catch (Exception e) {
-                    e.printStackTrace();
-                    promise.reject(new IOException("Failed to get output stream."));
+                } catch (IOException e) {
+                    // Don't leave an orphan entry in the MediaStore
+                    resolver.delete(uri, null, null);
+                    promise.reject(e);
                     return false;
+                } finally {
+                    if (stream != null) {
+                        stream.close();
+                    }
                 }
 
-                contentValues.clear();
-                contentValues.put(MediaStore.Video.Media.IS_PENDING, 0);
-                appCtx.getContentResolver().update(fileUri, contentValues, null, null);
-                stream = resolver.openOutputStream(fileUri);
-                if (stream == null) {
-                    promise.reject(new IOException("Failed to get output stream."));
-                    return false;
-                }
+                // remove pending
+                //contentValues = new ContentValues();
+                //contentValues.put(MediaStore.MediaColumns.IS_PENDING, 0);
+                //resolver.update(fileUri, contentValues, null, null);
+
             } catch (IOException e) {
-                // Don't leave an orphan entry in the MediaStore
-                resolver.delete(uri, null, null);
-                promise.reject(e);
+                promise.reject("ReactNativeBlobUtil.createMediaFile", "Cannot write to file, file might not exist");
                 return false;
-            } finally {
-                if (stream != null) {
-                    stream.close();
-                    return true;
-                }
             }
-
-            // remove pending
-            contentValues = new ContentValues();
-            contentValues.put(MediaStore.MediaColumns.IS_PENDING, 0);
-            resolver.update(fileUri, contentValues, null, null);
-
-        } catch (IOException e) {
-            promise.reject("ReactNativeBlobUtil.createMediaFile", "Cannot write to file, file might not exist");
-            return false;
+            return true;
+        } else {
+            return ReactNativeBlobUtilFS.writeFile(ReactNativeBlobUtilUtils.normalizePath(fileUri.toString()), ReactNativeBlobUtilConst.DATA_ENCODE_URI, data, false);
         }
-        return true;
     }
 
     public static void copyToInternal(Uri contenturi, String destpath, Promise promise) {
@@ -190,10 +225,16 @@ public class ReactNativeBlobUtilMediaCollection {
 
         InputStream in = null;
         OutputStream out = null;
+        File f = new File((destpath));
 
-        if (!new File(destpath).exists()) {
+        if (!f.exists()) {
             try {
-                boolean result = new File(destpath).createNewFile();
+                File parent = f.getParentFile();
+                if (parent != null && !parent.exists() && !parent.mkdirs()) {
+                    promise.reject("ReactNativeBlobUtil.copyToInternal: Cannot create parent folders<'" + destpath);
+                    return;
+                }
+                boolean result = f.createNewFile();
                 if (!result) {
                     promise.reject("ReactNativeBlobUtil.copyToInternal: Destination file at '" + destpath + "' already exists");
                     return;
@@ -240,9 +281,7 @@ public class ReactNativeBlobUtilMediaCollection {
         ContentResolver resolver = appCtx.getContentResolver();
         try {
             InputStream in = resolver.openInputStream(contentUri);
-            int length = 0;
-
-            length = in.available();
+            int length = in.available();
 
             byte[] bytes = new byte[length];
             int bytesRead = in.read(bytes);
@@ -260,14 +299,11 @@ public class ReactNativeBlobUtilMediaCollection {
                 case "ascii":
                     WritableArray asciiResult = Arguments.createArray();
                     for (byte b : bytes) {
-                        asciiResult.pushInt((int) b);
+                        asciiResult.pushInt(b);
                     }
                     promise.resolve(asciiResult);
                     break;
-                case "utf8":
-                    promise.resolve(new String(bytes));
-                    break;
-                default:
+                default: // covers utf-8
                     promise.resolve(new String(bytes));
                     break;
             }

package/android/src/main/java/com/ReactNativeBlobUtil/ReactNativeBlobUtilReq.java

@@ -12,6 +12,9 @@ import android.net.NetworkCapabilities;
 import android.net.NetworkInfo;
 import android.net.Uri;
 import android.os.Build;
+import android.os.Bundle;
+import android.os.Handler;
+import android.os.Message;
 import android.util.Base64;
 import android.webkit.CookieManager;
 
@@ -48,6 +51,9 @@ import java.util.HashMap;
 
 import java.util.List;
 import java.util.Locale;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.TimeUnit;
 
 import javax.net.ssl.SSLContext;
@@ -87,6 +93,12 @@ public class ReactNativeBlobUtilReq extends BroadcastReceiver implements Runnabl
         BASE64
     }
 
+    private boolean shouldTransformFile() {
+        return this.options.transformFile &&
+            // Can only process if it's written to a file
+            (this.options.fileCache || this.options.path != null);
+    }
+
     public static HashMap<String, Call> taskTable = new HashMap<>();
     public static HashMap<String, Long> androidDownloadManagerTaskTable = new HashMap<>();
     static HashMap<String, ReactNativeBlobUtilProgressConfig> progressReport = new HashMap<>();
@@ -124,7 +136,9 @@ public class ReactNativeBlobUtilReq extends BroadcastReceiver implements Runnabl
         this.rawRequestBodyArray = arrayBody;
         this.client = client;
 
-        if (this.options.fileCache || this.options.path != null)
+        // If transformFile is specified, we first want to get the response back in memory so we can
+        // encrypt it wholesale and at that point, write it into the file storage.
+        if((this.options.fileCache || this.options.path != null) && !this.shouldTransformFile())
             responseType = ResponseType.FileStorage;
         else
             responseType = ResponseType.KeepInMemory;
@@ -153,6 +167,59 @@ public class ReactNativeBlobUtilReq extends BroadcastReceiver implements Runnabl
         }
     }
 
+    private final int QUERY = 1314;
+    private ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(1);
+    private Future<?> future;
+    private Handler mHandler = new Handler(new Handler.Callback() {
+        public boolean handleMessage(Message msg) {
+            switch (msg.what) {
+
+                case QUERY:
+
+                    Bundle data = msg.getData();
+                    long id = data.getLong("downloadManagerId");
+                    if (id == downloadManagerId) {
+
+                        Context appCtx = ReactNativeBlobUtil.RCTContext.getApplicationContext();
+
+                        DownloadManager downloadManager = (DownloadManager) appCtx.getSystemService(Context.DOWNLOAD_SERVICE);
+
+                        DownloadManager.Query query = new DownloadManager.Query();
+
+                        Cursor cursor = downloadManager.query(query);
+
+                        if (cursor != null && cursor.moveToFirst()) {
+
+                            long written = cursor.getInt(cursor.getColumnIndex(DownloadManager.COLUMN_BYTES_DOWNLOADED_SO_FAR));
+
+                            long total = cursor.getLong(cursor.getColumnIndex(
+                                    DownloadManager.COLUMN_TOTAL_SIZE_BYTES));
+                            cursor.close();
+
+                            ReactNativeBlobUtilProgressConfig reportConfig = getReportProgress(taskId);
+                            float progress = (total != -1) ? written / total : 0;
+
+                            if (reportConfig != null && reportConfig.shouldReport(progress /* progress */)) {
+                                WritableMap args = Arguments.createMap();
+                                args.putString("taskId", String.valueOf(taskId));
+                                args.putString("written", String.valueOf(written));
+                                args.putString("total", String.valueOf(total));
+                                args.putString("chunk", "");
+                                ReactNativeBlobUtil.RCTContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+                                        .emit(ReactNativeBlobUtilConst.EVENT_PROGRESS, args);
+
+                            }
+
+                            if (total == written) {
+                                future.cancel(true);
+                            }
+                        }
+                    }
+            }
+            return true;
+        }
+    });
+
     @Override
     public void run() {
 
@@ -204,6 +271,17 @@ public class ReactNativeBlobUtilReq extends BroadcastReceiver implements Runnabl
                 downloadManagerId = dm.enqueue(req);
                 androidDownloadManagerTaskTable.put(taskId, Long.valueOf(downloadManagerId));
                 appCtx.registerReceiver(this, new IntentFilter(DownloadManager.ACTION_DOWNLOAD_COMPLETE));
+                future = scheduledExecutorService.scheduleAtFixedRate(new Runnable() {
+                    @Override
+                    public void run() {
+                        Message msg = mHandler.obtainMessage();
+                        Bundle data = new Bundle();
+                        data.putLong("downloadManagerId", downloadManagerId);
+                        msg.setData(data);
+                        msg.what = QUERY;
+                        mHandler.sendMessage(msg);
+                    }
+                }, 0, 100, TimeUnit.MILLISECONDS);
                 return;
             }
 
@@ -557,6 +635,26 @@ public class ReactNativeBlobUtilReq extends BroadcastReceiver implements Runnabl
                     // response data directly pass to JS context as string.
                     else {
                         byte[] b = resp.body().bytes();
+                        // If process file option is turned on, we first keep response in memory and then stream that content
+                        // after processing
+                        if (this.shouldTransformFile()) {
+                            if (ReactNativeBlobUtilFileTransformer.sharedFileTransformer == null) {
+                                throw new IllegalStateException("Write file with transform was specified but the shared file transformer is not set");
+                            }
+                            this.destPath = this.destPath.replace("?append=true", "");
+                            File file = new File(this.destPath);
+                            if (!file.exists()) {
+                                file.createNewFile();
+                            }
+                            try (FileOutputStream fos = new FileOutputStream(file)) {
+                                fos.write(ReactNativeBlobUtilFileTransformer.sharedFileTransformer.onWriteFile(b));
+                            } catch(Exception e) {
+                                callback.invoke("Error from file transformer:" + e.getLocalizedMessage(), null);
+                                return;
+                            }
+                            callback.invoke(null, ReactNativeBlobUtilConst.RNFB_RESPONSE_PATH, this.destPath);
+                            return;
+                        }
                         if (responseFormat == ResponseFormat.BASE64) {
                             callback.invoke(null, ReactNativeBlobUtilConst.RNFB_RESPONSE_BASE64, android.util.Base64.encodeToString(b, Base64.NO_WRAP));
                             return;

package/android/src/main/java/com/ReactNativeBlobUtil/ReactNativeBlobUtilUtils.java

@@ -10,7 +10,6 @@ import com.facebook.react.modules.core.DeviceEventManagerModule;
 
 import java.nio.charset.Charset;
 import java.security.MessageDigest;
-import java.security.cert.CertificateException;
 import java.util.Locale;
 
 import javax.net.ssl.HostnameVerifier;
@@ -22,9 +21,10 @@ import javax.net.ssl.X509TrustManager;
 
 import okhttp3.OkHttpClient;
 
-
 public class ReactNativeBlobUtilUtils {
 
+    public static X509TrustManager sharedTrustManager;
+
     public static String getMD5(String input) {
         String result = null;
 
@@ -61,22 +61,10 @@ public class ReactNativeBlobUtilUtils {
 
     public static OkHttpClient.Builder getUnsafeOkHttpClient(OkHttpClient client) {
         try {
-            // Create a trust manager that does not validate certificate chains
-            final X509TrustManager x509TrustManager = new X509TrustManager() {
-                @Override
-                public void checkClientTrusted(java.security.cert.X509Certificate[] chain, String authType) throws CertificateException {
-                }
 
-                @Override
-                public void checkServerTrusted(java.security.cert.X509Certificate[] chain, String authType) throws CertificateException {
-                }
+            if (sharedTrustManager == null) throw new IllegalStateException("Use of own trust manager but none defined");
 
-                @Override
-                public java.security.cert.X509Certificate[] getAcceptedIssuers() {
-                    return new java.security.cert.X509Certificate[]{};
-                }
-            };
-            final TrustManager[] trustAllCerts = new TrustManager[]{x509TrustManager};
+            final TrustManager[] trustAllCerts = new TrustManager[]{sharedTrustManager};
 
             // Install the all-trusting trust manager
             final SSLContext sslContext = SSLContext.getInstance("SSL");
@@ -85,7 +73,7 @@ public class ReactNativeBlobUtilUtils {
             final SSLSocketFactory sslSocketFactory = sslContext.getSocketFactory();
 
             OkHttpClient.Builder builder = client.newBuilder();
-            builder.sslSocketFactory(sslSocketFactory, x509TrustManager);
+            builder.sslSocketFactory(sslSocketFactory, sharedTrustManager);
             builder.hostnameVerifier(new HostnameVerifier() {
                 @Override
                 public boolean verify(String hostname, SSLSession session) {

package/android/src/main/java/com/ReactNativeBlobUtil/Response/ReactNativeBlobUtilFileResp.java

@@ -72,6 +72,10 @@ public class ReactNativeBlobUtilFileResp extends ResponseBody {
 
     @Override
     public long contentLength() {
+        if (originalBody.contentLength() > Integer.MAX_VALUE) {
+            // This is a workaround for a bug Okio buffer where it can't handle larger than int.
+            return Integer.MAX_VALUE;
+        }
         return originalBody.contentLength();
     }
 

package/class/ReactNativeBlobUtilBlobResponse.js

@@ -3,7 +3,7 @@ import fs from "../fs";
 import Blob from "../polyfill/Blob";
 import ReactNativeBlobUtilSession from "./ReactNativeBlobUtilSession";
 import URIUtil from "../utils/uri";
-
+import base64 from "base-64";
 /**
  * ReactNativeBlobUtil response object class.
  */

package/fs.js

@@ -160,7 +160,20 @@ function readFile(path: string, encoding: string = 'utf8'): Promise<any> {
     if (typeof path !== 'string') {
         return Promise.reject(addCode('EINVAL', new TypeError('Missing argument "path" ')));
     }
-    return ReactNativeBlobUtil.readFile(path, encoding);
+    return ReactNativeBlobUtil.readFile(path, encoding, false);
+}
+
+/**
+ * Reads the file, then transforms it before returning the content
+ * @param  {string} path Path of the file.
+ * @param  {'base64' | 'utf8' | 'ascii'} encoding Encoding of read stream.
+ * @return {Promise<Array<number> | string>}
+ */
+function readFileWithTransform(path: string, encoding: string = 'utf8'): Promise<any> {
+    if (typeof path !== 'string') {
+        return Promise.reject(addCode('EINVAL', new TypeError('Missing argument "path" ')))
+    }
+    return ReactNativeBlobUtil.readFile(path, encoding, true);
 }
 
 /**
@@ -186,7 +199,31 @@ function writeFile(path: string, data: string | Array<number>, encoding: ?string
             return Promise.reject(addCode('EINVAL', new TypeError(`"data" must be a String when encoding is "utf8" or "base64", but it is "${typeof data}"`)));
         }
         else
-            return ReactNativeBlobUtil.writeFile(path, encoding, data, false);
+            return ReactNativeBlobUtil.writeFile(path, encoding, data, false, false);
+    }
+}
+
+/**
+ * Transforms the data and then writes to the file.
+ * @param  {string} path  Path of the file.
+ * @param  {string | number[]} data Data to write to the file.
+ * @param  {string} encoding Encoding of data (Optional).
+ * @return {Promise}
+ */
+function writeFileWithTransform(path: string, data: string | Array<number>, encoding: ?string = 'utf8'): Promise {
+    if (typeof path !== 'string') {
+        return Promise.reject(addCode('EINVAL', new TypeError('Missing argument "path" ')))
+    }
+    if (encoding.toLocaleLowerCase() === 'ascii') {
+        return Promise.reject(addCode('EINVAL', new TypeError('ascii is not supported for converted files')))
+    }
+    else {
+        if (typeof data !== 'string') {
+            return Promise.reject(addCode('EINVAL', new TypeError(`"data" must be a String when encoding is "utf8" or "base64", but it is "${typeof data}"`)))
+        }
+
+        else
+            return ReactNativeBlobUtil.writeFile(path, encoding, data, true, false)
     }
 }
 
@@ -206,7 +243,7 @@ function appendFile(path: string, data: string | Array<number>, encoding?: strin
             return Promise.reject(addCode('EINVAL'), new TypeError(`"data" must be a String when encoding is "utf8" or "base64", but it is "${typeof data}"`));
         }
         else
-            return ReactNativeBlobUtil.writeFile(path, encoding, data, true);
+            return ReactNativeBlobUtil.writeFile(path, encoding, data, false, true);
     }
 }
 
@@ -415,6 +452,8 @@ export default {
     cp,
     writeStream,
     writeFile,
+    writeFileWithTransform,
+    readFileWithTransform,
     appendFile,
     pathForAppGroup,
     syncPathAppGroup,

package/index.d.ts

@@ -399,6 +399,14 @@ export interface FS {
      */
     writeFile(path: string, data: string | number[], encoding?: Encoding): Promise<void>;
 
+    /**
+     * Processes the data and then writes to the file.
+     * @param  path  Path of the file.
+     * @param  data Data to write to the file.
+     * @param  encoding Encoding of data (Optional).
+     */
+     writeFileWithTransform(path: string, data: string | number[], encoding?: Encoding): Promise<void>;
+
     appendFile(path: string, data: string | number[], encoding?: Encoding | "uri"): Promise<number>;
 
     /**
@@ -408,6 +416,13 @@ export interface FS {
      */
     readFile(path: string, encoding: Encoding, bufferSize?: number): Promise<any>;
 
+    /**
+     * Reads from a file and then processes the data before returning
+     * @param  path Path of the file.
+     * @param  encoding Encoding of read stream.
+     */
+     readFileWithTransform(path: string, encoding: Encoding, bufferSize?: number): Promise<any>;
+
     /**
      * Check if file exists and if it is a folder.
      * @param  path Path to check
@@ -475,7 +490,7 @@ export interface ReactNativeBlobUtilWriteStream {
 
     write(data: string): Promise<void>;
 
-    close(): void;
+    close(): Promise<void>;
 }
 
 export interface ReactNativeBlobUtilReadStream {
@@ -698,6 +713,13 @@ export interface ReactNativeBlobUtilConfig {
      */
     fileCache?: boolean;
 
+    /**
+     * Set this property to true if you want the data to be processed before it gets written onto disk.
+     * This only has effect if the FileTransformer has been registered and the library is configured to write
+     * response onto disk.
+     */
+    transformFile?: boolean;
+
     /**
      * Set this property to change temp file extension that created by fetch response data.
      */
@@ -808,6 +830,13 @@ export interface MediaCollection {
      */
     writeToMediafile(uri: string, path: string): Promise<string>
 
+    /**
+     * Copies and transforms an existing file to a mediastore file. Make sure FileTransformer is set
+     * @param uri URI of the destination mediastore file
+     * @param path Path to the existing file which should be copied
+     */
+    writeToMediafileWithTransform(uri: string, path: string): Promise<string>
+
     /**
      * Copies a file from the mediastore to the apps internal storage
      * @param contenturi URI of the mediastore file