Use speech recognition from the game screen

gradle/libs.versions.toml

@@ -20,6 +20,7 @@ androidx-test-espresso-core = "androidx.test.espresso:espresso-core:3.4.0"
 androidx-test-espresso-intents = "androidx.test.espresso:espresso-intents:3.4.0"
 
 accompanist-flowlayout = { module = "com.google.accompanist:accompanist-flowlayout", version.ref = "accompanist" }
+accompanist-permissions = { module = "com.google.accompanist:accompanist-permissions", version.ref = "accompanist" }
 
 compose-animation-animation = { module = "androidx.compose.animation:animation", version.ref = "compose" }
 compose-animation-graphics = { module = "androidx.compose.animation:animation-graphics", version.ref = "compose" }
@@ -59,6 +60,7 @@ truth = "com.google.truth:truth:1.1.3"
 
 compose-android = [
     "accompanist-flowlayout",
+    "accompanist-permissions",
     "androidx-activity-compose",
     "androidx-lifecycle-compose",
     "androidx-navigation-compose",

mobile/build.gradle.kts

@@ -50,6 +50,7 @@ tasks.withType<KotlinCompile>().configureEach {
   kotlinOptions.freeCompilerArgs += "-opt-in=androidx.compose.animation.ExperimentalAnimationApi"
   kotlinOptions.freeCompilerArgs +=
       "-opt-in=androidx.compose.animation.core.ExperimentalTransitionApi"
+  kotlinOptions.freeCompilerArgs += "-Xjvm-default=compatibility"
 }
 
 dependencies {

mobile/src/androidTest/java/ch/epfl/sdp/mobile/test/application/SpeechFacadeTest.kt

@@ -0,0 +1,37 @@
+package ch.epfl.sdp.mobile.test.application
+
+import ch.epfl.sdp.mobile.application.speech.SpeechFacade
+import ch.epfl.sdp.mobile.application.speech.SpeechFacade.RecognitionResult.*
+import ch.epfl.sdp.mobile.test.infrastructure.speech.FailingSpeechRecognizerFactory
+import ch.epfl.sdp.mobile.test.infrastructure.speech.SuccessfulSpeechRecognizer
+import ch.epfl.sdp.mobile.test.infrastructure.speech.SuccessfulSpeechRecognizerFactory
+import ch.epfl.sdp.mobile.test.infrastructure.speech.SuspendingSpeechRecognizerFactory
+import com.google.common.truth.Truth.assertThat
+import kotlinx.coroutines.cancelAndJoin
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.test.UnconfinedTestDispatcher
+import kotlinx.coroutines.test.runTest
+import org.junit.Test
+
+class SpeechFacadeTest {
+
+  @Test
+  fun given_suspendingRecognizer_when_recognizesThenCancels_then_terminatesWithoutException() =
+      runTest(UnconfinedTestDispatcher()) {
+        val facade = SpeechFacade(SuspendingSpeechRecognizerFactory)
+        val job = launch { facade.recognize() }
+        job.cancelAndJoin()
+      }
+
+  @Test
+  fun given_failingRecognizer_when_recognizes_then_returnsErrorInternal() = runTest {
+    val facade = SpeechFacade(FailingSpeechRecognizerFactory)
+    assertThat(facade.recognize()).isEqualTo(Failure.Internal)
+  }
+
+  @Test
+  fun given_successfulRecognizer_when_recognizes_then_returnsResults() = runTest {
+    val facade = SpeechFacade(SuccessfulSpeechRecognizerFactory)
+    assertThat(facade.recognize()).isEqualTo(Success(SuccessfulSpeechRecognizer.Results))
+  }
+}

mobile/src/androidTest/java/ch/epfl/sdp/mobile/test/infrastructure/speech/FailingSpeechRecognizerFactory.kt

@@ -0,0 +1,22 @@
+package ch.epfl.sdp.mobile.test.infrastructure.speech
+
+import ch.epfl.sdp.mobile.infrastructure.speech.SpeechRecognizer
+import ch.epfl.sdp.mobile.infrastructure.speech.SpeechRecognizerFactory
+
+/** An implementation of [SpeechRecognizerFactory] which always fails. */
+object FailingSpeechRecognizerFactory : SpeechRecognizerFactory {
+  override fun createSpeechRecognizer() = FailingSpeechRecognizer()
+}
+
+/** A [SpeechRecognizer] which will always fail to recognize the user input, and return an error. */
+class FailingSpeechRecognizer : SpeechRecognizer {
+  private var listener: SpeechRecognizer.Listener? = null
+  override fun setListener(listener: SpeechRecognizer.Listener) {
+    this.listener = listener
+  }
+  override fun startListening() {
+    listener?.onError()
+  }
+  override fun stopListening() = Unit
+  override fun destroy() = Unit
+}

mobile/src/androidTest/java/ch/epfl/sdp/mobile/test/infrastructure/speech/SuccessfulSpeechRecognizerFactory.kt

@@ -0,0 +1,29 @@
+package ch.epfl.sdp.mobile.test.infrastructure.speech
+
+import ch.epfl.sdp.mobile.infrastructure.speech.SpeechRecognizer
+import ch.epfl.sdp.mobile.infrastructure.speech.SpeechRecognizerFactory
+
+/** An implementation of [SpeechRecognizerFactory] which always succeeds. */
+object SuccessfulSpeechRecognizerFactory : SpeechRecognizerFactory {
+  override fun createSpeechRecognizer() = SuccessfulSpeechRecognizer()
+}
+
+/** A [SpeechRecognizer] which always succeeds to recognize the user input, and return [Results]. */
+class SuccessfulSpeechRecognizer : SpeechRecognizer {
+
+  companion object {
+
+    /** The results which will always be returned on success. */
+    val Results = listOf("Hello", "World")
+  }
+
+  private var listener: SpeechRecognizer.Listener? = null
+  override fun setListener(listener: SpeechRecognizer.Listener) {
+    this.listener = listener
+  }
+  override fun startListening() {
+    listener?.onResults(Results)
+  }
+  override fun stopListening() = Unit
+  override fun destroy() = Unit
+}

mobile/src/androidTest/java/ch/epfl/sdp/mobile/test/infrastructure/speech/SuspendingSpeechRecognizerFactory.kt

@@ -0,0 +1,17 @@
+package ch.epfl.sdp.mobile.test.infrastructure.speech
+
+import ch.epfl.sdp.mobile.infrastructure.speech.SpeechRecognizer
+import ch.epfl.sdp.mobile.infrastructure.speech.SpeechRecognizerFactory
+
+/** An implementation of [SpeechRecognizerFactory] which never issues results. */
+object SuspendingSpeechRecognizerFactory : SpeechRecognizerFactory {
+  override fun createSpeechRecognizer(): SpeechRecognizer = SuspendingSpeechRecognizer
+}
+
+/** A [SpeechRecognizer] which never returns. */
+object SuspendingSpeechRecognizer : SpeechRecognizer {
+  override fun setListener(listener: SpeechRecognizer.Listener) = Unit
+  override fun startListening() = Unit // Never triggers a result.
+  override fun stopListening() = Unit
+  override fun destroy() = Unit
+}

mobile/src/androidTest/java/ch/epfl/sdp/mobile/test/infrastructure/speech/android/AndroidSpeechRecognizerFactoryTest.kt

@@ -0,0 +1,27 @@
+package ch.epfl.sdp.mobile.test.infrastructure.speech.android
+
+import android.content.Context
+import android.speech.SpeechRecognizer
+import ch.epfl.sdp.mobile.infrastructure.speech.android.AndroidSpeechRecognizerFactory
+import io.mockk.every
+import io.mockk.mockk
+import io.mockk.mockkStatic
+import io.mockk.verify
+import org.junit.Test
+
+class AndroidSpeechRecognizerFactoryTest {
+
+  @Test
+  fun given_factory_when_createSpeechRecognizer_then_createsFrameworkSpeechRecognizer() {
+    val context = mockk<Context>()
+    val factory = AndroidSpeechRecognizerFactory(context)
+    val recognizer = mockk<SpeechRecognizer>()
+    mockkStatic(SpeechRecognizer::class)
+
+    every { SpeechRecognizer.createSpeechRecognizer(context) } returns recognizer
+
+    factory.createSpeechRecognizer()
+
+    verify { SpeechRecognizer.createSpeechRecognizer(context) }
+  }
+}

mobile/src/androidTest/java/ch/epfl/sdp/mobile/test/infrastructure/speech/android/AndroidSpeechRecognizerTest.kt

@@ -0,0 +1,100 @@
+package ch.epfl.sdp.mobile.test.infrastructure.speech.android
+
+import android.speech.RecognitionListener
+import android.speech.SpeechRecognizer
+import android.speech.SpeechRecognizer.RESULTS_RECOGNITION
+import androidx.core.os.bundleOf
+import ch.epfl.sdp.mobile.infrastructure.speech.SpeechRecognizer.Listener
+import ch.epfl.sdp.mobile.infrastructure.speech.android.AndroidSpeechRecognizer
+import io.mockk.every
+import io.mockk.mockk
+import io.mockk.verify
+import org.junit.Test
+
+class AndroidSpeechRecognizerTest {
+
+  @Test
+  fun given_recognizer_when_destroy_then_destroysFramework() {
+    val framework = mockk<SpeechRecognizer>()
+    val recognizer = AndroidSpeechRecognizer(framework)
+    every { framework.destroy() } returns Unit
+
+    recognizer.destroy()
+
+    verify { framework.destroy() }
+  }
+
+  @Test
+  fun given_recognizer_when_startListening_then_startsFrameworkListening() {
+    val framework = mockk<SpeechRecognizer>()
+    val recognizer = AndroidSpeechRecognizer(framework)
+    every { framework.startListening(any()) } returns Unit
+
+    recognizer.startListening()
+
+    verify { framework.startListening(any()) }
+  }
+
+  @Test
+  fun given_recognizer_when_stopListening_then_stopsFrameworkListening() {
+    val framework = mockk<SpeechRecognizer>()
+    val recognizer = AndroidSpeechRecognizer(framework)
+    every { framework.stopListening() } returns Unit
+
+    recognizer.stopListening()
+
+    verify { framework.stopListening() }
+  }
+
+  @Test
+  fun given_recognizer_when_settingListener_then_callsErrorListener() {
+    val framework = mockk<SpeechRecognizer>()
+    val recognizer = AndroidSpeechRecognizer(framework)
+    val listener = mockk<Listener>()
+
+    every { listener.onError() } returns Unit
+    every { framework.setRecognitionListener(any()) } answers
+        {
+          firstArg<RecognitionListener>().onError(0)
+        }
+
+    recognizer.setListener(listener)
+
+    verify { listener.onError() }
+  }
+
+  @Test
+  fun given_recognizer_when_settingListener_then_callsSuccessListener() {
+    val framework = mockk<SpeechRecognizer>()
+    val recognizer = AndroidSpeechRecognizer(framework)
+    val listener = mockk<Listener>()
+
+    every { listener.onResults(arrayListOf("Hello")) } returns Unit
+    every { framework.setRecognitionListener(any()) } answers
+        {
+          firstArg<RecognitionListener>()
+              .onResults(bundleOf(RESULTS_RECOGNITION to arrayListOf("Hello")))
+        }
+
+    recognizer.setListener(listener)
+
+    verify { listener.onResults(arrayListOf("Hello")) }
+  }
+
+  @Test
+  fun given_recognizer_when_settingListener_then_callsSuccessListenerWithDefaultValue() {
+    val framework = mockk<SpeechRecognizer>()
+    val recognizer = AndroidSpeechRecognizer(framework)
+    val listener = mockk<Listener>()
+
+    every { listener.onResults(emptyList()) } returns Unit
+    every { framework.setRecognitionListener(any()) } answers
+        {
+          firstArg<RecognitionListener>().onResults(bundleOf(RESULTS_RECOGNITION to null))
+        }
+
+    recognizer.setListener(listener)
+
+    verify { listener.onResults(emptyList()) }
+  }
+}

mobile/src/androidTest/java/ch/epfl/sdp/mobile/test/infrastructure/speech/android/RecognitionListenerAdapterTest.kt

@@ -0,0 +1,25 @@
+package ch.epfl.sdp.mobile.test.infrastructure.speech.android
+
+import android.os.Bundle
+import ch.epfl.sdp.mobile.infrastructure.speech.android.RecognitionListenerAdapter
+import com.google.common.truth.Truth.assertThat
+import org.junit.Test
+
+class RecognitionListenerAdapterTest {
+
+  @Test
+  fun given_emptyAdapter_when_callingAnyMethod_then_neverThrowsAndAlwaysReturnsUnit() {
+    // This is slightly artificial, but we don't really expect anything else from the subject under
+    // test and it's required for code coverage.
+    val adapter = object : RecognitionListenerAdapter() {}
+
+    assertThat(adapter.onReadyForSpeech(Bundle.EMPTY)).isEqualTo(Unit)
+    assertThat(adapter.onBeginningOfSpeech()).isEqualTo(Unit)
+    assertThat(adapter.onRmsChanged(0f)).isEqualTo(Unit)
+    assertThat(adapter.onBufferReceived(byteArrayOf())).isEqualTo(Unit)
+    assertThat(adapter.onEndOfSpeech()).isEqualTo(Unit)
+    assertThat(adapter.onResults(Bundle.EMPTY)).isEqualTo(Unit)
+    assertThat(adapter.onPartialResults(Bundle.EMPTY)).isEqualTo(Unit)
+    assertThat(adapter.onEvent(0, Bundle.EMPTY)).isEqualTo(Unit)
+  }
+}

mobile/src/androidTest/java/ch/epfl/sdp/mobile/test/state/ClassicChessBoardStateTest.kt

@@ -10,6 +10,7 @@ import ch.epfl.sdp.mobile.test.infrastructure.persistence.auth.emptyAuth
 import ch.epfl.sdp.mobile.test.infrastructure.persistence.store.buildStore
 import ch.epfl.sdp.mobile.test.infrastructure.persistence.store.document
 import ch.epfl.sdp.mobile.ui.game.ChessBoardState
+import ch.epfl.sdp.mobile.ui.game.SpeechRecognizerState
 import com.google.common.truth.Truth.assertThat
 import io.mockk.every
 import io.mockk.mockk
@@ -20,6 +21,11 @@ import org.junit.Test
 
 class ClassicChessBoardStateTest {
 
+  private object NoOpSpeechRecognizerState : SpeechRecognizerState {
+    override val listening = false
+    override fun onListenClick() = Unit
+  }
+
   @Test
   fun selectingPiece_displaysAvailableMoves() = runTest {
     val auth = emptyAuth()
@@ -40,7 +46,7 @@ class ClassicChessBoardStateTest {
     val match = facade.createMatch(user, user)
 
     val actions = StatefulGameScreenActions(onBack = {}, onShowAr = {})
-    val state = MatchGameScreenState(actions, user, match, scope)
+    val state = MatchGameScreenState(actions, user, match, scope, NoOpSpeechRecognizerState)
 
     state.onPositionClick(ChessBoardState.Position(4, 6))
     assertThat(state.availableMoves)

mobile/src/androidTest/java/ch/epfl/sdp/mobile/test/state/CompositionLocalsTest.kt

@@ -4,6 +4,7 @@ import androidx.compose.ui.test.junit4.createComposeRule
 import ch.epfl.sdp.mobile.state.LocalAuthenticationFacade
 import ch.epfl.sdp.mobile.state.LocalChessFacade
 import ch.epfl.sdp.mobile.state.LocalSocialFacade
+import ch.epfl.sdp.mobile.state.LocalSpeechFacade
 import org.junit.Assert.assertThrows
 import org.junit.Rule
 import org.junit.Test
@@ -30,4 +31,11 @@ class CompositionLocalsTest {
       rule.setContent { LocalSocialFacade.current }
     }
   }
+
+  @Test
+  fun missingSpeechFacade_throwsException() {
+    assertThrows(IllegalStateException::class.java) {
+      rule.setContent { LocalSpeechFacade.current }
+    }
+  }
 }

mobile/src/androidTest/java/ch/epfl/sdp/mobile/test/state/NavigationTest.kt

@@ -10,6 +10,7 @@ import ch.epfl.sdp.mobile.application.ProfileDocument
 import ch.epfl.sdp.mobile.application.authentication.AuthenticationFacade
 import ch.epfl.sdp.mobile.application.chess.ChessFacade
 import ch.epfl.sdp.mobile.application.social.SocialFacade
+import ch.epfl.sdp.mobile.application.speech.SpeechFacade
 import ch.epfl.sdp.mobile.state.Navigation
 import ch.epfl.sdp.mobile.state.ProvideFacades
 import ch.epfl.sdp.mobile.test.infrastructure.persistence.auth.SuspendingAuth
@@ -18,6 +19,7 @@ import ch.epfl.sdp.mobile.test.infrastructure.persistence.auth.emptyAuth
 import ch.epfl.sdp.mobile.test.infrastructure.persistence.store.buildStore
 import ch.epfl.sdp.mobile.test.infrastructure.persistence.store.document
 import ch.epfl.sdp.mobile.test.infrastructure.persistence.store.emptyStore
+import ch.epfl.sdp.mobile.test.infrastructure.speech.FailingSpeechRecognizerFactory
 import kotlinx.coroutines.test.runTest
 import org.junit.Rule
 import org.junit.Test
@@ -32,8 +34,9 @@ class NavigationTest {
     val facade = AuthenticationFacade(SuspendingAuth, store)
     val socialFacade = SocialFacade(SuspendingAuth, store)
     val chessFacade = ChessFacade(SuspendingAuth, store)
+    val speechFacade = SpeechFacade(FailingSpeechRecognizerFactory)
     rule.setContentWithLocalizedStrings {
-      ProvideFacades(facade, socialFacade, chessFacade) { Navigation() }
+      ProvideFacades(facade, socialFacade, chessFacade, speechFacade) { Navigation() }
     }
     rule.onAllNodes(keyIsDefined(SemanticsProperties.Text)).assertCountEquals(0)
   }
@@ -45,9 +48,10 @@ class NavigationTest {
     val facade = AuthenticationFacade(auth, store)
     val socialFacade = SocialFacade(auth, store)
     val chessFacade = ChessFacade(SuspendingAuth, store)
+    val speechFacade = SpeechFacade(FailingSpeechRecognizerFactory)
     val strings =
         rule.setContentWithLocalizedStrings {
-          ProvideFacades(facade, socialFacade, chessFacade) { Navigation() }
+          ProvideFacades(facade, socialFacade, chessFacade, speechFacade) { Navigation() }
         }
 
     // Do we see the authentication screen actions ?
@@ -61,9 +65,10 @@ class NavigationTest {
     val facade = AuthenticationFacade(auth, store)
     val socialFacade = SocialFacade(auth, store)
     val chessFacade = ChessFacade(SuspendingAuth, store)
+    val speechFacade = SpeechFacade(FailingSpeechRecognizerFactory)
     val strings =
         rule.setContentWithLocalizedStrings {
-          ProvideFacades(facade, socialFacade, chessFacade) { Navigation() }
+          ProvideFacades(facade, socialFacade, chessFacade, speechFacade) { Navigation() }
         }
     facade.signUpWithEmail("email@epfl.ch", "name", "password")
 
@@ -82,9 +87,10 @@ class NavigationTest {
     val authFacade = AuthenticationFacade(auth, store)
     val chessFacade = ChessFacade(auth, store)
     val socialFacade = SocialFacade(auth, store)
+    val speechFacade = SpeechFacade(FailingSpeechRecognizerFactory)
     val strings =
         rule.setContentWithLocalizedStrings {
-          ProvideFacades(authFacade, socialFacade, chessFacade) { Navigation() }
+          ProvideFacades(authFacade, socialFacade, chessFacade, speechFacade) { Navigation() }
         }
     authFacade.signInWithEmail("email@epfl.ch", "password")