Show recording duration and waveform

.circleci/config.yml

@@ -57,6 +57,9 @@ jobs:
       - run:
           name: Run async unit tests
           command: ./gradlew -PdisablePreDex --no-daemon --max-workers=2 async:testDebug
+      - run:
+          name: Run strings unit tests
+          command: ./gradlew -PdisablePreDex --no-daemon --max-workers=2 strings:testDebug
       - run:
           name: Run material unit tests
           command: ./gradlew -PdisablePreDex --no-daemon --max-workers=2 material:testDebug

async/src/main/java/org/odk/collect/async/CoroutineAndWorkManagerScheduler.kt

@@ -8,36 +8,14 @@ import androidx.work.OneTimeWorkRequest
 import androidx.work.PeriodicWorkRequest
 import androidx.work.WorkInfo
 import androidx.work.WorkManager
-import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.Runnable
-import kotlinx.coroutines.cancel
-import kotlinx.coroutines.delay
-import kotlinx.coroutines.isActive
-import kotlinx.coroutines.launch
-import kotlinx.coroutines.withContext
 import java.util.concurrent.TimeUnit
-import java.util.function.Consumer
-import java.util.function.Supplier
 import kotlin.coroutines.CoroutineContext
 
-class CoroutineAndWorkManagerScheduler(private val foregroundContext: CoroutineContext, private val backgroundContext: CoroutineContext, private val workManager: WorkManager) : Scheduler {
+class CoroutineAndWorkManagerScheduler(foregroundContext: CoroutineContext, backgroundContext: CoroutineContext, private val workManager: WorkManager) : CoroutineScheduler(foregroundContext, backgroundContext) {
 
     constructor(workManager: WorkManager) : this(Dispatchers.Main, Dispatchers.IO, workManager) // Needed for Java construction
 
-    override fun <T> immediate(background: Supplier<T>, foreground: Consumer<T>) {
-        CoroutineScope(foregroundContext).launch {
-            val result = withContext(backgroundContext) { background.get() }
-            foreground.accept(result)
-        }
-    }
-
-    override fun immediate(foreground: java.lang.Runnable) {
-        CoroutineScope(foregroundContext).launch {
-            foreground.run()
-        }
-    }
-
     override fun networkDeferred(tag: String, spec: TaskSpec) {
         val constraints = Constraints.Builder()
             .setRequiredNetworkType(NetworkType.CONNECTED)
@@ -65,19 +43,6 @@ class CoroutineAndWorkManagerScheduler(private val foregroundContext: CoroutineC
         workManager.enqueueUniquePeriodicWork(tag, ExistingPeriodicWorkPolicy.REPLACE, workRequest)
     }
 
-    override fun repeat(foreground: Runnable, repeatPeriod: Long): Cancellable {
-        val repeatScope = CoroutineScope(foregroundContext)
-
-        repeatScope.launch {
-            while (isActive) {
-                foreground.run()
-                delay(repeatPeriod)
-            }
-        }
-
-        return ScopeCancellable(repeatScope)
-    }
-
     override fun cancelDeferred(tag: String) {
         workManager.cancelUniqueWork(tag)
     }
@@ -97,11 +62,3 @@ class CoroutineAndWorkManagerScheduler(private val foregroundContext: CoroutineC
         return false
     }
 }
-
-private class ScopeCancellable(private val scope: CoroutineScope) : Cancellable {
-
-    override fun cancel(): Boolean {
-        scope.cancel()
-        return true
-    }
-}

async/src/main/java/org/odk/collect/async/CoroutineScheduler.kt

@@ -0,0 +1,55 @@
+package org.odk.collect.async
+
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.isActive
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+import java.util.function.Consumer
+import java.util.function.Supplier
+import kotlin.coroutines.CoroutineContext
+
+open class CoroutineScheduler(private val foregroundContext: CoroutineContext, private val backgroundContext: CoroutineContext) : Scheduler {
+
+    override fun <T> immediate(background: Supplier<T>, foreground: Consumer<T>) {
+        CoroutineScope(foregroundContext).launch {
+            val result = withContext(backgroundContext) { background.get() }
+            foreground.accept(result)
+        }
+    }
+
+    override fun immediate(foreground: Runnable) {
+        CoroutineScope(foregroundContext).launch {
+            foreground.run()
+        }
+    }
+
+    override fun repeat(foreground: Runnable, repeatPeriod: Long): Cancellable {
+        val repeatScope = CoroutineScope(foregroundContext)
+
+        repeatScope.launch {
+            while (isActive) {
+                foreground.run()
+                delay(repeatPeriod)
+            }
+        }
+
+        return ScopeCancellable(repeatScope)
+    }
+
+    override fun networkDeferred(tag: String, spec: TaskSpec) {
+        throw UnsupportedOperationException()
+    }
+
+    override fun networkDeferred(tag: String, spec: TaskSpec, repeatPeriod: Long) {
+        throw UnsupportedOperationException()
+    }
+
+    override fun cancelDeferred(tag: String) {
+        throw UnsupportedOperationException()
+    }
+
+    override fun isRunning(tag: String): Boolean {
+        throw UnsupportedOperationException()
+    }
+}

async/src/main/java/org/odk/collect/async/ScopeCancellable.kt

@@ -0,0 +1,12 @@
+package org.odk.collect.async
+
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.cancel
+
+internal class ScopeCancellable(private val scope: CoroutineScope) : Cancellable {
+
+    override fun cancel(): Boolean {
+        scope.cancel()
+        return true
+    }
+}

audioclips/src/test/java/org/odk/collect/audioclips/AudioClipViewModelTest.kt

@@ -68,10 +68,10 @@ class AudioClipViewModelTest {
     @Test
     fun playMultipleClips_updatesProgress_forAllClips() {
         viewModel.play(Clip("clip1", "file://audio.mp3"))
-        assertThat(fakeScheduler.checkRepeatRunning(), equalTo(true))
+        assertThat(fakeScheduler.isRepeatRunning(), equalTo(true))
         viewModel.onCleared()
         viewModel.play(Clip("clip1", "file://audio.mp3"))
-        assertThat(fakeScheduler.checkRepeatRunning(), equalTo(true))
+        assertThat(fakeScheduler.isRepeatRunning(), equalTo(true))
     }
 
     @Test
@@ -88,14 +88,14 @@ class AudioClipViewModelTest {
         val onCompletionListener = captor.value
         verify(mediaPlayer).setDataSource("file://audio1.mp3")
         verify(mediaPlayer, times(1)).start()
-        assertThat(fakeScheduler.checkRepeatRunning(), equalTo(true))
+        assertThat(fakeScheduler.isRepeatRunning(), equalTo(true))
         onCompletionListener.onCompletion(mediaPlayer)
         verify(mediaPlayer).setDataSource("file://audio2.mp3")
         verify(mediaPlayer, times(2)).start()
-        assertThat(fakeScheduler.checkRepeatRunning(), equalTo(true))
+        assertThat(fakeScheduler.isRepeatRunning(), equalTo(true))
         onCompletionListener.onCompletion(mediaPlayer)
         verify(mediaPlayer, times(2)).start()
-        assertThat(fakeScheduler.checkRepeatRunning(), equalTo(false))
+        assertThat(fakeScheduler.isRepeatRunning(), equalTo(false))
     }
 
     @Test
@@ -204,7 +204,7 @@ class AudioClipViewModelTest {
     fun background_cancelsScheduler() {
         viewModel.play(Clip("clip1", "file://audio.mp3"))
         viewModel.background()
-        assertThat(fakeScheduler.hasBeenCancelled(), equalTo(true))
+        assertThat(fakeScheduler.isRepeatRunning(), equalTo(false))
     }
 
     @Test
@@ -317,7 +317,7 @@ class AudioClipViewModelTest {
     fun onCleared_cancelsScheduler() {
         viewModel.play(Clip("clip1", "file://audio.mp3"))
         viewModel.onCleared()
-        assertThat(fakeScheduler.hasBeenCancelled(), equalTo(true))
+        assertThat(fakeScheduler.isRepeatRunning(), equalTo(false))
     }
 
     @Test
@@ -326,7 +326,7 @@ class AudioClipViewModelTest {
         val captor = ArgumentCaptor.forClass(MediaPlayer.OnCompletionListener::class.java)
         verify(mediaPlayer).setOnCompletionListener(captor.capture())
         captor.value.onCompletion(mediaPlayer)
-        assertThat(fakeScheduler.hasBeenCancelled(), equalTo(true))
+        assertThat(fakeScheduler.isRepeatRunning(), equalTo(false))
     }
 
     @Test

audiorecorder/build.gradle

@@ -47,6 +47,7 @@ dependencies {
     implementation 'com.google.android.material:material:1.2.1'
     implementation project(':strings')
     implementation "com.google.dagger:dagger:${rootProject.daggerVersion}"
+    implementation project(path: ':async')
     testImplementation project(path: ':testshared')
     kapt "com.google.dagger:dagger-compiler:${rootProject.daggerVersion}"
 

audiorecorder/src/main/java/org/odk/collect/audiorecorder/DaggerSetup.kt

@@ -7,6 +7,9 @@ import dagger.BindsInstance
 import dagger.Component
 import dagger.Module
 import dagger.Provides
+import kotlinx.coroutines.Dispatchers
+import org.odk.collect.async.CoroutineScheduler
+import org.odk.collect.async.Scheduler
 import org.odk.collect.audiorecorder.recorder.MediaRecorderRecorder
 import org.odk.collect.audiorecorder.recorder.RealMediaRecorderWrapper
 import org.odk.collect.audiorecorder.recorder.Recorder
@@ -70,6 +73,11 @@ internal open class AudioRecorderDependencyModule {
     open fun providesRecordingRepository(): RecordingRepository {
         return RecordingRepository()
     }
+
+    @Provides
+    open fun providesScheduler(application: Application): Scheduler {
+        return CoroutineScheduler(Dispatchers.Main, Dispatchers.IO)
+    }
 }
 
 internal fun RobolectricApplication.clearDependencies() {

audiorecorder/src/main/java/org/odk/collect/audiorecorder/recorder/MediaRecorderRecorder.kt

@@ -51,6 +51,9 @@ internal class MediaRecorderRecorder(private val cacheDir: File, private val med
         file?.delete()
     }
 
+    override val amplitude: Int
+        get() = mediaRecorder?.getMaxAmplitude() ?: 0
+
     override fun isRecording(): Boolean {
         return mediaRecorder != null
     }

audiorecorder/src/main/java/org/odk/collect/audiorecorder/recorder/MediaRecorderWrapper.kt

@@ -18,6 +18,7 @@ internal interface MediaRecorderWrapper {
     fun start()
     fun stop()
     fun release()
+    fun getMaxAmplitude(): Int
 }
 
 class RealMediaRecorderWrapper(private val mediaRecorder: MediaRecorder) : MediaRecorderWrapper {
@@ -61,4 +62,8 @@ class RealMediaRecorderWrapper(private val mediaRecorder: MediaRecorder) : Media
     override fun release() {
         mediaRecorder.release()
     }
+
+    override fun getMaxAmplitude(): Int {
+        return mediaRecorder.maxAmplitude
+    }
 }

audiorecorder/src/main/java/org/odk/collect/audiorecorder/recorder/Recorder.kt

@@ -7,6 +7,7 @@ internal interface Recorder {
     fun stop(): File
     fun cancel()
 
+    val amplitude: Int
     fun isRecording(): Boolean
 }
 

audiorecorder/src/main/java/org/odk/collect/audiorecorder/recording/AudioRecorderViewModel.kt

@@ -7,12 +7,12 @@ import java.io.File
 
 /**
  * Interface for a ViewModel that records audio. Can only record once session
- * at a time but supports cases where multiple views can start/playback different
- * recordings through a `sessionsId` passed to `start` and `getRecording`.
+ * at a time.
  */
 abstract class AudioRecorderViewModel : ViewModel() {
-    abstract fun isRecording(): LiveData<Boolean>
-    abstract fun getRecording(sessionId: String): LiveData<File?>
+    abstract fun isRecording(): Boolean
+    abstract fun getCurrentSession(): LiveData<RecordingSession?>
+
     abstract fun start(sessionId: String, output: Output)
     abstract fun stop()
 
@@ -22,3 +22,5 @@ abstract class AudioRecorderViewModel : ViewModel() {
      */
     abstract fun cleanUp()
 }
+
+data class RecordingSession(val id: String, val file: File?, val duration: Long, val amplitude: Int)