Releases/v1.0.0

app/build.gradle

@@ -38,7 +38,7 @@ android {
  compose true
  }
  composeOptions {
- kotlinCompilerExtensionVersion '1.5.9'
+ kotlinCompilerExtensionVersion '1.5.14'
  }
  packagingOptions {
  resources {

app/src/main/AndroidManifest.xml

@@ -2,14 +2,21 @@
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
  xmlns:tools="http://schemas.android.com/tools">
 
+ <!--
+ todo: New/Optional Stuff from U and V
+ * Selected Photos Access
+ * Media Processing FG Service type (w/mandatory timeout)
+ -->
+
  <uses-permission android:name="android.permission.READ_MEDIA_VIDEO" />
  <uses-permission android:name="android.permission.READ_MEDIA_AUDIO" />
  <uses-permission
  android:name="android.permission.READ_EXTERNAL_STORAGE"
  android:maxSdkVersion="32" />
  <uses-permission
  android:name="android.permission.WRITE_EXTERNAL_STORAGE"
- android:maxSdkVersion="29" />
+ android:maxSdkVersion="28" />
+ <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
 
  <application
  android:name=".UploadExampleApp"
@@ -51,6 +58,11 @@
  <category android:name="android.intent.category.LAUNCHER" />
  </intent-filter>
  </activity>
+ <service android:name=".UploadNotificationService"
+ android:exported="false"
+ android:foregroundServiceType="dataSync"
+ >
+ </service>
  </application>
 
 </manifest>

app/src/main/java/com/mux/video/vod/demo/UploadExampleApp.kt

@@ -1,11 +1,34 @@
 package com.mux.video.vod.demo
 
+import android.annotation.TargetApi
 import android.app.Application
+import android.app.NotificationChannel
+import android.app.NotificationManager
+import android.os.Build
 import com.mux.video.upload.MuxUploadSdk
+import com.mux.video.upload.api.MuxUploadManager
 
 class UploadExampleApp : Application() {
+
  override fun onCreate() {
  super.onCreate()
+ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+ createNotificationChannel()
+ }
  MuxUploadSdk.initialize(this)
+ if (MuxUploadManager.allUploadJobs().isNotEmpty()) {
+ UploadNotificationService.startCompat(this)
+ }
+ }
+
+ @TargetApi(Build.VERSION_CODES.O)
+ private fun createNotificationChannel() {
+ val channel = NotificationChannel(
+ UploadNotificationService.CHANNEL_UPLOAD_PROGRESS,
+ getString(R.string.notif_channel_name),
+ NotificationManager.IMPORTANCE_LOW
+ )
+ channel.description = getString(R.string.notif_channel_desc)
+ getSystemService(NotificationManager::class.java).createNotificationChannel(channel)
  }
 }

app/src/main/java/com/mux/video/vod/demo/UploadNotificationService.kt

@@ -0,0 +1,221 @@
+package com.mux.video.vod.demo
+
+import android.annotation.SuppressLint
+import android.annotation.TargetApi
+import android.app.Service
+import android.content.Context
+import android.content.Intent
+import android.content.pm.ServiceInfo
+import android.os.Binder
+import android.os.Build
+import android.os.IBinder
+import android.util.Log
+import androidx.core.app.NotificationCompat
+import androidx.core.app.ServiceCompat
+import com.mux.video.upload.api.MuxUpload
+import com.mux.video.upload.api.MuxUploadManager
+import com.mux.video.upload.api.UploadEventListener
+import com.mux.video.upload.api.UploadStatus
+
+/**
+ * Service that monitors ongoing [MuxUpload]s, showing progress notifications for them. This
+ * service will enter the foreground whenever there are uploads in progress and will exit foreground
+ * and stop itself when there are no more uploads in progress (ie, all have completed, paused, or
+ * failed)
+ */
+class UploadNotificationService : Service() {
+
+ companion object {
+ private const val TAG = "BackgroundUploadService"
+
+ const val ACTION_START = "start"
+ const val NOTIFICATION_FG = 200002
+ const val CHANNEL_UPLOAD_PROGRESS = "upload_progress"
+
+ fun startCompat(context: Context) {
+ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+ startImplApiO(context)
+ } else {
+ startImplLegacy(context)
+ }
+ }
+
+ @TargetApi(Build.VERSION_CODES.O)
+ private fun startImplApiO(context: Context) {
+ val startIntent = Intent(context, UploadNotificationService::class.java)
+ startIntent.action = ACTION_START
+ context.startForegroundService(startIntent)
+ }
+
+ private fun startImplLegacy(context: Context) {
+ val startIntent = Intent(context, UploadNotificationService::class.java)
+ startIntent.action = ACTION_START
+ context.startService(startIntent)
+ }
+ }
+
+ private var uploadListListener: UploadListListener? = null
+ // uploads tracked by this Service, regardless of state. cleared when the service is destroyed
+ private val uploadsByFile = mutableMapOf<String, MuxUpload>()
+
+ override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
+ val action = intent?.action
+ if (action != ACTION_START) {
+ throw RuntimeException("Unknown action")
+ }
+
+ // can be commanded to start arbitrary number of times
+ if (uploadListListener == null) {
+ notify(MuxUploadManager.allUploadJobs())
+
+ val lis = UploadListListener()
+ this.uploadListListener = lis
+ MuxUploadManager.addUploadsUpdatedListener(lis)
+ }
+
+ return super.onStartCommand(intent, flags, startId)
+ }
+
+ override fun onBind(intent: Intent?): IBinder? {
+ return MyBinder()
+ }
+
+ override fun onDestroy() {
+ uploadListListener?.let { MuxUploadManager.removeUploadsUpdatedListener(it) }
+ }
+
+ private fun notifyWithCurrentUploads() = notify(this.uploadsByFile.values)
+
+ @SuppressLint("InlinedApi", "MissingPermission") // inline use of FOREGROUND_SERVICE
+ private fun notify(uploads: Collection<MuxUpload>) {
+ if (uploads.isEmpty()) {
+ // only notify if there are uploads being tracked (in-progress or finished)
+ return
+ }
+
+ val uploadsInProgress = uploads.filter { it.isRunning }
+ val uploadsCompleted = uploads.filter { it.isSuccessful }
+ val uploadsFailed = uploads.filter { it.error != null }
+
+ Log.v(TAG, "notify: uploadsInProgress: ${uploadsInProgress.size}")
+ Log.v(TAG, "notify: uploadsCompleted: ${uploadsCompleted.size}")
+ Log.v(TAG, "notify: uploadsFailed: ${uploadsFailed.size}")
+
+ val builder = NotificationCompat.Builder(this, CHANNEL_UPLOAD_PROGRESS)
+ builder.setSmallIcon(R.drawable.ic_launcher)
+ builder.setAutoCancel(false)
+ builder.setOngoing(true)
+
+ if (uploadsInProgress.isNotEmpty()) {
+ Log.d(TAG, "notifying progress")
+ if (uploadsInProgress.size == 1 && this.uploadsByFile.size == 1) {
+ // Special case: A single upload in progress, with a single upload requested
+ val upload = uploadsInProgress.first()
+ val kbUploaded = (upload.currentProgress.bytesUploaded / 1024).toInt()
+ val kbTotal = (upload.currentProgress.totalBytes / 1024).toInt()
+
+ Log.d(TAG, "upload state: ${upload.uploadStatus}")
+
+ builder.setProgress(kbTotal, kbUploaded, false)
+ builder.setContentText(
+ resources.getQuantityString(
+ R.plurals.notif_txt_uploading, 1, 1, 1
+ )
+ )
+ builder.setContentTitle(
+ resources.getQuantityString(
+ R.plurals.notif_title_uploading, 1, 1
+ )
+ )
+ } else {
+ // Multiple uploads requested simultaneously so we batch them into one
+ val totalKbUploaded = uploadsInProgress.sumOf { it.currentProgress.bytesUploaded / 1024 }
+ val totalKb = uploadsInProgress.sumOf { it.currentProgress.totalBytes / 1024 }
+
+ builder.setProgress(totalKb.toInt(),totalKbUploaded.toInt(), false)
+ builder.setContentText(
+ resources.getQuantityString(
+ R.plurals.notif_txt_uploading,
+ uploads.size,
+ uploadsInProgress.size,
+ )
+ )
+ builder.setContentTitle(
+ resources.getQuantityString(
+ R.plurals.notif_title_uploading, uploads.size,
+ uploads.size
+ )
+ )
+ }
+ } else if (uploadsFailed.isNotEmpty()) {
+ Log.i(TAG, "notifying Fail")
+ builder.setContentTitle(
+ resources.getQuantityString(
+ R.plurals.notif_title_failed,
+ uploadsFailed.size,
+ uploadsFailed.size
+ )
+ )
+ builder.setContentText(
+ resources.getQuantityString(
+ R.plurals.notif_txt_failed,
+ uploadsFailed.size,
+ uploadsFailed.size
+ )
+ )
+ } else if (uploadsCompleted.isNotEmpty()) {
+ Log.i(TAG, "notifying Complete")
+ builder.setContentText(getString(R.string.notif_txt_success))
+ builder.setContentTitle(
+ resources.getQuantityString(
+ R.plurals.notif_title_success,
+ uploadsCompleted.size,
+ uploadsCompleted.size,
+ )
+ )
+ }
+
+ // always startForeground even if we're about to detach (to update the notification)
+ ServiceCompat.startForeground(
+ this,
+ NOTIFICATION_FG,
+ builder.build(),
+ ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC
+ )
+
+ if (uploadsInProgress.isEmpty()) {
+ // we only need foreground/to even be running while uploads are actually running
+ ServiceCompat.stopForeground(this, ServiceCompat.STOP_FOREGROUND_DETACH)
+ stopSelf()
+ }
+ }
+
+ private fun updateCurrentUploads(incomingUploads: List<MuxUpload>) {
+ // listen to status of new uploads
+ incomingUploads
+ .filter { !this.uploadsByFile.containsKey(it.videoFile.path) }
+ .forEach {
+ this.uploadsByFile[it.videoFile.path] = it
+ it.setStatusListener(UploadStatusListener())
+ }
+ }
+
+ private inner class UploadListListener : UploadEventListener<List<MuxUpload>> {
+ override fun onEvent(event: List<MuxUpload>) {
+ val service = this@UploadNotificationService
+ service.updateCurrentUploads(event)
+ service.notifyWithCurrentUploads()
+ }
+ }
+
+ private inner class UploadStatusListener : UploadEventListener<UploadStatus> {
+ override fun onEvent(event: UploadStatus) {
+ val service = this@UploadNotificationService
+ service.notifyWithCurrentUploads()
+ }
+ }
+
+ private inner class MyBinder : Binder() {
+ fun getService(): UploadNotificationService = this@UploadNotificationService
+ }
+}

app/src/main/java/com/mux/video/vod/demo/backend/ImaginaryBackend.kt

@@ -56,8 +56,8 @@ object ImaginaryBackend {
  // note: You shouldn't do basic auth with hard-coded keys in a real app
  private fun basicCredential(): String = Credentials.basic(ACCESS_TOKEN_ID, ACCESS_TOKEN_SECRET)
 
- private const val ACCESS_TOKEN_ID = "YOUR TOKEN ID HERE"
- private const val ACCESS_TOKEN_SECRET = "YOUR TOKEN SECRET HERE"
+ private const val ACCESS_TOKEN_ID = "YOUR ACCESS TOKEN ID HERE"
+ private const val ACCESS_TOKEN_SECRET = "YOUR ACCESS TOKEN SECRET HERE"
 }
 
 private interface ImaginaryWebapp {

app/src/main/java/com/mux/video/vod/demo/upload/screen/UploadListScreen.kt

@@ -53,6 +53,7 @@ import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.sp
 import androidx.lifecycle.viewmodel.compose.viewModel
 import com.mux.video.upload.api.MuxUpload
+import com.mux.video.upload.api.UploadStatus
 import com.mux.video.vod.demo.R
 import com.mux.video.vod.demo.upload.CreateUploadActivity
 import com.mux.video.vod.demo.upload.CreateUploadCta
@@ -175,10 +176,13 @@ private fun ListItemContent(upload: MuxUpload) {
  }
  }
 
+ val uploadState = remember { mutableStateOf(upload.uploadStatus) }
+ upload.setStatusListener { uploadState.value = it }
+
  ListThumbnail(bitmap = bitmap)
- if (upload.isSuccessful) {
+ if (uploadState.value.isSuccessful()) {
  DoneOverlay()
- } else if (upload.error != null) {
+ } else if (uploadState.value.getError() != null) {
  ErrorOverlay(modifier = Modifier.fillMaxSize())
  } else if (upload.isRunning) {
  ProgressOverlay(

app/src/main/java/com/mux/video/vod/demo/upload/viewmodel/CreateUploadViewModel.kt

@@ -3,7 +3,6 @@ package com.mux.video.vod.demo.upload.viewmodel
 import android.app.Application
 import android.database.Cursor
 import android.graphics.Bitmap
-import android.media.MediaMetadataRetriever
 import android.net.Uri
 import android.os.Build
 import android.provider.MediaStore
@@ -13,6 +12,7 @@ import androidx.lifecycle.LiveData
 import androidx.lifecycle.MutableLiveData
 import androidx.lifecycle.viewModelScope
 import com.mux.video.upload.api.MuxUpload
+import com.mux.video.vod.demo.UploadNotificationService
 import com.mux.video.vod.demo.backend.ImaginaryBackend
 import com.mux.video.vod.demo.upload.model.MediaStoreVideo
 import com.mux.video.vod.demo.upload.model.extractThumbnail
@@ -67,14 +67,15 @@ class CreateUploadViewModel(private val app: Application) : AndroidViewModel(app
  ).build()
  // Force restart when creating brand new uploads (because we're making new Direct uploads)
  .start(forceRestart = true)
+
+ UploadNotificationService.startCompat(app)
  }
  }
 
  /**
  * In order to upload a file from the device's media store, the file must be copied into the app's
  * temp directory. (Technically we could stream it from the source, but this prevents the other
  * app from modifying the file if we pause the upload for a long time or whatever)
- * TODO<em> Is this something that should go in the SDK? This is a common workflow
  */
  @Throws
  private suspend fun copyIntoTempFile(contentUri: Uri): File {