The FastPixUploader SDK is a robust Android library designed for chunked file uploads using signed URLs. It simplifies large file uploads by splitting files into smaller chunks, ensuring smooth and reliable transfers with built-in retry and progress tracking mechanisms.

• Chunking: Files are automatically split into chunks (configurable, default size is 16MB/chunk).
• Pause and Resume: Allows temporarily pausing the upload and resuming after a while.
• Retry: Uploads might fail due to temporary network failures. Individual chunks are retried for 5 times with exponential backoff to recover automatically from such failures.
• Lifecycle Event Listeners: Listen to various upload lifecycle events to provide real-time feedback to users.
• Error Handling and Reporting: Comprehensive error handling to manage upload failures gracefully and inform users of issues.
• Customizability: Developers can customize the chunk size and retry attempts based on their specific needs and network conditions.

• Android 5.0 (API 21) or above
• Kotlin project (Java-compatible via interfaces)
• To get started with SDK, you will need a signed URL.
• To make API requests, you'll need a valid Access Token and Secret Key. See the Basic Authentication Guide for details on retrieving these credentials.
• Once you have your credentials, use the Upload media from device API to generate a signed URL for uploading media.

Add the SDK module to your project and include it as a dependency if distributed as an module.

• Add to your app's build.gradle:

dependencies {
 implementation("io.fastpix.upload:x.x.x") //latest version 1.0.1
}

package io.fastpix.uploadsdk

val sdk = FastPixUploadSdk.Builder(this)
 .setFile(file)
 .setSignedUrl(_signedUrl.orEmpty())
 .setChunkSize(16 * 1024 * 1024) // Chunk Size in Byte
 .setMaxRetries(3) 
 .callback(new object : FastPixUploadCallbacks {
 override fun onProgressUpdate(progress: Double) {
 /* ... */
 }
 override fun onPauseUploading() {
 // Handle Pause State
 }
 override fun onResumeUploading() {
 // Handle Resume State
 }
 override fun onAbort() {
 // Handle Abort State
 }
 override fun onUploadInit() {
 // Handle Abort State
 }
 override fun onChunkHanlded(
 totalChunks: Int,
 fileSizeInBytes: Long,
 currentChunk: Int,
 currentChunkSizeInBytes: Long
 ) {
 // Update the UI according chunk data
 }
 override fun onSuccess(timiMillis: Long) {
 // Time to complete the Upload Process
 }
 override fun onChunkUploadingFailed(
 failedChunkRetries: Int,
 chunkCount: Int,
 chunkSize: Int
 ) {
 // Handle Chunk Upload Failure
 }
 override fun onError(error: String, timeMillis: Long) {
 // Handle error message
 }
 override fun onNetworkStateChanged(isOnline: Boolean) {
 // Handle Network Changes
 }
 })
 .setRetryDelay(2000) // Retry Delay 
 .build()
// Starts the Uploading Process
sdk.startUpload()

You can control the upload lifecycle with the following methods:

• Pause an Upload:

  sdk.pauseUpload() // Pauses the current upload

• Resume an Upload:

  sdk.resumeUpload() // Resume the current upload

• Abort an Upload:

  sdk.abort(); // Abort the current upload
  

The upload function accepts the following parameters:

Implement FastPixUploadCallback to handle various upload events:

• Homepage
• Dashboard
• GitHub
• API Reference

For more detailed steps and advanced usage, please refer to the official FastPix Documentation.