react-native-blob-util 0.13.15 → 0.14.0

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

@@ -0,0 +1,287 @@
+package com.ReactNativeBlobUtil;
+
+import android.net.Uri;
+import android.os.SystemClock;
+import android.util.Base64;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.Callback;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.WritableArray;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.modules.core.DeviceEventManagerModule;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.OutputStream;
+import java.nio.charset.Charset;
+import java.util.HashMap;
+import java.util.UUID;
+
+public class ReactNativeBlobUtilStream {
+    private final DeviceEventManagerModule.RCTDeviceEventEmitter emitter;
+    private String encoding = "base64";
+    private OutputStream writeStreamInstance = null;
+    private static final HashMap<String, ReactNativeBlobUtilStream> fileStreams = new HashMap<>();
+
+    ReactNativeBlobUtilStream(ReactApplicationContext ctx) {
+        this.emitter = ctx.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class);
+    }
+
+    /**
+     * Create a file stream for read
+     *
+     * @param path       File stream target path
+     * @param encoding   File stream decoder, should be one of `base64`, `utf8`, `ascii`
+     * @param bufferSize Buffer size of read stream, default to 4096 (4095 when encode is `base64`)
+     */
+    void readStream(String path, String encoding, int bufferSize, int tick, final String streamId) {
+        String resolved = ReactNativeBlobUtilUtils.normalizePath(path);
+        if (resolved != null)
+            path = resolved;
+
+        try {
+            int chunkSize = encoding.equalsIgnoreCase("base64") ? 4095 : 4096;
+            if (bufferSize > 0)
+                chunkSize = bufferSize;
+
+            InputStream fs;
+
+            if (resolved != null && path.startsWith(ReactNativeBlobUtilConst.FILE_PREFIX_BUNDLE_ASSET)) {
+                fs = ReactNativeBlobUtil.RCTContext.getAssets().open(path.replace(ReactNativeBlobUtilConst.FILE_PREFIX_BUNDLE_ASSET, ""));
+            }
+            // fix issue 287
+            else if (resolved == null) {
+                fs = ReactNativeBlobUtil.RCTContext.getContentResolver().openInputStream(Uri.parse(path));
+            } else {
+                fs = new FileInputStream(new File(path));
+            }
+
+            int cursor = 0;
+            boolean error = false;
+
+            if (encoding.equalsIgnoreCase("utf8")) {
+                InputStreamReader isr = new InputStreamReader(fs, Charset.forName("UTF-8"));
+                BufferedReader reader = new BufferedReader(isr, chunkSize);
+                char[] buffer = new char[chunkSize];
+                // read chunks of the string
+                while (reader.read(buffer, 0, chunkSize) != -1) {
+                    String chunk = new String(buffer);
+                    emitStreamEvent(streamId, "data", chunk);
+                    if (tick > 0)
+                        SystemClock.sleep(tick);
+                }
+
+                reader.close();
+                isr.close();
+            } else if (encoding.equalsIgnoreCase("ascii")) {
+                byte[] buffer = new byte[chunkSize];
+                while ((cursor = fs.read(buffer)) != -1) {
+                    WritableArray chunk = Arguments.createArray();
+                    for (int i = 0; i < cursor; i++) {
+                        chunk.pushInt((int) buffer[i]);
+                    }
+                    emitStreamEvent(streamId, "data", chunk);
+                    if (tick > 0)
+                        SystemClock.sleep(tick);
+                }
+            } else if (encoding.equalsIgnoreCase("base64")) {
+                byte[] buffer = new byte[chunkSize];
+                while ((cursor = fs.read(buffer)) != -1) {
+                    if (cursor < chunkSize) {
+                        byte[] copy = new byte[cursor];
+                        System.arraycopy(buffer, 0, copy, 0, cursor);
+                        emitStreamEvent(streamId, "data", Base64.encodeToString(copy, Base64.NO_WRAP));
+                    } else
+                        emitStreamEvent(streamId, "data", Base64.encodeToString(buffer, Base64.NO_WRAP));
+                    if (tick > 0)
+                        SystemClock.sleep(tick);
+                }
+            } else {
+                emitStreamEvent(
+                        streamId,
+                        "error",
+                        "EINVAL",
+                        "Unrecognized encoding `" + encoding + "`, should be one of `base64`, `utf8`, `ascii`"
+                );
+                error = true;
+            }
+
+            if (!error)
+                emitStreamEvent(streamId, "end", "");
+            fs.close();
+
+        } catch (FileNotFoundException err) {
+            emitStreamEvent(
+                    streamId,
+                    "error",
+                    "ENOENT",
+                    "No such file '" + path + "'"
+            );
+        } catch (Exception err) {
+            emitStreamEvent(
+                    streamId,
+                    "error",
+                    "EUNSPECIFIED",
+                    "Failed to convert data to " + encoding + " encoded string. This might be because this encoding cannot be used for this data."
+            );
+            err.printStackTrace();
+        }
+    }
+
+    /**
+     * Create a write stream and store its instance in ReactNativeBlobUtilFS.fileStreams
+     *
+     * @param path     Target file path
+     * @param encoding Should be one of `base64`, `utf8`, `ascii`
+     * @param append   Flag represents if the file stream overwrite existing content
+     * @param callback Callback
+     */
+    void writeStream(String path, String encoding, boolean append, Callback callback) {
+        try {
+            File dest = new File(path);
+            File dir = dest.getParentFile();
+
+            if (!dest.exists()) {
+                if (dir != null && !dir.exists()) {
+                    if (!dir.mkdirs()) {
+                        callback.invoke("ENOTDIR", "Failed to create parent directory of '" + path + "'");
+                        return;
+                    }
+                }
+                if (!dest.createNewFile()) {
+                    callback.invoke("ENOENT", "File '" + path + "' does not exist and could not be created");
+                    return;
+                }
+            } else if (dest.isDirectory()) {
+                callback.invoke("EISDIR", "Expecting a file but '" + path + "' is a directory");
+                return;
+            }
+
+            OutputStream fs = new FileOutputStream(path, append);
+            this.encoding = encoding;
+            String streamId = UUID.randomUUID().toString();
+            ReactNativeBlobUtilStream.fileStreams.put(streamId, this);
+            this.writeStreamInstance = fs;
+            callback.invoke(null, null, streamId);
+        } catch (Exception err) {
+            callback.invoke("EUNSPECIFIED", "Failed to create write stream at path `" + path + "`; " + err.getLocalizedMessage());
+        }
+    }
+
+    /**
+     * Write a chunk of data into a file stream.
+     *
+     * @param streamId File stream ID
+     * @param data     Data chunk in string format
+     * @param callback JS context callback
+     */
+    static void writeChunk(String streamId, String data, Callback callback) {
+        ReactNativeBlobUtilStream fs = fileStreams.get(streamId);
+        assert fs != null;
+        OutputStream stream = fs.writeStreamInstance;
+        byte[] chunk = ReactNativeBlobUtilUtils.stringToBytes(data, fs.encoding);
+        try {
+            stream.write(chunk);
+            callback.invoke();
+        } catch (Exception e) {
+            callback.invoke(e.getLocalizedMessage());
+        }
+    }
+
+    /**
+     * Write data using ascii array
+     *
+     * @param streamId File stream ID
+     * @param data     Data chunk in ascii array format
+     * @param callback JS context callback
+     */
+    static void writeArrayChunk(String streamId, ReadableArray data, Callback callback) {
+        try {
+            ReactNativeBlobUtilStream fs = fileStreams.get(streamId);
+            assert fs != null;
+            OutputStream stream = fs.writeStreamInstance;
+            byte[] chunk = new byte[data.size()];
+            for (int i = 0; i < data.size(); i++) {
+                chunk[i] = (byte) data.getInt(i);
+            }
+            stream.write(chunk);
+            callback.invoke();
+        } catch (Exception e) {
+            callback.invoke(e.getLocalizedMessage());
+        }
+    }
+
+    /**
+     * Close file write stream by ID
+     *
+     * @param streamId Stream ID
+     * @param callback JS context callback
+     */
+    static void closeStream(String streamId, Callback callback) {
+        try {
+            ReactNativeBlobUtilStream fs = fileStreams.get(streamId);
+            assert fs != null;
+            OutputStream stream = fs.writeStreamInstance;
+            fileStreams.remove(streamId);
+            stream.close();
+            callback.invoke();
+        } catch (Exception err) {
+            callback.invoke(err.getLocalizedMessage());
+        }
+    }
+
+    /**
+     * Private method for emit read stream event.
+     *
+     * @param streamName ID of the read stream
+     * @param event      Event name, `data`, `end`, `error`, etc.
+     * @param data       Event data
+     */
+    private void emitStreamEvent(String streamName, String event, String data) {
+        WritableMap eventData = Arguments.createMap();
+        eventData.putString("event", event);
+        eventData.putString("detail", data);
+        this.emitter.emit(streamName, eventData);
+    }
+
+    // "event" always is "data"...
+    private void emitStreamEvent(String streamName, String event, WritableArray data) {
+        WritableMap eventData = Arguments.createMap();
+        eventData.putString("event", event);
+        eventData.putArray("detail", data);
+        this.emitter.emit(streamName, eventData);
+    }
+
+    // "event" always is "error"...
+    private void emitStreamEvent(String streamName, String event, String code, String message) {
+        WritableMap eventData = Arguments.createMap();
+        eventData.putString("event", event);
+        eventData.putString("code", code);
+        eventData.putString("detail", message);
+        this.emitter.emit(streamName, eventData);
+    }
+
+    /**
+     * Get input stream of the given path, when the path is a string starts with bundle-assets://
+     * the stream is created by Assets Manager, otherwise use FileInputStream.
+     *
+     * @param path The file to open stream
+     * @return InputStream instance
+     * @throws IOException If the given file does not exist or is a directory FileInputStream will throw a FileNotFoundException
+     */
+    public static InputStream inputStreamFromPath(String path) throws IOException {
+        if (path.startsWith(ReactNativeBlobUtilConst.FILE_PREFIX_BUNDLE_ASSET)) {
+            return ReactNativeBlobUtil.RCTContext.getAssets().open(path.replace(ReactNativeBlobUtilConst.FILE_PREFIX_BUNDLE_ASSET, ""));
+        }
+        return new FileInputStream(new File(path));
+    }
+
+}

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

@@ -1,11 +1,17 @@
 package com.ReactNativeBlobUtil;
 
+import android.net.Uri;
+import android.util.Base64;
+
+import com.ReactNativeBlobUtil.Utils.PathResolver;
 import com.facebook.react.bridge.Arguments;
 import com.facebook.react.bridge.WritableMap;
 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;
 import javax.net.ssl.SSLContext;
@@ -30,7 +36,7 @@ public class ReactNativeBlobUtilUtils {
             StringBuilder sb = new StringBuilder();
 
             for (byte b : digest) {
-                sb.append(String.format("%02x", b & 0xff));
+                sb.append(String.format(Locale.ROOT, "%02x", b & 0xff));
             }
 
             result = sb.toString();
@@ -75,7 +81,7 @@ public class ReactNativeBlobUtilUtils {
             // Install the all-trusting trust manager
             final SSLContext sslContext = SSLContext.getInstance("SSL");
             sslContext.init(null, trustAllCerts, new java.security.SecureRandom());
-            // Create an ssl socket factory with our all-trusting manager
+            // Create an ssl socLket factory with our all-trusting manager
             final SSLSocketFactory sslSocketFactory = sslContext.getSocketFactory();
 
             OkHttpClient.Builder builder = client.newBuilder();
@@ -92,4 +98,53 @@ public class ReactNativeBlobUtilUtils {
             throw new RuntimeException(e);
         }
     }
+
+    /**
+     * String to byte converter method
+     *
+     * @param data     Raw data in string format
+     * @param encoding Decoder name
+     * @return Converted data byte array
+     */
+    public static byte[] stringToBytes(String data, String encoding) {
+        if (encoding.equalsIgnoreCase("ascii")) {
+            return data.getBytes(Charset.forName("US-ASCII"));
+        } else if (encoding.toLowerCase(Locale.ROOT).contains("base64")) {
+            return Base64.decode(data, Base64.NO_WRAP);
+
+        } else if (encoding.equalsIgnoreCase("utf8")) {
+            return data.getBytes(Charset.forName("UTF-8"));
+        }
+        return data.getBytes(Charset.forName("US-ASCII"));
+    }
+
+    /**
+     * Normalize the path, remove URI scheme (xxx://) so that we can handle it.
+     *
+     * @param path URI string.
+     * @return Normalized string
+     */
+    public static String normalizePath(String path) {
+        if (path == null)
+            return null;
+        if (!path.matches("\\w+\\:.*"))
+            return path;
+        if (path.startsWith("file://")) {
+            return path.replace("file://", "");
+        }
+
+        Uri uri = Uri.parse(path);
+        if (path.startsWith(ReactNativeBlobUtilConst.FILE_PREFIX_BUNDLE_ASSET)) {
+            return path;
+        } else
+            return PathResolver.getRealPathFromURI(ReactNativeBlobUtil.RCTContext, uri);
+    }
+
+    public static boolean isAsset(String path) {
+        return path != null && path.startsWith(ReactNativeBlobUtilConst.FILE_PREFIX_BUNDLE_ASSET);
+    }
+
+    public static boolean isContentUri(String path) {
+        return path != null && path.startsWith(ReactNativeBlobUtilConst.FILE_PREFIX_CONTENT);
+    }
 }

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

@@ -35,6 +35,11 @@ public class ReactNativeBlobUtilFileResp extends ResponseBody {
     FileOutputStream ofStream;
     boolean isEndMarkerReceived;
 
+    public ReactNativeBlobUtilFileResp(ResponseBody body) {
+        super();
+        this.originalBody = body;
+    }
+
     public ReactNativeBlobUtilFileResp(ReactApplicationContext ctx, String taskId, ResponseBody body, String path, boolean overwrite) throws IOException {
         super();
         this.rctContext = ctx;

package/android/src/main/java/com/ReactNativeBlobUtil/Utils/FileDescription.java

@@ -0,0 +1,19 @@
+package com.ReactNativeBlobUtil.Utils;
+
+import android.webkit.MimeTypeMap;
+
+public class FileDescription {
+    public String name;
+    public String partentFolder;
+    public String mimeType;
+
+    public FileDescription(String n, String mT, String pF) {
+        name = n;
+        partentFolder = pF != null ? pF : "";
+        mimeType = mT;
+    }
+
+    public String getFullPath(){
+        return partentFolder + "/" + MimeType.getFullFileName(name, mimeType);
+    }
+}

package/android/src/main/java/com/ReactNativeBlobUtil/Utils/MimeType.java

@@ -0,0 +1,70 @@
+package com.ReactNativeBlobUtil.Utils;
+
+import android.webkit.MimeTypeMap;
+
+import org.apache.commons.lang3.StringUtils;
+
+public class MimeType {
+    static String UNKNOWN = "*/*";
+    static String BINARY_FILE = "application/octet-stream";
+    static String IMAGE = "image/*";
+    static String AUDIO = "audio/*";
+    static String VIDEO = "video/*";
+    static String TEXT = "text/*";
+    static String FONT = "font/*";
+    static String APPLICATION = "application/*";
+    static String CHEMICAL = "chemical/*";
+    static String MODEL = "model/*";
+
+    /**
+     * * Given `name` = `ABC` AND `mimeType` = `video/mp4`, then return `ABC.mp4`
+     * * Given `name` = `ABC` AND `mimeType` = `null`, then return `ABC`
+     * * Given `name` = `ABC.mp4` AND `mimeType` = `video/mp4`, then return `ABC.mp4`
+     *
+     * @param name can have file extension or not
+     */
+
+    public static String getFullFileName(String name, String mimeType) {
+        // Prior to API 29, MimeType.BINARY_FILE has no file extension
+        String ext = MimeType.getExtensionFromMimeType(mimeType);
+        if (ext.isEmpty() || name.endsWith("." + "ext")) return name;
+        else {
+            String fn = name + "." + ext;
+            if (fn.endsWith(".")) return StringUtils.stripEnd(fn, ".");
+            else return fn;
+        }
+    }
+
+    /**
+     * Some mime types return no file extension on older API levels. This function adds compatibility accross API levels.
+     *
+     * @see this.getExtensionFromMimeTypeOrFileName
+     */
+
+    public static String getExtensionFromMimeType(String mimeType) {
+        if (mimeType != null) {
+            if (mimeType.equals(BINARY_FILE)) return "bin";
+            else return MimeTypeMap.getSingleton().getExtensionFromMimeType(mimeType);
+        } else return "";
+    }
+
+    /**
+     * @see this.getExtensionFromMimeType
+     */
+    public static String getExtensionFromMimeTypeOrFileName(String mimeType, String filename) {
+        if (mimeType == null || mimeType.equals(UNKNOWN)) return StringUtils.substringAfterLast(filename, ".");
+        else return getExtensionFromMimeType(mimeType);
+    }
+
+    /**
+     * Some file types return no mime type on older API levels. This function adds compatibility across API levels.
+     */
+    public static String getMimeTypeFromExtension(String fileExtension) {
+        if (fileExtension.equals("bin")) return BINARY_FILE;
+        else {
+            String mt = MimeTypeMap.getSingleton().getMimeTypeFromExtension(fileExtension);
+            if (mt != null) return mt;
+            else return UNKNOWN;
+        }
+    }
+}

package/fetch.js

@@ -259,7 +259,7 @@ export function fetch(...args: any): Promise {
                 if (options.path || options.fileCache || options.addAndroidDownloads
                     || options.key || options.auto && respInfo.respType === 'blob') {
                     if (options.session)
-                        session(options.session).add(data);
+                        fs.session(options.session).add(data);
                 }
                 respInfo.rnfbEncode = rawType;
                 resolve(new FetchBlobResponse(taskId, respInfo, data));

package/fs.js

@@ -23,7 +23,8 @@ const dirs = {
     SDCardDir: ReactNativeBlobUtil.SDCardDir, // Depracated
     SDCardApplicationDir: ReactNativeBlobUtil.SDCardApplicationDir, // Deprecated
     MainBundleDir: ReactNativeBlobUtil.MainBundleDir,
-    LibraryDir: ReactNativeBlobUtil.LibraryDir
+    LibraryDir: ReactNativeBlobUtil.LibraryDir,
+  ApplicationSupportDir: ReactNativeBlobUtil.ApplicationSupportDir
 };
 
 function addCode(code: string, error: Error): Error {