@ammarahmed/react-native-upload 6.16.0 → 6.17.0

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1 @@
+<manifest />

package/android/src/main/java/com/appfolio/extensions/ContextExtensions.kt

@@ -0,0 +1,63 @@
+package com.appfolio.extensions
+
+import android.content.Context
+import com.appfolio.work.TaskCompletionNotifier
+import com.appfolio.work.UploadManager
+import net.gotev.uploadservice.UploadTask
+import net.gotev.uploadservice.data.UploadNotificationConfig
+import net.gotev.uploadservice.data.UploadTaskParameters
+import net.gotev.uploadservice.logger.UploadServiceLogger
+import net.gotev.uploadservice.observer.task.BroadcastEmitter
+
+data class UploadTaskCreationParameters(
+    val params: UploadTaskParameters,
+    val notificationConfig: UploadNotificationConfig
+)
+
+/**
+ * Creates a new task instance based on the requested task class in the intent.
+ * @param creationParameters task creation params
+ * @return task instance or null if the task class is not supported or invalid
+ */
+@Suppress("UNCHECKED_CAST")
+fun Context.getUploadTask(
+    creationParameters: UploadTaskCreationParameters,
+    notificationId: Int
+): UploadTask? {
+    return try {
+        val observers = arrayOf(
+            BroadcastEmitter(this),
+            TaskCompletionNotifier()
+        )
+
+        val taskClass = Class.forName(creationParameters.params.taskClass) as Class<out UploadTask>
+        val uploadTask = taskClass.newInstance().apply {
+            init(
+                context = this@getUploadTask,
+                taskParams = creationParameters.params,
+                notificationConfig = creationParameters.notificationConfig,
+                notificationId = notificationId,
+                taskObservers = observers
+            )
+        }
+
+        UploadServiceLogger.debug(
+            component = UploadManager.TAG,
+            uploadId = creationParameters.params.id,
+            message = {
+                "Successfully created new task with class: ${taskClass.name}"
+            }
+        )
+        uploadTask
+    } catch (exc: Throwable) {
+        UploadServiceLogger.error(
+            component = UploadManager.TAG,
+            uploadId = "",
+            exception = exc,
+            message = {
+                "Error while instantiating new task"
+            }
+        )
+        null
+    }
+}

package/android/src/main/java/com/appfolio/extensions/UploadExtensions.kt

@@ -0,0 +1,57 @@
+package com.appfolio.extensions
+
+import androidx.work.Constraints
+import androidx.work.Data
+import androidx.work.NetworkType
+import androidx.work.OneTimeWorkRequest
+import com.google.gson.Gson
+import net.gotev.uploadservice.data.UploadFile
+import net.gotev.uploadservice.data.UploadNotificationConfig
+import net.gotev.uploadservice.data.UploadTaskParameters
+import net.gotev.uploadservice.extensions.setOrRemove
+import net.gotev.uploadservice.persistence.PersistableData
+
+private const val PROPERTY_PARAM_NAME = "multipartParamName"
+private const val PROPERTY_REMOTE_FILE_NAME = "multipartRemoteFileName"
+private const val PROPERTY_CONTENT_TYPE = "multipartContentType"
+const val PARAM_KEY_TASK_PARAMS = "PARAM_KEY_TASK_PARAMS"
+const val PARAM_KEY_NOTIF_CONFIG = "PARAM_KEY_NOTIF_CONFIG"
+
+internal var UploadFile.parameterName: String?
+  get() = properties[PROPERTY_PARAM_NAME]
+  set(value) {
+    properties.setOrRemove(PROPERTY_PARAM_NAME, value)
+  }
+
+internal var UploadFile.remoteFileName: String?
+  get() = properties[PROPERTY_REMOTE_FILE_NAME]
+  set(value) {
+    properties.setOrRemove(PROPERTY_REMOTE_FILE_NAME, value)
+  }
+
+internal var UploadFile.contentType: String?
+  get() = properties[PROPERTY_CONTENT_TYPE]
+  set(value) {
+    properties.setOrRemove(PROPERTY_CONTENT_TYPE, value)
+  }
+
+internal fun UploadTaskParameters.toJson(): String = toPersistableData().toJson()
+
+internal fun String.toUploadTaskParameters(): UploadTaskParameters = UploadTaskParameters.createFromPersistableData(PersistableData.fromJson(this))
+
+internal fun UploadNotificationConfig.toJson(): String = Gson().toJson(this)
+
+internal fun String.toUploadNotificationConfig() = Gson().fromJson(this, UploadNotificationConfig::class.java)
+
+internal fun OneTimeWorkRequest.Builder.setData(uploadTaskParameters: UploadTaskParameters, notificationConfig: UploadNotificationConfig) {
+  val data = Data.Builder()
+  data.putString(PARAM_KEY_TASK_PARAMS, uploadTaskParameters.toJson())
+  data.putString(PARAM_KEY_NOTIF_CONFIG, notificationConfig.toJson())
+  setInputData(data.build())
+}
+
+internal fun OneTimeWorkRequest.Builder.shouldLimitNetwork(limit: Boolean) {
+  val network = if (limit) NetworkType.UNMETERED else NetworkType.CONNECTED
+  val constraints = Constraints.Builder().setRequiredNetworkType(network).build()
+  setConstraints(constraints)
+}

package/android/src/main/java/com/appfolio/uploader/GlobalRequestObserverDelegate.kt

@@ -0,0 +1,62 @@
+package com.appfolio.uploader
+
+import android.content.Context
+import android.util.Log
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.modules.core.DeviceEventManagerModule.RCTDeviceEventEmitter
+import net.gotev.uploadservice.data.UploadInfo
+import net.gotev.uploadservice.network.ServerResponse
+import net.gotev.uploadservice.observer.request.RequestObserverDelegate
+
+class GlobalRequestObserverDelegate(reactContext: ReactApplicationContext) : RequestObserverDelegate {
+  private val TAG = "UploadReceiver"
+
+  private var reactContext: ReactApplicationContext = reactContext
+
+  override fun onCompleted(context: Context, uploadInfo: UploadInfo) {
+  }
+
+  override fun onCompletedWhileNotObserving() {
+  }
+
+  override fun onError(context: Context, uploadInfo: UploadInfo, exception: Throwable) {
+
+    val params = Arguments.createMap()
+    params.putString("id", uploadInfo.uploadId)
+
+    // Make sure we do not try to call getMessage() on a null object
+    if (exception != null) {
+      params.putString("error", exception.message)
+    } else {
+      params.putString("error", "Unknown exception")
+    }
+
+    sendEvent("error", params, context)
+  }
+
+  override fun onProgress(context: Context, uploadInfo: UploadInfo) {
+    val params = Arguments.createMap()
+    params.putString("id", uploadInfo.uploadId)
+    params.putInt("progress", uploadInfo.progressPercent) //0-100
+
+    sendEvent("progress", params, context)
+  }
+
+  override fun onSuccess(context: Context, uploadInfo: UploadInfo, serverResponse: ServerResponse) {
+    val params = Arguments.createMap()
+    params.putString("id", uploadInfo.uploadId)
+    params.putInt("responseCode", serverResponse.code)
+    params.putString("responseBody", serverResponse.bodyString)
+    sendEvent("completed", params, context)
+  }
+
+  /**
+   * Sends an event to the JS module.
+   */
+  private fun sendEvent(eventName: String, params: WritableMap?, context: Context) {
+    reactContext?.getJSModule(RCTDeviceEventEmitter::class.java)?.emit("RNFileUploader-$eventName", params)
+            ?: Log.e(TAG, "sendEvent() failed due reactContext == null!")
+  }
+}

package/android/src/main/java/com/appfolio/uploader/ModifiedBinaryUploadRequest.kt

@@ -0,0 +1,29 @@
+package com.appfolio.uploader
+import android.content.Context
+import net.gotev.uploadservice.UploadTask
+import net.gotev.uploadservice.data.UploadFile
+import net.gotev.uploadservice.protocols.binary.BinaryUploadRequest
+import net.gotev.uploadservice.protocols.binary.BinaryUploadTask
+import java.io.FileNotFoundException
+import java.io.IOException
+
+class ModifiedBinaryUploadRequest(context: Context, serverUrl: String, limitNetwork: Boolean) :
+    ModifiedHttpUploadRequest<ModifiedBinaryUploadRequest>(context, serverUrl, limitNetwork) {
+
+  override val taskClass: Class<out UploadTask>
+    get() = BinaryUploadTask::class.java
+
+  /**
+   * Sets the file used as raw body of the upload request.
+   *
+   * @param path path to the file that you want to upload
+   * @throws FileNotFoundException if the file to upload does not exist
+   * @return [BinaryUploadRequest]
+   */
+  @Throws(IOException::class)
+  fun setFileToUpload(path: String): ModifiedBinaryUploadRequest {
+    files.clear()
+    files.add(UploadFile(path))
+    return this
+  }
+}

package/android/src/main/java/com/appfolio/uploader/ModifiedHttpUploadRequest.kt

@@ -0,0 +1,57 @@
+package com.appfolio.uploader
+
+import android.content.Context
+import androidx.work.OneTimeWorkRequest
+import androidx.work.WorkManager
+import com.appfolio.extensions.setData
+import com.appfolio.extensions.shouldLimitNetwork
+import com.appfolio.work.UploadManager
+import com.appfolio.work.UploadWorker
+import net.gotev.uploadservice.HttpUploadRequest
+import net.gotev.uploadservice.data.UploadTaskParameters
+import java.util.*
+
+abstract class ModifiedHttpUploadRequest<B : HttpUploadRequest<B>>(context: Context, serverUrl: String, private val limitNetwork: Boolean = false) :
+    HttpUploadRequest<B>(context, serverUrl) {
+
+  private var started: Boolean = false
+  private var uploadId = UUID.randomUUID().toString()
+  private val uploadTaskParameters: UploadTaskParameters
+    get() = UploadTaskParameters(
+        taskClass = taskClass.name,
+        id = uploadId,
+        serverUrl = serverUrl,
+        maxRetries = maxRetries,
+        autoDeleteSuccessfullyUploadedFiles = autoDeleteSuccessfullyUploadedFiles,
+        files = files,
+        additionalParameters = getAdditionalParameters()
+    )
+
+  override fun startUpload(): String {
+    require(files.isNotEmpty()) { "Set the file to be used in the request body first!" }
+    check(!started) {
+      "You have already called startUpload() on this Upload request instance once and you " +
+          "cannot call it multiple times. Check your code."
+    }
+
+    check(!UploadManager.taskList.contains(uploadTaskParameters.id)) {
+      "You have tried to perform startUpload() using the same uploadID of an " +
+          "already running task. You're trying to use the same ID for multiple uploads."
+    }
+
+    started = true
+    val workManager: WorkManager = WorkManager.getInstance(context)
+    val uploadRequest = OneTimeWorkRequest.Builder(UploadWorker::class.java)
+    uploadRequest.shouldLimitNetwork(limitNetwork)
+    uploadRequest.addTag("${UploadWorker::class.java.simpleName}-$uploadId")
+    uploadRequest.setData(uploadTaskParameters, notificationConfig(context, uploadId))
+    workManager.enqueue(uploadRequest.build())
+
+    return uploadTaskParameters.id;
+  }
+
+  fun setCustomUploadID(uploadID: String) {
+    this.uploadId = uploadID
+    setUploadID(uploadID)
+  }
+}

package/android/src/main/java/com/appfolio/uploader/ModifiedMultipartUploadRequest.kt

@@ -0,0 +1,60 @@
+package com.appfolio.uploader
+
+import android.content.Context
+import com.appfolio.extensions.contentType
+import com.appfolio.extensions.parameterName
+import com.appfolio.extensions.remoteFileName
+import net.gotev.uploadservice.UploadTask
+import net.gotev.uploadservice.data.UploadFile
+import net.gotev.uploadservice.protocols.multipart.MultipartUploadTask
+import java.io.FileNotFoundException
+
+class ModifiedMultipartUploadRequest(context: Context, serverUrl: String, limitNetwork: Boolean)  :
+    ModifiedHttpUploadRequest<ModifiedMultipartUploadRequest>(context, serverUrl, limitNetwork) {
+
+  override val taskClass: Class<out UploadTask>
+    get() = MultipartUploadTask::class.java
+
+  /**
+   * Adds a file to this upload request.
+   *
+   * @param filePath path to the file that you want to upload
+   * @param parameterName Name of the form parameter that will contain file's data
+   * @param fileName File name seen by the server side script. If null, the original file name
+   * will be used
+   * @param contentType Content type of the file. If null or empty, the mime type will be
+   * automatically detected. If fore some reasons autodetection fails,
+   * `application/octet-stream` will be used by default
+   * @return [ModifiedMultipartUploadRequest]
+   */
+  @Throws(FileNotFoundException::class)
+  @JvmOverloads
+  fun addFileToUpload(
+      filePath: String,
+      parameterName: String,
+      fileName: String? = null,
+      contentType: String? = null
+  ): ModifiedMultipartUploadRequest {
+    require(filePath.isNotBlank() && parameterName.isNotBlank()) {
+      "Please specify valid filePath and parameterName. They cannot be blank."
+    }
+
+    files.add(UploadFile(filePath).apply {
+      this.parameterName = parameterName
+
+      this.contentType = if (contentType.isNullOrBlank()) {
+        handler.contentType(context)
+      } else {
+        contentType
+      }
+
+      remoteFileName = if (fileName.isNullOrBlank()) {
+        handler.name(context)
+      } else {
+        fileName
+      }
+    })
+
+    return this
+  }
+}