Fix #120: Introduce question data controller API

domain/src/main/java/org/oppia/domain/question/QuestionDataController.kt

@@ -0,0 +1,83 @@
+package org.oppia.domain.question
+
+import android.content.Context
+import androidx.lifecycle.LiveData
+import androidx.lifecycle.MutableLiveData
+import org.oppia.app.model.Question
+import org.oppia.domain.topic.TEST_TOPIC_ID_0
+import org.oppia.domain.topic.TEST_TOPIC_ID_1
+import org.oppia.util.data.AsyncResult
+import org.oppia.util.data.DataProviders
+import javax.inject.Inject
+import javax.inject.Singleton
+
+private const val QUESTION_DATA_PROVIDER_ID = "QuestionDataProvider"
+
+/** Controller for retrieving an exploration. */
+@Singleton
+class QuestionDataController @Inject constructor(
+  private val questionProgressController: QuestionProgressController,
+  private val dataProviders: DataProviders
+) {
+
+  /**
+   * Returns a list of [Question] objects given a topic ID.
+   */
+  fun getQuestionsForTopic(topicId: String): LiveData<AsyncResult<List<Question>>> {
+    val dataProvider = dataProviders.createInMemoryDataProviderAsync(QUESTION_DATA_PROVIDER_ID) {
+      retrieveQuestionsForTopic(topicId)
+    }
+    return dataProviders.convertToLiveData(dataProvider)
+  }
+
+  /**
+   * Begins a question training session given a list of questions. This method is not expected to fail.
+   * [QuestionProgressController] should be used to manage the play state, and monitor the load success/failure of
+   * the training session.
+   *
+   * Questions will be shuffled and then the training session will begin.
+   *
+   * @return a one-time [LiveData] to observe whether initiating the play request succeeded.
+   * The training session may still fail to load, but this provides early-failure detection.
+   */
+  fun startQuestionTrainingSession(questionsList: List<Question>): LiveData<AsyncResult<Any?>> {
+    return try {
+      questionProgressController.beginQuestionTrainingSession(questionsList.shuffled())
+      MutableLiveData(AsyncResult.success<Any?>(null))
+    } catch (e: Exception) {
+      MutableLiveData(AsyncResult.failed(e))
+    }
+  }
+
+  /**
+   * Finishes the most recent training session started by [startQuestionTrainingSession].
+   * This method should only be called if there is a training session is being played,
+   * otherwise an exception will be thrown.
+   */
+  fun stopQuestionTrainingSession(): LiveData<AsyncResult<Any?>> {
+    return try {
+      questionProgressController.finishQuestionTrainingSession()
+      MutableLiveData(AsyncResult.success<Any?>(null))
+    } catch (e: Exception) {
+      MutableLiveData(AsyncResult.failed(e))
+    }
+  }
+
+  @Suppress("RedundantSuspendModifier") // DataProviders expects this function to be a suspend function.
+  private suspend fun retrieveQuestionsForTopic(topicId: String): AsyncResult<List<Question>> {
+    return try {
+      AsyncResult.success(loadQuestions(topicId))
+    } catch (e: Exception) {
+      AsyncResult.failed(e)
+    }
+  }
+
+  // Loads and returns the questions given a topic id.
+  private fun loadQuestions(topicId: String): List<Question> {
+    when(topicId) {
+      TEST_TOPIC_ID_0 -> return emptyList()
+      TEST_TOPIC_ID_1 -> return emptyList()
+      else -> throw IllegalStateException("Invalid topic ID: $topicId")
+    }
+  }
+}

domain/src/main/java/org/oppia/domain/question/QuestionProgressController.kt

@@ -0,0 +1,18 @@
+package org.oppia.domain.question
+
+import org.oppia.app.model.Question
+import javax.inject.Inject
+import javax.inject.Singleton
+
+
+/** Controller for retrieving an exploration. */
+@Singleton
+class QuestionProgressController @Inject constructor(
+) {
+  fun beginQuestionTrainingSession(questionsList: List<Question>) {
+  }
+
+  fun finishQuestionTrainingSession() {
+
+  }
+}

domain/src/test/java/org/oppia/domain/question/QuestionDataControllerTest.kt

@@ -0,0 +1,194 @@
+package org.oppia.domain.question
+
+import android.app.Application
+import android.content.Context
+import androidx.arch.core.executor.testing.InstantTaskExecutorRule
+import androidx.lifecycle.Observer
+import androidx.test.core.app.ApplicationProvider
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import com.google.common.truth.Truth.assertThat
+import dagger.BindsInstance
+import dagger.Component
+import dagger.Module
+import dagger.Provides
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.ObsoleteCoroutinesApi
+import kotlinx.coroutines.newSingleThreadContext
+import kotlinx.coroutines.test.TestCoroutineDispatcher
+import kotlinx.coroutines.test.resetMain
+import kotlinx.coroutines.test.runBlockingTest
+import kotlinx.coroutines.test.setMain
+import org.junit.After
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.mockito.ArgumentCaptor
+import org.mockito.Captor
+import org.mockito.Mock
+import org.mockito.Mockito.atLeastOnce
+import org.mockito.Mockito.verify
+import org.mockito.junit.MockitoJUnit
+import org.mockito.junit.MockitoRule
+import org.oppia.app.model.Question
+import org.oppia.util.data.AsyncResult
+import org.oppia.util.logging.EnableConsoleLog
+import org.oppia.util.logging.EnableFileLog
+import org.oppia.util.logging.GlobalLogLevel
+import org.oppia.util.logging.LogLevel
+import org.oppia.util.threading.BackgroundDispatcher
+import org.oppia.util.threading.BlockingDispatcher
+import org.robolectric.annotation.Config
+import javax.inject.Inject
+import javax.inject.Qualifier
+import javax.inject.Singleton
+import kotlin.coroutines.EmptyCoroutineContext
+
+const val TEST_TOPIC_ID_0 = "test_topic_id_0"
+
+/** Tests for [QuestionDataController]. */
+@RunWith(AndroidJUnit4::class)
+@Config(manifest = Config.NONE)
+class QuestionDataControllerTest {
+  @Rule
+  @JvmField
+  val mockitoRule: MockitoRule = MockitoJUnit.rule()
+
+  @Rule
+  @JvmField
+  val executorRule = InstantTaskExecutorRule()
+
+  @Inject
+  lateinit var questionDataController: QuestionDataController
+
+  @Mock
+  lateinit var mockQuestionListObserver: Observer<AsyncResult<List<Question>>>
+
+  @Captor
+  lateinit var questionListResultCaptor: ArgumentCaptor<AsyncResult<List<Question>>>
+
+  @Inject
+  @field:TestDispatcher
+  lateinit var testDispatcher: CoroutineDispatcher
+
+  private val coroutineContext by lazy {
+    EmptyCoroutineContext + testDispatcher
+  }
+
+  // https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-test/
+  @ObsoleteCoroutinesApi
+  private val testThread = newSingleThreadContext("TestMain")
+
+  @Before
+  @ExperimentalCoroutinesApi
+  @ObsoleteCoroutinesApi
+  fun setUp() {
+    Dispatchers.setMain(testThread)
+    setUpTestApplicationComponent()
+  }
+
+  @After
+  @ExperimentalCoroutinesApi
+  @ObsoleteCoroutinesApi
+  fun tearDown() {
+    Dispatchers.resetMain()
+    testThread.close()
+  }
+
+  private fun setUpTestApplicationComponent() {
+    DaggerQuestionDataControllerTest_TestApplicationComponent.builder()
+      .setApplication(ApplicationProvider.getApplicationContext())
+      .build()
+      .inject(this)
+  }
+
+  @Test
+  @ExperimentalCoroutinesApi
+  fun testController_providesInitialLiveDataForTopicId0() = runBlockingTest(coroutineContext) {
+    val questionListLiveData = questionDataController.getQuestionsForTopic(TEST_TOPIC_ID_0)
+    advanceUntilIdle()
+    questionListLiveData.observeForever(mockQuestionListObserver)
+
+    verify(mockQuestionListObserver, atLeastOnce()).onChanged(questionListResultCaptor.capture())
+    assertThat(questionListResultCaptor.value.isSuccess()).isTrue()
+    assertThat(questionListResultCaptor.value.getOrThrow()).isNotNull()
+    val questionList = questionListResultCaptor.value.getOrThrow();
+    assertThat(questionList.size).isEqualTo(0)
+  }
+
+  @Test
+  @ExperimentalCoroutinesApi
+  fun testController_returnsFailureForNonExistentTopic() = runBlockingTest(coroutineContext) {
+    val questionListLiveData = questionDataController.getQuestionsForTopic("NON_EXISTENT_TOPIC")
+    advanceUntilIdle()
+    questionListLiveData.observeForever(mockQuestionListObserver)
+    verify(mockQuestionListObserver, atLeastOnce()).onChanged(questionListResultCaptor.capture())
+    assertThat(questionListResultCaptor.value.isFailure()).isTrue()
+  }
+
+  @Qualifier
+  annotation class TestDispatcher
+
+  // TODO(#89): Move this to a common test application component.
+  @Module
+  class TestModule {
+    @Provides
+    @Singleton
+    fun provideContext(application: Application): Context {
+      return application
+    }
+
+    @ExperimentalCoroutinesApi
+    @Singleton
+    @Provides
+    @TestDispatcher
+    fun provideTestDispatcher(): CoroutineDispatcher {
+      return TestCoroutineDispatcher()
+    }
+
+    @Singleton
+    @Provides
+    @BackgroundDispatcher
+    fun provideBackgroundDispatcher(@TestDispatcher testDispatcher: CoroutineDispatcher): CoroutineDispatcher {
+      return testDispatcher
+    }
+
+    @Singleton
+    @Provides
+    @BlockingDispatcher
+    fun provideBlockingDispatcher(@TestDispatcher testDispatcher: CoroutineDispatcher): CoroutineDispatcher {
+      return testDispatcher
+    }
+
+    // TODO(#59): Either isolate these to their own shared test module, or use the real logging
+    // module in tests to avoid needing to specify these settings for tests.
+    @EnableConsoleLog
+    @Provides
+    fun provideEnableConsoleLog(): Boolean = true
+
+    @EnableFileLog
+    @Provides
+    fun provideEnableFileLog(): Boolean = false
+
+    @GlobalLogLevel
+    @Provides
+    fun provideGlobalLogLevel(): LogLevel = LogLevel.VERBOSE
+  }
+
+  // TODO(#89): Move this to a common test application component.
+  @Singleton
+  @Component(modules = [TestModule::class])
+  interface TestApplicationComponent {
+    @Component.Builder
+    interface Builder {
+      @BindsInstance
+      fun setApplication(application: Application): Builder
+
+      fun build(): TestApplicationComponent
+    }
+
+    fun inject(questionDataControllerTest: QuestionDataControllerTest)
+  }
+}

model/src/main/proto/question.proto

@@ -0,0 +1,21 @@
+syntax = "proto3";
+
+package model;
+
+import "exploration.proto";
+
+option java_package = "org.oppia.app.model";
+option java_multiple_files = true;
+
+// Structure for a single question.
+message Question {
+  string question_id = 1;
+  State question_state = 2;
+  string language_code = 3;
+  int32 version = 4;
+  repeated string linked_skill_ids = 5;
+  int64 created_on_timestamp_ms = 6;
+  int64 updated_on_timestamp_ms = 7;
+}
+
+