FirestackStorage.java

package io.fullstack.firestack;

import android.os.Environment;
import android.os.StatFs;
import android.content.Context;
import android.util.Log;
import java.util.Map;
import java.util.HashMap;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
import java.io.FileNotFoundException;

import android.net.Uri;
import android.provider.MediaStore;
import android.database.Cursor;
import android.support.annotation.NonNull;
import android.support.annotation.Nullable;

import com.facebook.react.bridge.Arguments;
import com.facebook.react.bridge.ReactApplicationContext;
import com.facebook.react.bridge.ReactContextBaseJavaModule;
import com.facebook.react.bridge.ReactMethod;
import com.facebook.react.bridge.Callback;
import com.facebook.react.bridge.WritableMap;
import com.facebook.react.bridge.ReadableMap;
import com.facebook.react.modules.core.DeviceEventManagerModule;
import com.facebook.react.bridge.ReactContext;

import com.google.android.gms.tasks.OnCompleteListener;
import com.google.android.gms.tasks.OnFailureListener;
import com.google.android.gms.tasks.OnSuccessListener;
import com.google.android.gms.tasks.Task;

import com.google.firebase.storage.OnProgressListener;
import com.google.firebase.storage.OnPausedListener;

import com.google.firebase.FirebaseApp;

import com.google.firebase.storage.FirebaseStorage;
import com.google.firebase.storage.UploadTask;

import com.google.firebase.storage.StorageMetadata;
import com.google.firebase.storage.StorageReference;

class FirestackStorage extends ReactContextBaseJavaModule {

  private static final String TAG = "FirestackStorage";
  private static final String DocumentDirectoryPath = "DOCUMENT_DIRECTORY_PATH";
  private static final String ExternalDirectoryPath = "EXTERNAL_DIRECTORY_PATH";
  private static final String ExternalStorageDirectoryPath = "EXTERNAL_STORAGE_DIRECTORY_PATH";
  private static final String PicturesDirectoryPath = "PICTURES_DIRECTORY_PATH";
  private static final String TemporaryDirectoryPath = "TEMPORARY_DIRECTORY_PATH";
  private static final String CachesDirectoryPath = "CACHES_DIRECTORY_PATH";
  private static final String DocumentDirectory = "DOCUMENT_DIRECTORY_PATH";
  private static final String BundlePath = "MAIN_BUNDLE_PATH";

  private static final String FileTypeRegular = "FILETYPE_REGULAR";
  private static final String FileTypeDirectory = "FILETYPE_DIRECTORY";


  private Context context;
  private ReactContext mReactContext;
  private FirebaseApp app;

  public FirestackStorage(ReactApplicationContext reactContext) {
    super(reactContext);

    Log.d(TAG, "Attaching FirestackStorage");
    this.context = reactContext;
    mReactContext = reactContext;

    Log.d(TAG, "New instance");
  }

  @Override
  public String getName() {
    return TAG;
  }

  @ReactMethod
  public void downloadUrl(final String javascriptStorageBucket,
                          final String path,
                          final Callback callback) {
      FirebaseStorage storage = FirebaseStorage.getInstance();
      String storageBucket = storage.getApp().getOptions().getStorageBucket();
      String storageUrl = "gs://"+storageBucket;
      Log.d(TAG, "Storage url " + storageUrl + path);
      final StorageReference storageRef = storage.getReferenceFromUrl(storageUrl);
      final StorageReference fileRef = storageRef.child(path);

      Task<Uri> downloadTask = fileRef.getDownloadUrl();
      downloadTask.addOnSuccessListener(new OnSuccessListener<Uri>() {
        @Override
        public void onSuccess(Uri uri) {
          final WritableMap res = Arguments.createMap();

          res.putString("status", "success");
          res.putString("bucket", storageRef.getBucket());
          res.putString("fullPath", uri.toString());
          res.putString("path", uri.getPath());
          res.putString("url", uri.toString());

          fileRef.getMetadata()
          .addOnSuccessListener(new OnSuccessListener<StorageMetadata>() {
              @Override
              public void onSuccess(final StorageMetadata storageMetadata) {
                Log.d(TAG, "getMetadata success " + storageMetadata);
                res.putString("name", storageMetadata.getName());

                WritableMap metadata = Arguments.createMap();
                metadata.putString("getBucket", storageMetadata.getBucket());
                metadata.putString("getName", storageMetadata.getName());
                metadata.putDouble("sizeBytes", storageMetadata.getSizeBytes());
                metadata.putDouble("created_at", storageMetadata.getCreationTimeMillis());
                metadata.putDouble("updated_at", storageMetadata.getUpdatedTimeMillis());
                metadata.putString("md5hash", storageMetadata.getMd5Hash());
                metadata.putString("encoding", storageMetadata.getContentEncoding());
                res.putString("url", storageMetadata.getDownloadUrl().toString());

                res.putMap("metadata", metadata);
                callback.invoke(null, res);
              }
          }).addOnFailureListener(new OnFailureListener() {
              @Override
              public void onFailure(@NonNull Exception exception) {
                Log.e(TAG, "Failure in download " + exception);
                  callback.invoke(makeErrorPayload(1, exception));
              }
          });

        }
      }).addOnFailureListener(new OnFailureListener() {
        @Override
        public void onFailure(@NonNull Exception exception) {
          Log.e(TAG, "Failed to download file " + exception.getMessage());

          WritableMap err = Arguments.createMap();
          err.putString("status", "error");
          err.putString("description", exception.getLocalizedMessage());

          callback.invoke(err);
        }
      });
  }

  // STORAGE
  @ReactMethod
  public void uploadFile(final String urlStr, final String name, final String filepath, final ReadableMap metadata, final Callback callback) {
    FirebaseStorage storage = FirebaseStorage.getInstance();

    StorageReference storageRef = urlStr!=null ? storage.getReferenceFromUrl(urlStr) : storage.getReference();
    StorageReference fileRef = storageRef.child(name);

Log.i(TAG, "From file: " + filepath + " to " + urlStr + " with name " + name);
    try {
      // InputStream stream = new FileInputStream(new File(filepath));
      Uri file = Uri.fromFile(new File(filepath));

      StorageMetadata.Builder metadataBuilder = new StorageMetadata.Builder();
      Map<String, Object> m = FirestackUtils.recursivelyDeconstructReadableMap(metadata);

      StorageMetadata md = metadataBuilder.build();
      UploadTask uploadTask = fileRef.putFile(file, md);
      // UploadTask uploadTask = fileRef.putStream(stream, md);

      // Register observers to listen for when the download is done or if it fails
      uploadTask.addOnFailureListener(new OnFailureListener() {
        @Override
        public void onFailure(@NonNull Exception exception) {
          // Handle unsuccessful uploads
          Log.e(TAG, "Failed to upload file " + exception.getMessage());

          WritableMap err = Arguments.createMap();
          err.putString("description", exception.getLocalizedMessage());

          callback.invoke(err);
        }
      }).addOnSuccessListener(new OnSuccessListener<UploadTask.TaskSnapshot>() {
        @Override
        public void onSuccess(UploadTask.TaskSnapshot taskSnapshot) {
          Log.d(TAG, "Successfully uploaded file " + taskSnapshot);
          // taskSnapshot.getMetadata() contains file metadata such as size, content-type, and download URL.
          WritableMap resp = getDownloadData(taskSnapshot);
                  // NSDictionary *props = @{
                  //               @"fullPath": ref.fullPath,
                  //               @"bucket": ref.bucket,
                  //               @"name": ref.name,
                  //               @"metadata": [snapshot.metadata dictionaryRepresentation]
                  //               };

          callback.invoke(null, resp);
        }
      })
      .addOnProgressListener(new OnProgressListener<UploadTask.TaskSnapshot>() {
        @Override
        public void onProgress(UploadTask.TaskSnapshot taskSnapshot) {
          double totalBytes = taskSnapshot.getTotalByteCount();
          double bytesTransferred = taskSnapshot.getBytesTransferred();
          double progress = (100.0 * bytesTransferred) / totalBytes;

          System.out.println("Transferred " + bytesTransferred + "/" + totalBytes + "("+progress + "% complete)");

          if (progress >= 0) {
            WritableMap data = Arguments.createMap();
            data.putString("eventName", "upload_progress");
            data.putDouble("progress", progress);
            FirestackUtils.sendEvent(mReactContext, "upload_progress", data);
          }
        }
      }).addOnPausedListener(new OnPausedListener<UploadTask.TaskSnapshot>() {
        @Override
        public void onPaused(UploadTask.TaskSnapshot taskSnapshot) {
          System.out.println("Upload is paused");
          StorageMetadata d = taskSnapshot.getMetadata();
          String bucket = d.getBucket();
          WritableMap data = Arguments.createMap();
          data.putString("eventName", "upload_paused");
          data.putString("ref", bucket);
          FirestackUtils.sendEvent(mReactContext, "upload_paused", data);
        }
      });
    }
    catch (Exception ex) {
      callback.invoke(makeErrorPayload(2, ex));
    }
  }

  @ReactMethod
  public void getRealPathFromURI(final String uri, final Callback callback) {
    try {
      Context context = getReactApplicationContext();
      String [] proj = {MediaStore.Images.Media.DATA};
      Cursor cursor = context.getContentResolver().query(Uri.parse(uri), proj,  null, null, null);
      int column_index = cursor.getColumnIndexOrThrow(MediaStore.Images.Media.DATA);
      cursor.moveToFirst();
      String path = cursor.getString(column_index); 
      cursor.close();
  
      callback.invoke(null, path);
    } catch (Exception ex) {
      ex.printStackTrace();
      callback.invoke(makeErrorPayload(1, ex));
    }
  }

  private WritableMap getDownloadData(final UploadTask.TaskSnapshot taskSnapshot) {
    Uri downloadUrl = taskSnapshot.getDownloadUrl();
    StorageMetadata d = taskSnapshot.getMetadata();

    WritableMap resp = Arguments.createMap();
    resp.putString("downloadUrl", downloadUrl.toString());
    resp.putString("fullPath", d.getPath());
    resp.putString("bucket", d.getBucket());
    resp.putString("name", d.getName());

    WritableMap metadataObj = Arguments.createMap();
    metadataObj.putString("cacheControl", d.getCacheControl());
    metadataObj.putString("contentDisposition", d.getContentDisposition());
    metadataObj.putString("contentType", d.getContentType());
    resp.putMap("metadata", metadataObj);

    return resp;
  }

  private WritableMap makeErrorPayload(double code, Exception ex) {
    WritableMap error = Arguments.createMap();
    error.putDouble("code", code);
    error.putString("message", ex.getMessage());
    return error;
  }

  // Comes almost directory from react-native-fs
  @Override
  public Map<String, Object> getConstants() {
    final Map<String, Object> constants = new HashMap<>();

    constants.put(DocumentDirectory, 0);
    constants.put(DocumentDirectoryPath, this.getReactApplicationContext().getFilesDir().getAbsolutePath());
    constants.put(TemporaryDirectoryPath, null);
    constants.put(PicturesDirectoryPath, Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_PICTURES).getAbsolutePath());
    constants.put(CachesDirectoryPath, this.getReactApplicationContext().getCacheDir().getAbsolutePath());
    constants.put(FileTypeRegular, 0);
    constants.put(FileTypeDirectory, 1);
    constants.put(BundlePath, null);

    File externalStorageDirectory = Environment.getExternalStorageDirectory();
    if (externalStorageDirectory != null) {
        constants.put(ExternalStorageDirectoryPath, externalStorageDirectory.getAbsolutePath());
    } else {
        constants.put(ExternalStorageDirectoryPath, null);
    }

    File externalDirectory = this.getReactApplicationContext().getExternalFilesDir(null);
    if (externalDirectory != null) {
      constants.put(ExternalDirectoryPath, externalDirectory.getAbsolutePath());
    } else {
      constants.put(ExternalDirectoryPath, null);
    }

    return constants;
  }
}