react-native-blob-util 0.13.17 → 0.14.1

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

@@ -0,0 +1,299 @@
+package com.ReactNativeBlobUtil;
+
+import android.content.ContentResolver;
+import android.content.ContentValues;
+import android.content.Context;
+import android.net.Uri;
+import android.os.Build;
+import android.os.Environment;
+import android.os.ParcelFileDescriptor;
+import android.provider.MediaStore;
+import android.util.Base64;
+
+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;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+
+public class ReactNativeBlobUtilMediaCollection {
+
+    public enum MediaType {
+        Audio,
+        Image,
+        Video,
+        Download
+    }
+
+    private static Uri getMediaUri(MediaType mt) {
+        Uri res = null;
+        if (mt == MediaType.Audio) {
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+                res = MediaStore.Audio.Media.getContentUri(MediaStore.VOLUME_EXTERNAL_PRIMARY);
+            } else {
+                res = MediaStore.Audio.Media.EXTERNAL_CONTENT_URI;
+            }
+        } else if (mt == MediaType.Video) {
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+                res = MediaStore.Video.Media.getContentUri(MediaStore.VOLUME_EXTERNAL_PRIMARY);
+            } else {
+                res = MediaStore.Video.Media.EXTERNAL_CONTENT_URI;
+            }
+        } else if (mt == MediaType.Image) {
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+                res = MediaStore.Images.Media.getContentUri(MediaStore.VOLUME_EXTERNAL_PRIMARY);
+            } else {
+                res = MediaStore.Images.Media.EXTERNAL_CONTENT_URI;
+            }
+        } else if (mt == MediaType.Download) {
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+                res = MediaStore.Downloads.getContentUri(MediaStore.VOLUME_EXTERNAL_PRIMARY);
+            }
+        }
+
+        return res;
+    }
+
+    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, ReactApplicationContext ctx) {
+        // Add a specific media item.
+        Context appCtx = ReactNativeBlobUtil.RCTContext.getApplicationContext();
+        ContentResolver resolver = appCtx.getContentResolver();
+
+        ContentValues fileDetails = new ContentValues();
+        String relativePath = getRelativePath(mt, ctx);
+        String mimeType = file.mimeType;
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+            fileDetails.put(MediaStore.MediaColumns.DATE_ADDED, System.currentTimeMillis() / 1000);
+            fileDetails.put(MediaStore.MediaColumns.DATE_MODIFIED, System.currentTimeMillis() / 1000);
+            fileDetails.put(MediaStore.MediaColumns.MIME_TYPE, mimeType);
+            fileDetails.put(MediaStore.MediaColumns.DISPLAY_NAME, file.name);
+            fileDetails.put(MediaStore.MediaColumns.RELATIVE_PATH, relativePath + '/' + file.partentFolder);
+
+            Uri mediauri = getMediaUri(mt);
+
+            // Keeps a handle to the new file's URI in case we need to modify it later.
+            return resolver.insert(mediauri, fileDetails);
+        } else {
+            File f = new File(relativePath + file.getFullPath());
+            if (true) {
+                if (!f.exists()) {
+                    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);
+                }
+
+            }
+        }
+
+        return null;
+    }
+
+    public static boolean writeToMediaFile(Uri fileUri, String data, Promise promise) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+            try {
+                Context appCtx = ReactNativeBlobUtil.RCTContext.getApplicationContext();
+                ContentResolver resolver = appCtx.getContentResolver();
+
+                // 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;
+
+                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 + "')");
+                            return false;
+                        }
+                        byte[] buf = new byte[10240];
+                        int read;
+
+                        FileInputStream fin = new FileInputStream(src);
+                        FileOutputStream out = new FileOutputStream(descr.getFileDescriptor());
+
+                        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;
+                    }
+
+                    //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;
+                    }
+                } 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();
+                    }
+                }
+
+                // 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);
+        }
+    }
+
+    public static void copyToInternal(Uri contenturi, String destpath, Promise promise) {
+        Context appCtx = ReactNativeBlobUtil.RCTContext.getApplicationContext();
+        ContentResolver resolver = appCtx.getContentResolver();
+
+        InputStream in = null;
+        OutputStream out = null;
+        File f = new File((destpath));
+
+        if (!f.exists()) {
+            try {
+                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;
+                }
+            } catch (IOException ioException) {
+                promise.reject("ReactNativeBlobUtil.copyToInternal: Could not create file: " + ioException.getLocalizedMessage());
+            }
+        }
+
+        try {
+            in = resolver.openInputStream(contenturi);
+            out = new FileOutputStream(destpath);
+
+            byte[] buf = new byte[10240];
+            int len;
+            while ((len = in.read(buf)) > 0) {
+                out.write(buf, 0, len);
+            }
+
+        } catch (IOException e) {
+            promise.reject("ReactNativeBlobUtil.copyToInternal:  Could not write data: " + e.getLocalizedMessage());
+        } finally {
+            if (in != null) {
+                try {
+                    in.close();
+                } catch (IOException ioException) {
+                    ioException.printStackTrace();
+                }
+            }
+            if (out != null) {
+                try {
+                    out.close();
+                } catch (IOException ioException) {
+                    ioException.printStackTrace();
+                }
+            }
+        }
+
+        promise.resolve("");
+    }
+
+    public static void getBlob(Uri contentUri, String encoding, Promise promise) {
+        Context appCtx = ReactNativeBlobUtil.RCTContext.getApplicationContext();
+        ContentResolver resolver = appCtx.getContentResolver();
+        try {
+            InputStream in = resolver.openInputStream(contentUri);
+            int length = in.available();
+
+            byte[] bytes = new byte[length];
+            int bytesRead = in.read(bytes);
+            in.close();
+
+            if (bytesRead < length) {
+                promise.reject("EUNSPECIFIED", "Read only " + bytesRead + " bytes of " + length);
+                return;
+            }
+
+            switch (encoding.toLowerCase()) {
+                case "base64":
+                    promise.resolve(Base64.encodeToString(bytes, Base64.NO_WRAP));
+                    break;
+                case "ascii":
+                    WritableArray asciiResult = Arguments.createArray();
+                    for (byte b : bytes) {
+                        asciiResult.pushInt(b);
+                    }
+                    promise.resolve(asciiResult);
+                    break;
+                default: // covers utf-8
+                    promise.resolve(new String(bytes));
+                    break;
+            }
+        } catch (IOException ioException) {
+            ioException.printStackTrace();
+        }
+    }
+}

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

@@ -1,5 +1,7 @@
 package com.ReactNativeBlobUtil;
 
+import androidx.annotation.NonNull;
+
 import com.facebook.react.ReactPackage;
 import com.facebook.react.bridge.JavaScriptModule;
 import com.facebook.react.bridge.NativeModule;
@@ -13,8 +15,9 @@ import java.util.List;
 
 public class ReactNativeBlobUtilPackage implements ReactPackage {
 
+    @NonNull
     @Override
-    public List<NativeModule> createNativeModules(ReactApplicationContext reactContext) {
+    public List<NativeModule> createNativeModules(@NonNull ReactApplicationContext reactContext) {
         List<NativeModule> modules = new ArrayList<>();
         modules.add(new ReactNativeBlobUtil(reactContext));
         return modules;
@@ -24,8 +27,9 @@ public class ReactNativeBlobUtilPackage implements ReactPackage {
         return Collections.emptyList();
     }
 
+    @NonNull
     @Override
-    public List<ViewManager> createViewManagers(ReactApplicationContext reactContext) {
+    public List<ViewManager> createViewManagers(@NonNull ReactApplicationContext reactContext) {
         return Collections.emptyList();
     }
 

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

@@ -30,33 +30,27 @@ import com.facebook.react.bridge.WritableArray;
 import com.facebook.react.bridge.WritableMap;
 import com.facebook.react.modules.core.DeviceEventManagerModule;
 
-import javax.net.ssl.TrustManagerFactory;
-import javax.net.ssl.TrustManager;
-import javax.net.ssl.X509TrustManager;
-import javax.net.ssl.SSLContext;
-
 import java.io.File;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.net.MalformedURLException;
+import java.net.Proxy;
 import java.net.SocketException;
 import java.net.SocketTimeoutException;
 import java.net.URL;
-import java.net.Proxy;
 import java.nio.ByteBuffer;
 import java.nio.charset.CharacterCodingException;
 import java.nio.charset.Charset;
 import java.nio.charset.CharsetDecoder;
-import java.security.KeyStore;
 import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
 import java.util.HashMap;
 
+import java.util.List;
+import java.util.Locale;
 import java.util.concurrent.TimeUnit;
 
-import javax.net.ssl.SSLSocketFactory;
+import javax.net.ssl.SSLContext;
 
 import okhttp3.Call;
 import okhttp3.ConnectionPool;
@@ -120,7 +114,7 @@ public class ReactNativeBlobUtilReq extends BroadcastReceiver implements Runnabl
     OkHttpClient client;
 
     public ReactNativeBlobUtilReq(ReadableMap options, String taskId, String method, String url, ReadableMap headers, String body, ReadableArray arrayBody, OkHttpClient client, final Callback callback) {
-        this.method = method.toUpperCase();
+        this.method = method.toUpperCase(Locale.ROOT);
         this.options = new ReactNativeBlobUtilConfig(options);
         this.taskId = taskId;
         this.url = url;
@@ -196,7 +190,7 @@ public class ReactNativeBlobUtilReq extends BroadcastReceiver implements Runnabl
                     req.addRequestHeader(key, headers.getString(key));
                 }
                 // Attempt to add cookie, if it exists
-                URL urlObj = null;
+                URL urlObj;
                 try {
                     urlObj = new URL(url);
                     String baseUrl = urlObj.getProtocol() + "://" + urlObj.getHost();
@@ -311,14 +305,14 @@ public class ReactNativeBlobUtilReq extends BroadcastReceiver implements Runnabl
                         else if (value.equalsIgnoreCase("utf8"))
                             responseFormat = ResponseFormat.UTF8;
                     } else {
-                        builder.header(key.toLowerCase(), value);
-                        mheaders.put(key.toLowerCase(), value);
+                        builder.header(key.toLowerCase(Locale.ROOT), value);
+                        mheaders.put(key.toLowerCase(Locale.ROOT), value);
                     }
                 }
             }
 
             if (method.equalsIgnoreCase("post") || method.equalsIgnoreCase("put") || method.equalsIgnoreCase("patch")) {
-                String cType = getHeaderIgnoreCases(mheaders, "Content-Type").toLowerCase();
+                String cType = getHeaderIgnoreCases(mheaders, "Content-Type").toLowerCase(Locale.ROOT);
 
                 if (rawRequestBodyArray != null) {
                     requestType = RequestType.Form;
@@ -332,7 +326,7 @@ public class ReactNativeBlobUtilReq extends BroadcastReceiver implements Runnabl
                     if (rawRequestBody.startsWith(ReactNativeBlobUtilConst.FILE_PREFIX)
                             || rawRequestBody.startsWith(ReactNativeBlobUtilConst.CONTENT_PREFIX)) {
                         requestType = RequestType.SingleFile;
-                    } else if (cType.toLowerCase().contains(";base64") || cType.toLowerCase().startsWith("application/octet")) {
+                    } else if (cType.toLowerCase(Locale.ROOT).contains(";base64") || cType.toLowerCase(Locale.ROOT).startsWith("application/octet")) {
                         cType = cType.replace(";base64", "").replace(";BASE64", "");
                         if (mheaders.containsKey("content-type"))
                             mheaders.put("content-type", cType);
@@ -388,14 +382,16 @@ public class ReactNativeBlobUtilReq extends BroadcastReceiver implements Runnabl
             // #156 fix cookie issue
             final Request req = builder.build();
             clientBuilder.addNetworkInterceptor(new Interceptor() {
+                @NonNull
                 @Override
-                public Response intercept(Chain chain) throws IOException {
+                public Response intercept(@NonNull Chain chain) throws IOException {
                     redirects.add(chain.request().url().toString());
                     return chain.proceed(chain.request());
                 }
             });
             // Add request interceptor for upload progress event
             clientBuilder.addInterceptor(new Interceptor() {
+                @NonNull
                 @Override
                 public Response intercept(@NonNull Chain chain) throws IOException {
                     Response originalResponse = null;
@@ -467,7 +463,7 @@ public class ReactNativeBlobUtilReq extends BroadcastReceiver implements Runnabl
             call.enqueue(new okhttp3.Callback() {
 
                 @Override
-                public void onFailure(@NonNull Call call, IOException e) {
+                public void onFailure(@NonNull Call call, @NonNull IOException e) {
                     cancelTask(taskId);
                     if (respInfo == null) {
                         respInfo = Arguments.createMap();
@@ -718,7 +714,7 @@ public class ReactNativeBlobUtilReq extends BroadcastReceiver implements Runnabl
         boolean isCustomBinary = false;
         if (options.binaryContentTypes != null) {
             for (int i = 0; i < options.binaryContentTypes.size(); i++) {
-                if (ctype.toLowerCase().contains(options.binaryContentTypes.getString(i).toLowerCase())) {
+                if (ctype.toLowerCase(Locale.ROOT).contains(options.binaryContentTypes.getString(i).toLowerCase(Locale.ROOT))) {
                     isCustomBinary = true;
                     break;
                 }
@@ -730,13 +726,13 @@ public class ReactNativeBlobUtilReq extends BroadcastReceiver implements Runnabl
     private String getHeaderIgnoreCases(Headers headers, String field) {
         String val = headers.get(field);
         if (val != null) return val;
-        return headers.get(field.toLowerCase()) == null ? "" : headers.get(field.toLowerCase());
+        return headers.get(field.toLowerCase(Locale.ROOT)) == null ? "" : headers.get(field.toLowerCase(Locale.ROOT));
     }
 
     private String getHeaderIgnoreCases(HashMap<String, String> headers, String field) {
         String val = headers.get(field);
         if (val != null) return val;
-        String lowerCasedValue = headers.get(field.toLowerCase());
+        String lowerCasedValue = headers.get(field.toLowerCase(Locale.ROOT));
         return lowerCasedValue == null ? "" : lowerCasedValue;
     }