From 2893862448d7cd45ef3320c49e4edd508075c190 Mon Sep 17 00:00:00 2001
From: marysoloman <nikitamarysolomanpvt@gmail.com>
Date: Tue, 24 Dec 2019 15:24:03 +0530
Subject: [PATCH 01/19] isAppAlreadyOnboarded introduced

---
 app/src/main/AndroidManifest.xml              |  4 +++
 .../oppia/app/home/UserAppHistoryViewModel.kt |  3 ++
 .../oppia/app/splash/OnboardingActivity.kt    | 29 +++++++++++++++++++
 .../org/oppia/app/splash/SplashActivity.kt    | 19 +++++++++---
 app/src/main/res/layout/dummy_onboard.xml     | 16 ++++++++++
 .../oppia/domain/UserAppHistoryController.kt  | 12 ++++++++
 model/src/main/proto/example.proto            |  1 +
 7 files changed, 80 insertions(+), 4 deletions(-)
 create mode 100644 app/src/main/java/org/oppia/app/splash/OnboardingActivity.kt
 create mode 100644 app/src/main/res/layout/dummy_onboard.xml

diff --git a/app/src/main/AndroidManifest.xml b/app/src/main/AndroidManifest.xml
index cabc2b96a91..e0f41aeeee0 100644
--- a/app/src/main/AndroidManifest.xml
+++ b/app/src/main/AndroidManifest.xml
@@ -60,6 +60,10 @@
     <activity
       android:name=".settings.profile.ProfileResetPinActivity"
       android:screenOrientation="portrait" />
+    <activity
+      android:name=".splash.OnboardingActivity"
+      android:screenOrientation="portrait"
+      android:theme="@style/OppiaThemeWithoutActionBar" />
     <activity
       android:name=".splash.SplashActivity"
       android:screenOrientation="portrait"
diff --git a/app/src/main/java/org/oppia/app/home/UserAppHistoryViewModel.kt b/app/src/main/java/org/oppia/app/home/UserAppHistoryViewModel.kt
index 6b43dd7787f..48d7260c72e 100644
--- a/app/src/main/java/org/oppia/app/home/UserAppHistoryViewModel.kt
+++ b/app/src/main/java/org/oppia/app/home/UserAppHistoryViewModel.kt
@@ -8,4 +8,7 @@ class UserAppHistoryViewModel : HomeItemViewModel() {
   var isAppAlreadyOpened = ObservableField<Boolean>(false)
 
   fun setAlreadyAppOpened(alreadyOpenedApp: Boolean) = isAppAlreadyOpened.set(alreadyOpenedApp)
+  var isAppAlreadyOnboarded = ObservableField<Boolean>(false)
+
+  fun setAlreadyAppOnboarded(isalreadyOnboardedApp: Boolean) = isAppAlreadyOnboarded.set(isalreadyOnboardedApp)
 }
diff --git a/app/src/main/java/org/oppia/app/splash/OnboardingActivity.kt b/app/src/main/java/org/oppia/app/splash/OnboardingActivity.kt
new file mode 100644
index 00000000000..7fbbbcd6531
--- /dev/null
+++ b/app/src/main/java/org/oppia/app/splash/OnboardingActivity.kt
@@ -0,0 +1,29 @@
+package org.oppia.app.splash
+
+import android.content.Intent
+import android.os.Bundle
+import android.view.View
+import androidx.appcompat.app.AppCompatActivity
+import org.oppia.app.R
+import org.oppia.app.profile.ProfileActivity
+import org.oppia.domain.UserAppHistoryController
+import javax.inject.Inject
+
+/** An activity that shows a temporary Onboarding page until the app is onborarded then navigates to [ProfileActivity]. */
+class OnboardingActivity : AppCompatActivity() {
+  @Inject lateinit var userAppHistoryController: UserAppHistoryController
+
+  override fun onCreate(savedInstanceState: Bundle?) {
+    super.onCreate(savedInstanceState)
+    setContentView(R.layout.dummy_onboard)
+
+  }
+
+  private fun subscribeToUserAppHistory(view: View) {
+    userAppHistoryController.markUserOnboardedApp()
+    val intent = Intent(this, ProfileActivity::class.java)
+    startActivity(intent)
+    finish()
+  }
+
+}
diff --git a/app/src/main/java/org/oppia/app/splash/SplashActivity.kt b/app/src/main/java/org/oppia/app/splash/SplashActivity.kt
index e2e45056e3c..24800879e12 100644
--- a/app/src/main/java/org/oppia/app/splash/SplashActivity.kt
+++ b/app/src/main/java/org/oppia/app/splash/SplashActivity.kt
@@ -5,18 +5,29 @@ import android.os.Bundle
 import android.view.WindowManager
 import androidx.appcompat.app.AppCompatActivity
 import org.oppia.app.R
+import org.oppia.app.model.UserAppHistory
 import org.oppia.app.profile.ProfileActivity
+import javax.inject.Inject
 
 /** An activity that shows a temporary loading page until the app is fully loaded then navigates to [ProfileActivity]. */
 class SplashActivity : AppCompatActivity() {
 
+  @Inject lateinit var userAppHistory: UserAppHistory
+
   override fun onCreate(savedInstanceState: Bundle?) {
     super.onCreate(savedInstanceState)
     setContentView(R.layout.splash_activity)
-
     window.setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN);
-    val intent = Intent(this@SplashActivity, ProfileActivity::class.java)
-    startActivity(intent)
-    finish()
+    if (userAppHistory.alreadyOnBoardedApp) {
+      val intent = Intent(this@SplashActivity, ProfileActivity::class.java)
+      startActivity(intent)
+      finish()
+    } else {
+      // TODO (#454) : Replace ProfileActivity in this with OnboaridngActivity
+      val intent = Intent(this@SplashActivity, OnboardingActivity::class.java)
+      startActivity(intent)
+      finish()
+    }
   }
+
 }
diff --git a/app/src/main/res/layout/dummy_onboard.xml b/app/src/main/res/layout/dummy_onboard.xml
new file mode 100644
index 00000000000..52610900c50
--- /dev/null
+++ b/app/src/main/res/layout/dummy_onboard.xml
@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+  xmlns:tools="http://schemas.android.com/tools"
+  android:layout_width="match_parent"
+  android:layout_height="match_parent"
+  android:gravity="center"
+  android:orientation="vertical"
+  tools:context=".splash.OnboardingActivity">
+
+  <Button
+    android:layout_width="wrap_content"
+    android:layout_height="wrap_content"
+    android:text="onboard"
+    android:onClick="subscribeToUserAppHistory"/>
+</LinearLayout>
+
diff --git a/domain/src/main/java/org/oppia/domain/UserAppHistoryController.kt b/domain/src/main/java/org/oppia/domain/UserAppHistoryController.kt
index e505a5f8861..28aa1ee367b 100644
--- a/domain/src/main/java/org/oppia/domain/UserAppHistoryController.kt
+++ b/domain/src/main/java/org/oppia/domain/UserAppHistoryController.kt
@@ -47,6 +47,18 @@ class UserAppHistoryController @Inject constructor(
         logger.e("DOMAIN", "Failed to clear user app history.", it)
       }
     }
+  } /**
+   * Saves that the user has opened the app. Note that this does not notify existing subscribers of the changed state,
+   * nor can future subscribers observe this state until app restart.
+   */
+  fun markUserOnboardedApp() {
+    appHistoryStore.storeDataAsync(updateInMemoryCache = false) {
+      it.toBuilder().setAlreadyOnBoardedApp(true).build()
+    }.invokeOnCompletion {
+      it?.let {
+        logger.e("DOMAIN", "Failed when storing that the user already opened the app.", it)
+      }
+    }
   }
 
   /**
diff --git a/model/src/main/proto/example.proto b/model/src/main/proto/example.proto
index 0c68a3d68b4..a5463d5a015 100644
--- a/model/src/main/proto/example.proto
+++ b/model/src/main/proto/example.proto
@@ -7,6 +7,7 @@ option java_multiple_files = true;
 
 message UserAppHistory {
   bool already_opened_app = 1;
+  bool already_on_boarded_app = 2;
 }
 
 message TestMessage {

From 8bbed9506a341bc49f1930b7b298b0333c23b910 Mon Sep 17 00:00:00 2001
From: marysoloman <nikitamarysolomanpvt@gmail.com>
Date: Thu, 26 Dec 2019 15:21:25 +0530
Subject: [PATCH 02/19] test cases for onboarding flow

---
 .../oppia/app/activity/ActivityComponent.kt   |   4 +
 .../oppia/app/splash/OnboardingActivity.kt    |  26 +-
 .../app/splash/OnboardingActivityPresenter.kt |  30 +++
 .../org/oppia/app/splash/SplashActivity.kt    |  26 +-
 .../app/splash/SplashActivityPresenter.kt     |  61 +++++
 app/src/main/res/layout/dummy_onboard.xml     |   8 +-
 .../oppia/app/splash/SplashActivityTest.kt    | 228 ++++++++++++++++-
 .../oppia/domain/OnboardingFlowController.kt  |  60 +++++
 .../oppia/domain/UserAppHistoryController.kt  |  12 -
 .../domain/OnboardingFlowControllerTest.kt    | 234 ++++++++++++++++++
 .../domain/UserAppHistoryControllerTest.kt    |  38 +--
 model/src/main/proto/example.proto            |   5 +-
 12 files changed, 651 insertions(+), 81 deletions(-)
 create mode 100644 app/src/main/java/org/oppia/app/splash/OnboardingActivityPresenter.kt
 create mode 100644 app/src/main/java/org/oppia/app/splash/SplashActivityPresenter.kt
 create mode 100644 domain/src/main/java/org/oppia/domain/OnboardingFlowController.kt
 create mode 100644 domain/src/test/java/org/oppia/domain/OnboardingFlowControllerTest.kt

diff --git a/app/src/main/java/org/oppia/app/activity/ActivityComponent.kt b/app/src/main/java/org/oppia/app/activity/ActivityComponent.kt
index 2621a9b57f7..d61bd11b8a4 100644
--- a/app/src/main/java/org/oppia/app/activity/ActivityComponent.kt
+++ b/app/src/main/java/org/oppia/app/activity/ActivityComponent.kt
@@ -18,6 +18,8 @@ import org.oppia.app.settings.profile.ProfileEditActivity
 import org.oppia.app.settings.profile.ProfileListActivity
 import org.oppia.app.settings.profile.ProfileRenameActivity
 import org.oppia.app.settings.profile.ProfileResetPinActivity
+import org.oppia.app.splash.OnboardingActivity
+import org.oppia.app.splash.SplashActivity
 import org.oppia.app.story.StoryActivity
 import org.oppia.app.story.testing.StoryFragmentTestActivity
 import org.oppia.app.testing.AudioFragmentTestActivity
@@ -66,6 +68,7 @@ interface ActivityComponent {
   fun inject(htmlParserTestActivity: HtmlParserTestActivity)
   fun inject(myDownloadsActivity: MyDownloadsActivity)
   fun inject(navigationDrawerTestActivity: NavigationDrawerTestActivity)
+  fun inject(onboardingActivity: OnboardingActivity)
   fun inject(pinPasswordActivity: PinPasswordActivity)
   fun inject(profileActivity: ProfileActivity)
   fun inject(questionPlayerActivity: QuestionPlayerActivity)
@@ -73,6 +76,7 @@ interface ActivityComponent {
   fun inject(profileListActivity: ProfileListActivity)
   fun inject(profileRenameActivity: ProfileRenameActivity)
   fun inject(profileResetPinActivity: ProfileResetPinActivity)
+  fun inject(splashActivity: SplashActivity)
   fun inject(storyActivity: StoryActivity)
   fun inject(topicActivity: TopicActivity)
   fun inject(topicTestActivity: TopicTestActivity)
diff --git a/app/src/main/java/org/oppia/app/splash/OnboardingActivity.kt b/app/src/main/java/org/oppia/app/splash/OnboardingActivity.kt
index 7fbbbcd6531..386ac862406 100644
--- a/app/src/main/java/org/oppia/app/splash/OnboardingActivity.kt
+++ b/app/src/main/java/org/oppia/app/splash/OnboardingActivity.kt
@@ -1,29 +1,21 @@
 package org.oppia.app.splash
 
-import android.content.Intent
 import android.os.Bundle
-import android.view.View
-import androidx.appcompat.app.AppCompatActivity
-import org.oppia.app.R
+import org.oppia.app.activity.InjectableAppCompatActivity
+import org.oppia.app.help.OnboardingActivityPresenter
 import org.oppia.app.profile.ProfileActivity
-import org.oppia.domain.UserAppHistoryController
 import javax.inject.Inject
 
 /** An activity that shows a temporary Onboarding page until the app is onborarded then navigates to [ProfileActivity]. */
-class OnboardingActivity : AppCompatActivity() {
-  @Inject lateinit var userAppHistoryController: UserAppHistoryController
+class OnboardingActivity : InjectableAppCompatActivity() {
+
+  @Inject
+  lateinit var onboardingActivityPresenter: OnboardingActivityPresenter
 
   override fun onCreate(savedInstanceState: Bundle?) {
     super.onCreate(savedInstanceState)
-    setContentView(R.layout.dummy_onboard)
-
-  }
-
-  private fun subscribeToUserAppHistory(view: View) {
-    userAppHistoryController.markUserOnboardedApp()
-    val intent = Intent(this, ProfileActivity::class.java)
-    startActivity(intent)
-    finish()
+    activityComponent.inject(this)
+    onboardingActivityPresenter.handleOnCreate()
   }
-
 }
+
diff --git a/app/src/main/java/org/oppia/app/splash/OnboardingActivityPresenter.kt b/app/src/main/java/org/oppia/app/splash/OnboardingActivityPresenter.kt
new file mode 100644
index 00000000000..2059d506518
--- /dev/null
+++ b/app/src/main/java/org/oppia/app/splash/OnboardingActivityPresenter.kt
@@ -0,0 +1,30 @@
+package org.oppia.app.help
+
+import android.content.Intent
+import androidx.appcompat.app.AppCompatActivity
+import kotlinx.android.synthetic.main.dummy_onboard.*
+import org.oppia.app.R
+import org.oppia.app.activity.ActivityScope
+import org.oppia.app.profile.ProfileActivity
+import org.oppia.domain.OnboardingFlowController
+import javax.inject.Inject
+
+/** The presenter for [OnboardingActivity]. */
+@ActivityScope
+class OnboardingActivityPresenter @Inject constructor(
+  private val activity: AppCompatActivity,
+  private val onboardingFlowController: OnboardingFlowController
+) {
+
+  fun handleOnCreate() {
+    activity.setContentView(R.layout.dummy_onboard)
+    activity.onboard.setOnClickListener({ subscribeToUserAppHistory() })
+  }
+
+  private fun subscribeToUserAppHistory() {
+    onboardingFlowController.markOnboardingFlowCompleted()
+    val intent = Intent(activity, ProfileActivity::class.java)
+    activity.startActivity(intent)
+    activity.finish()
+  }
+}
diff --git a/app/src/main/java/org/oppia/app/splash/SplashActivity.kt b/app/src/main/java/org/oppia/app/splash/SplashActivity.kt
index 24800879e12..e62d5e46486 100644
--- a/app/src/main/java/org/oppia/app/splash/SplashActivity.kt
+++ b/app/src/main/java/org/oppia/app/splash/SplashActivity.kt
@@ -1,33 +1,21 @@
 package org.oppia.app.splash
 
-import android.content.Intent
 import android.os.Bundle
-import android.view.WindowManager
-import androidx.appcompat.app.AppCompatActivity
-import org.oppia.app.R
-import org.oppia.app.model.UserAppHistory
+import org.oppia.app.activity.InjectableAppCompatActivity
+import org.oppia.app.help.SplashActivityPresenter
 import org.oppia.app.profile.ProfileActivity
 import javax.inject.Inject
 
 /** An activity that shows a temporary loading page until the app is fully loaded then navigates to [ProfileActivity]. */
-class SplashActivity : AppCompatActivity() {
+class SplashActivity : InjectableAppCompatActivity() {
 
-  @Inject lateinit var userAppHistory: UserAppHistory
+  @Inject
+  lateinit var splashActivityPresenter: SplashActivityPresenter
 
   override fun onCreate(savedInstanceState: Bundle?) {
     super.onCreate(savedInstanceState)
-    setContentView(R.layout.splash_activity)
-    window.setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN);
-    if (userAppHistory.alreadyOnBoardedApp) {
-      val intent = Intent(this@SplashActivity, ProfileActivity::class.java)
-      startActivity(intent)
-      finish()
-    } else {
-      // TODO (#454) : Replace ProfileActivity in this with OnboaridngActivity
-      val intent = Intent(this@SplashActivity, OnboardingActivity::class.java)
-      startActivity(intent)
-      finish()
-    }
+    activityComponent.inject(this)
+    splashActivityPresenter.handleOnCreate()
   }
 
 }
diff --git a/app/src/main/java/org/oppia/app/splash/SplashActivityPresenter.kt b/app/src/main/java/org/oppia/app/splash/SplashActivityPresenter.kt
new file mode 100644
index 00000000000..e632c9c20b6
--- /dev/null
+++ b/app/src/main/java/org/oppia/app/splash/SplashActivityPresenter.kt
@@ -0,0 +1,61 @@
+package org.oppia.app.help
+
+import android.content.Intent
+import android.view.WindowManager
+import androidx.appcompat.app.AppCompatActivity
+import androidx.lifecycle.LiveData
+import androidx.lifecycle.Observer
+import androidx.lifecycle.Transformations
+import org.oppia.app.R
+import org.oppia.app.activity.ActivityScope
+import org.oppia.app.model.OnboardingFlow
+import org.oppia.app.profile.ProfileActivity
+import org.oppia.app.splash.OnboardingActivity
+import org.oppia.domain.OnboardingFlowController
+import org.oppia.util.data.AsyncResult
+import javax.inject.Inject
+
+/** The presenter for [OnboardingActivity]. */
+@ActivityScope
+class SplashActivityPresenter @Inject constructor(
+  private val activity: AppCompatActivity,
+  onboardingFlowController: OnboardingFlowController
+) {
+
+  val sample = onboardingFlowController.getOnboardingFlow()
+
+  fun handleOnCreate() {
+    activity.setContentView(R.layout.splash_activity)
+    activity.window.setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN);
+    subscribeToOnboardingFlow()
+  }
+
+  private fun showOnboardingActivity() {
+    val intent = Intent(activity, OnboardingActivity::class.java)
+    activity.startActivity(intent)
+    activity.finish()
+  }
+
+  private fun subscribeToOnboardingFlow() {
+    getOnboardingFlow().observe(activity, Observer<OnboardingFlow> { result ->
+      if (result.alreadyOnBoardedApp) {
+        val intent = Intent(activity, ProfileActivity::class.java)
+        activity.startActivity(intent)
+        activity.finish()
+      } else {
+        showOnboardingActivity()
+      }
+    })
+  }
+
+  private fun getOnboardingFlow(): LiveData<OnboardingFlow> {
+    // If there's an error loading the data, assume the default.
+    return Transformations.map(sample, ::processOnboardingFlowResult)
+  }
+
+  private fun processOnboardingFlowResult(appHistoryResult: AsyncResult<OnboardingFlow>): OnboardingFlow {
+    if (appHistoryResult.isFailure()) {
+    }
+    return appHistoryResult.getOrDefault(OnboardingFlow.getDefaultInstance())
+  }
+}
diff --git a/app/src/main/res/layout/dummy_onboard.xml b/app/src/main/res/layout/dummy_onboard.xml
index 52610900c50..93a72ff47e4 100644
--- a/app/src/main/res/layout/dummy_onboard.xml
+++ b/app/src/main/res/layout/dummy_onboard.xml
@@ -1,16 +1,14 @@
 <?xml version="1.0" encoding="utf-8"?>
 <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
-  xmlns:tools="http://schemas.android.com/tools"
   android:layout_width="match_parent"
   android:layout_height="match_parent"
   android:gravity="center"
-  android:orientation="vertical"
-  tools:context=".splash.OnboardingActivity">
+  android:orientation="vertical">
 
   <Button
+    android:id="@+id/onboard"
     android:layout_width="wrap_content"
     android:layout_height="wrap_content"
-    android:text="onboard"
-    android:onClick="subscribeToUserAppHistory"/>
+    android:text="onboard" />
 </LinearLayout>
 
diff --git a/app/src/sharedTest/java/org/oppia/app/splash/SplashActivityTest.kt b/app/src/sharedTest/java/org/oppia/app/splash/SplashActivityTest.kt
index fbe2bca39fd..bbab2d172dc 100644
--- a/app/src/sharedTest/java/org/oppia/app/splash/SplashActivityTest.kt
+++ b/app/src/sharedTest/java/org/oppia/app/splash/SplashActivityTest.kt
@@ -1,16 +1,52 @@
 package org.oppia.app.splash
 
+import android.app.Application
+import android.content.Context
+import android.os.Handler
+import android.os.Looper
+import android.view.View
+import androidx.test.core.app.ActivityScenario.launch
+import androidx.test.core.app.ApplicationProvider
+import androidx.test.espresso.Espresso.onIdle
+import androidx.test.espresso.Espresso.onView
+import androidx.test.espresso.IdlingRegistry
+import androidx.test.espresso.PerformException
+import androidx.test.espresso.UiController
+import androidx.test.espresso.ViewAction
+import androidx.test.espresso.ViewInteraction
+import androidx.test.espresso.assertion.ViewAssertions.matches
+import androidx.test.espresso.idling.CountingIdlingResource
 import androidx.test.espresso.intent.Intents
 import androidx.test.espresso.intent.Intents.intended
 import androidx.test.espresso.intent.matcher.IntentMatchers.hasComponent
+import androidx.test.espresso.matcher.ViewMatchers.isRoot
+import androidx.test.espresso.matcher.ViewMatchers.withId
+import androidx.test.espresso.matcher.ViewMatchers.withText
+import androidx.test.espresso.util.HumanReadables
+import androidx.test.espresso.util.TreeIterables
 import androidx.test.ext.junit.runners.AndroidJUnit4
 import androidx.test.rule.ActivityTestRule
+import dagger.BindsInstance
+import dagger.Component
+import dagger.Module
+import dagger.Provides
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.asCoroutineDispatcher
+import org.hamcrest.Matcher
 import org.junit.After
 import org.junit.Before
 import org.junit.Rule
 import org.junit.Test
 import org.junit.runner.RunWith
+import org.oppia.app.R
 import org.oppia.app.profile.ProfileActivity
+import org.oppia.domain.OnboardingFlowController
+import org.oppia.util.threading.BackgroundDispatcher
+import org.oppia.util.threading.BlockingDispatcher
+import java.util.concurrent.AbstractExecutorService
+import java.util.concurrent.TimeUnit
+import java.util.concurrent.TimeoutException
+import javax.inject.Singleton
 
 /**
  * Tests for [SplashActivity]. For context on the activity test rule setup see:
@@ -18,6 +54,180 @@ import org.oppia.app.profile.ProfileActivity
  */
 @RunWith(AndroidJUnit4::class)
 class SplashActivityTest {
+  @Before
+  fun setUp() {
+    Intents.init()
+    IdlingRegistry.getInstance().register(MainThreadExecutor.countingResource)
+    simulateNewAppInstance()
+  }
+
+  @After
+  fun tearDown() {
+    IdlingRegistry.getInstance().unregister(MainThreadExecutor.countingResource)
+    Intents.release()
+  }
+
+
+
+  @Test
+  fun testMainActivity_secondOpen_showsProfileChooserScreenAndHasSelectYourProfileString() {
+    simulateAppAlreadyOpened()
+
+    launch(SplashActivity::class.java).use {
+      // Wait until the expected text appears on the screen, and ensure it's for the welcome text view.
+//      waitForTheView(withText(R.string.profile_chooser_select))
+      onView(withId(R.id.profile_select_text)).check(matches(withText(R.string.profile_chooser_select)))
+    }
+  }
+
+  private fun simulateNewAppInstance() {
+    // Simulate a fresh app install by clearing any potential on-disk caches using an isolated app history controller.
+    createTestRootComponent().getOnboardingFlowController().clearOnboardingFlow()
+    onIdle()
+  }
+
+  private fun simulateAppAlreadyOpened() {
+    // Simulate the app was already opened by creating an isolated app history controller and saving the opened status
+    // on the system before the activity is opened.
+    createTestRootComponent().getOnboardingFlowController().markOnboardingFlowCompleted()
+    onIdle()
+  }
+
+  private fun createTestRootComponent(): TestApplicationComponent {
+    return DaggerSplashActivityTest_TestApplicationComponent.builder()
+      .setApplication(ApplicationProvider.getApplicationContext())
+      .build()
+  }
+
+  private fun waitForTheView(viewMatcher: Matcher<View>): ViewInteraction {
+    return onView(isRoot()).perform(waitForMatch(viewMatcher, 30000L))
+  }
+
+  // TODO(#59): Remove these waits once we can ensure that the production executors are not depended on in tests.
+  //  Sleeping is really bad practice in Espresso tests, and can lead to test flakiness. It shouldn't be necessary if we
+  //  use a test executor service with a counting idle resource, but right now Gradle mixes dependencies such that both
+  //  the test and production blocking executors are being used. The latter cannot be updated to notify Espresso of any
+  //  active coroutines, so the test attempts to assert state before it's ready. This artificial delay in the Espresso
+  //  thread helps to counter that.
+  /**
+   * Perform action of waiting for a specific matcher to finish. Adapted from:
+   * https://stackoverflow.com/a/22563297/3689782.
+   */
+  private fun waitForMatch(viewMatcher: Matcher<View>, millis: Long): ViewAction {
+    return object : ViewAction {
+      override fun getDescription(): String {
+        return "wait for a specific view with matcher <$viewMatcher> during $millis millis."
+      }
+
+      override fun getConstraints(): Matcher<View> {
+        return isRoot()
+      }
+
+      override fun perform(uiController: UiController?, view: View?) {
+        checkNotNull(uiController)
+        uiController.loopMainThreadUntilIdle()
+        val startTime = System.currentTimeMillis()
+        val endTime = startTime + millis
+
+        do {
+          if (TreeIterables.breadthFirstViewTraversal(view).any { viewMatcher.matches(it) }) {
+            return
+          }
+          uiController.loopMainThreadForAtLeast(50)
+        } while (System.currentTimeMillis() < endTime)
+
+        // Couldn't match in time.
+        throw PerformException.Builder()
+          .withActionDescription(description)
+          .withViewDescription(HumanReadables.describe(view))
+          .withCause(TimeoutException())
+          .build()
+      }
+    }
+  }
+
+  @Module
+  class TestModule {
+    @Provides
+    @Singleton
+    fun provideContext(application: Application): Context {
+      return application
+    }
+
+    // TODO(#89): Introduce a proper IdlingResource for background dispatchers to ensure they all complete before
+    //  proceeding in an Espresso test. This solution should also be interoperative with Robolectric contexts by using a
+    //  test coroutine dispatcher.
+
+    @Singleton
+    @Provides
+    @BackgroundDispatcher
+    fun provideBackgroundDispatcher(@BlockingDispatcher blockingDispatcher: CoroutineDispatcher): CoroutineDispatcher {
+      return blockingDispatcher
+    }
+
+    @Singleton
+    @Provides
+    @BlockingDispatcher
+    fun provideBlockingDispatcher(): CoroutineDispatcher {
+      return MainThreadExecutor.asCoroutineDispatcher()
+    }
+  }
+
+  @Singleton
+  @Component(modules = [TestModule::class])
+  interface TestApplicationComponent {
+    @Component.Builder
+    interface Builder {
+      @BindsInstance
+      fun setApplication(application: Application): Builder
+      fun build(): TestApplicationComponent
+    }
+
+    fun getOnboardingFlowController(): OnboardingFlowController
+  }
+
+  // TODO(#59): Move this to a general-purpose testing library that replaces all CoroutineExecutors with an
+  //  Espresso-enabled executor service. This service should also allow for background threads to run in both Espresso
+  //  and Robolectric to help catch potential race conditions, rather than forcing parallel execution to be sequential
+  //  and immediate.
+  //  NB: This also blocks on #59 to be able to actually create a test-only library.
+  /**
+   * An executor service that schedules all [Runnable]s to run asynchronously on the main thread. This is based on:
+   * https://android.googlesource.com/platform/packages/apps/TV/+/android-live-tv/src/com/android/tv/util/MainThreadExecutor.java.
+   */
+  private object MainThreadExecutor: AbstractExecutorService() {
+    override fun isTerminated(): Boolean = false
+
+    private val handler = Handler(Looper.getMainLooper())
+    val countingResource = CountingIdlingResource("main_thread_executor_counting_idling_resource")
+
+    override fun execute(command: Runnable?) {
+      countingResource.increment()
+      handler.post {
+        try {
+          command?.run()
+        } finally {
+          countingResource.decrement()
+        }
+      }
+    }
+
+    override fun shutdown() {
+      throw UnsupportedOperationException()
+    }
+
+    override fun shutdownNow(): MutableList<Runnable> {
+      throw UnsupportedOperationException()
+    }
+
+    override fun isShutdown(): Boolean = false
+
+    override fun awaitTermination(timeout: Long, unit: TimeUnit?): Boolean {
+      throw UnsupportedOperationException()
+    }
+  }
+
+
 
   // The initialTouchMode enables the activity to be launched in touch mode. The launchActivity is
   // disabled to launch Activity explicitly within each test case.
@@ -26,19 +236,19 @@ class SplashActivityTest {
     SplashActivity::class.java, /* initialTouchMode= */ true, /* launchActivity= */ false
   )
 
-  @Before
-  fun setUp() {
-    Intents.init()
-  }
+//  @Before
+//  fun setUp() {
+//    Intents.init()
+//  }
 
   @Test
-  fun testSplashActivity_initialOpen_routesToHomeActivity() {
+  fun testSplashActivity_initialOpen_routesToSplashActivity() {
     activityTestRule.launchActivity(null)
     intended(hasComponent(ProfileActivity::class.java.name))
   }
 
-  @After
-  fun tearDown() {
-    Intents.release()
-  }
+//  @After
+//  fun tearDown() {
+//    Intents.release()
+//  }
 }
diff --git a/domain/src/main/java/org/oppia/domain/OnboardingFlowController.kt b/domain/src/main/java/org/oppia/domain/OnboardingFlowController.kt
new file mode 100644
index 00000000000..020bfcf9814
--- /dev/null
+++ b/domain/src/main/java/org/oppia/domain/OnboardingFlowController.kt
@@ -0,0 +1,60 @@
+package org.oppia.domain
+
+import androidx.lifecycle.LiveData
+import org.oppia.app.model.OnboardingFlow
+import org.oppia.data.persistence.PersistentCacheStore
+import org.oppia.util.data.AsyncResult
+import org.oppia.util.data.DataProviders
+import org.oppia.util.logging.Logger
+import javax.inject.Inject
+import javax.inject.Singleton
+
+/** Controller for persisting and retrieving the previous user history of using the app. */
+@Singleton
+class OnboardingFlowController @Inject constructor(
+  cacheStoreFactory: PersistentCacheStore.Factory, private val dataProviders: DataProviders,
+  private val logger: Logger
+) {
+  private val appHistoryStore = cacheStoreFactory.create("onboarding_flow", OnboardingFlow.getDefaultInstance())
+
+  init {
+    // Prime the cache ahead of time so that any existing history is read prior to any calls to markUserOpenedApp().
+    appHistoryStore.primeCacheAsync().invokeOnCompletion {
+      it?.let {
+        logger.e("DOMAIN", "Failed to prime cache ahead of LiveData conversion for user app open history.", it)
+      }
+    }
+  }
+
+  /**
+   * Saves that the user has opened the app. Note that this does not notify existing subscribers of the changed state,
+   * nor can future subscribers observe this state until app restart.
+   */
+  fun markOnboardingFlowCompleted() {
+    appHistoryStore.storeDataAsync(updateInMemoryCache = false) {
+      it.toBuilder().setAlreadyOnBoardedApp(true).build()
+    }.invokeOnCompletion {
+      it?.let {
+        logger.e("DOMAIN", "Failed when storing that the user already opened the app.", it)
+      }
+    }
+  }
+
+  /** Clears any indication that the user has previously opened the application. */
+  fun clearOnboardingFlow() {
+    appHistoryStore.clearCacheAsync().invokeOnCompletion {
+      it?.let {
+        logger.e("DOMAIN", "Failed to clear onboarding flow.", it)
+      }
+    }
+  }
+
+  /**
+   * Returns a [LiveData] result indicating whether the user has previously opened the app. This is guaranteed to
+   * provide the state of the store upon the creation of this controller even if [markUserOpenedApp] has since been
+   * called.
+   */
+  fun getOnboardingFlow(): LiveData<AsyncResult<OnboardingFlow>> {
+    return dataProviders.convertToLiveData(appHistoryStore)
+  }
+}
\ No newline at end of file
diff --git a/domain/src/main/java/org/oppia/domain/UserAppHistoryController.kt b/domain/src/main/java/org/oppia/domain/UserAppHistoryController.kt
index 28aa1ee367b..e505a5f8861 100644
--- a/domain/src/main/java/org/oppia/domain/UserAppHistoryController.kt
+++ b/domain/src/main/java/org/oppia/domain/UserAppHistoryController.kt
@@ -47,18 +47,6 @@ class UserAppHistoryController @Inject constructor(
         logger.e("DOMAIN", "Failed to clear user app history.", it)
       }
     }
-  } /**
-   * Saves that the user has opened the app. Note that this does not notify existing subscribers of the changed state,
-   * nor can future subscribers observe this state until app restart.
-   */
-  fun markUserOnboardedApp() {
-    appHistoryStore.storeDataAsync(updateInMemoryCache = false) {
-      it.toBuilder().setAlreadyOnBoardedApp(true).build()
-    }.invokeOnCompletion {
-      it?.let {
-        logger.e("DOMAIN", "Failed when storing that the user already opened the app.", it)
-      }
-    }
   }
 
   /**
diff --git a/domain/src/test/java/org/oppia/domain/OnboardingFlowControllerTest.kt b/domain/src/test/java/org/oppia/domain/OnboardingFlowControllerTest.kt
new file mode 100644
index 00000000000..2273f25ecbf
--- /dev/null
+++ b/domain/src/test/java/org/oppia/domain/OnboardingFlowControllerTest.kt
@@ -0,0 +1,234 @@
+package org.oppia.domain
+
+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.OnboardingFlow
+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
+
+/** Tests for [OnboardingFlowController]. */
+@RunWith(AndroidJUnit4::class)
+@Config(manifest = Config.NONE)
+class OnboardingFlowControllerTest {
+  @Rule
+  @JvmField
+  val mockitoRule: MockitoRule = MockitoJUnit.rule()
+
+  @Rule
+  @JvmField
+  val executorRule = InstantTaskExecutorRule()
+
+  @Inject
+  lateinit var onboardingFlowController: OnboardingFlowController
+
+  @Inject
+  @field:TestDispatcher
+  lateinit var testDispatcher: CoroutineDispatcher
+
+  private val coroutineContext by lazy {
+    EmptyCoroutineContext + testDispatcher
+  }
+
+  @Mock
+  lateinit var mockAppHistoryObserver: Observer<AsyncResult<OnboardingFlow>>
+
+  @Captor
+  lateinit var appHistoryResultCaptor: ArgumentCaptor<AsyncResult<OnboardingFlow>>
+
+  // 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() {
+    DaggerOnboardingFlowControllerTest_TestApplicationComponent.builder()
+      .setApplication(ApplicationProvider.getApplicationContext())
+      .build()
+      .inject(this)
+  }
+
+  @Test
+  @ExperimentalCoroutinesApi
+  fun testController_providesInitialLiveData_thatIndicatesUserHasNotOpenedTheApp() = runBlockingTest(coroutineContext) {
+    val appHistory = onboardingFlowController.getOnboardingFlow()
+    advanceUntilIdle()
+    appHistory.observeForever(mockAppHistoryObserver)
+
+    verify(mockAppHistoryObserver, atLeastOnce()).onChanged(appHistoryResultCaptor.capture())
+    assertThat(appHistoryResultCaptor.value.isSuccess()).isTrue()
+    assertThat(appHistoryResultCaptor.value.getOrThrow().alreadyOnBoardedApp).isFalse()
+  }
+
+  @Test
+  @ExperimentalCoroutinesApi
+  fun testControllerObserver_observedAfterSettingAppOpened_providesLiveData_userDidNotOpenApp() =
+    runBlockingTest(coroutineContext) {
+      val appHistory = onboardingFlowController.getOnboardingFlow()
+
+      appHistory.observeForever(mockAppHistoryObserver)
+      onboardingFlowController.markOnboardingFlowCompleted()
+      advanceUntilIdle()
+
+      // The result should not indicate that the user opened the app because markUserOpenedApp does not notify observers
+      // of the change.
+      verify(mockAppHistoryObserver, atLeastOnce()).onChanged(appHistoryResultCaptor.capture())
+      assertThat(appHistoryResultCaptor.value.isSuccess()).isTrue()
+      assertThat(appHistoryResultCaptor.value.getOrThrow().alreadyOnBoardedApp).isFalse()
+    }
+
+  @Test
+  @ExperimentalCoroutinesApi
+  fun testController_settingAppOpened_observedNewController_userOpenedApp() = runBlockingTest(coroutineContext) {
+    onboardingFlowController.markOnboardingFlowCompleted()
+    advanceUntilIdle()
+
+    // Create the controller by creating another singleton graph and injecting it (simulating the app being recreated).
+    setUpTestApplicationComponent()
+    val appHistory = onboardingFlowController.getOnboardingFlow()
+    appHistory.observeForever(mockAppHistoryObserver)
+    advanceUntilIdle()
+
+    // The app should be considered open since a new LiveData instance was observed after marking the app as opened.
+    verify(mockAppHistoryObserver, atLeastOnce()).onChanged(appHistoryResultCaptor.capture())
+    assertThat(appHistoryResultCaptor.value.isSuccess()).isTrue()
+    assertThat(appHistoryResultCaptor.value.getOrThrow().alreadyOnBoardedApp).isTrue()
+  }
+
+  @Test
+  @ExperimentalCoroutinesApi
+  fun testController_openedApp_cleared_observeNewController_userDidNotOpenApp() = runBlockingTest(coroutineContext) {
+    onboardingFlowController.markOnboardingFlowCompleted()
+    advanceUntilIdle()
+
+    // Clear, then recreate another controller.
+    onboardingFlowController.clearOnboardingFlow()
+    setUpTestApplicationComponent()
+    val appHistory = onboardingFlowController.getOnboardingFlow()
+    appHistory.observeForever(mockAppHistoryObserver)
+    advanceUntilIdle()
+
+    // The app should be considered not yet opened since the previous history was cleared.
+    verify(mockAppHistoryObserver, atLeastOnce()).onChanged(appHistoryResultCaptor.capture())
+    assertThat(appHistoryResultCaptor.value.isSuccess()).isTrue()
+    assertThat(appHistoryResultCaptor.value.getOrThrow().alreadyOnBoardedApp).isFalse()
+  }
+
+  @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(onboardingFlowControllerTest: OnboardingFlowControllerTest)
+  }
+}
diff --git a/domain/src/test/java/org/oppia/domain/UserAppHistoryControllerTest.kt b/domain/src/test/java/org/oppia/domain/UserAppHistoryControllerTest.kt
index f73881afbe2..1e6a1d53141 100644
--- a/domain/src/test/java/org/oppia/domain/UserAppHistoryControllerTest.kt
+++ b/domain/src/test/java/org/oppia/domain/UserAppHistoryControllerTest.kt
@@ -58,7 +58,8 @@ class UserAppHistoryControllerTest {
   @JvmField
   val executorRule = InstantTaskExecutorRule()
 
-  @Inject lateinit var userAppHistoryController: UserAppHistoryController
+  @Inject
+  lateinit var userAppHistoryController: UserAppHistoryController
 
   @Inject
   @field:TestDispatcher
@@ -115,25 +116,24 @@ class UserAppHistoryControllerTest {
 
   @Test
   @ExperimentalCoroutinesApi
-  fun testControllerObserver_observedAfterSettingAppOpened_providesLiveData_userDidNotOpenApp()
-      = runBlockingTest(coroutineContext) {
-    val appHistory = userAppHistoryController.getUserAppHistory()
-
-    appHistory.observeForever(mockAppHistoryObserver)
-    userAppHistoryController.markUserOpenedApp()
-    advanceUntilIdle()
-
-    // The result should not indicate that the user opened the app because markUserOpenedApp does not notify observers
-    // of the change.
-    verify(mockAppHistoryObserver, atLeastOnce()).onChanged(appHistoryResultCaptor.capture())
-    assertThat(appHistoryResultCaptor.value.isSuccess()).isTrue()
-    assertThat(appHistoryResultCaptor.value.getOrThrow().alreadyOpenedApp).isFalse()
-  }
+  fun testControllerObserver_observedAfterSettingAppOpened_providesLiveData_userDidNotOpenApp() =
+    runBlockingTest(coroutineContext) {
+      val appHistory = userAppHistoryController.getUserAppHistory()
+
+      appHistory.observeForever(mockAppHistoryObserver)
+      userAppHistoryController.markUserOpenedApp()
+      advanceUntilIdle()
+
+      // The result should not indicate that the user opened the app because markUserOpenedApp does not notify observers
+      // of the change.
+      verify(mockAppHistoryObserver, atLeastOnce()).onChanged(appHistoryResultCaptor.capture())
+      assertThat(appHistoryResultCaptor.value.isSuccess()).isTrue()
+      assertThat(appHistoryResultCaptor.value.getOrThrow().alreadyOpenedApp).isFalse()
+    }
 
   @Test
   @ExperimentalCoroutinesApi
-  fun testController_settingAppOpened_observedNewController_userOpenedApp()
-      = runBlockingTest(coroutineContext) {
+  fun testController_settingAppOpened_observedNewController_userOpenedApp() = runBlockingTest(coroutineContext) {
     userAppHistoryController.markUserOpenedApp()
     advanceUntilIdle()
 
@@ -168,7 +168,8 @@ class UserAppHistoryControllerTest {
     assertThat(appHistoryResultCaptor.value.getOrThrow().alreadyOpenedApp).isFalse()
   }
 
-  @Qualifier annotation class TestDispatcher
+  @Qualifier
+  annotation class TestDispatcher
 
   // TODO(#89): Move this to a common test application component.
   @Module
@@ -224,6 +225,7 @@ class UserAppHistoryControllerTest {
     interface Builder {
       @BindsInstance
       fun setApplication(application: Application): Builder
+
       fun build(): TestApplicationComponent
     }
 
diff --git a/model/src/main/proto/example.proto b/model/src/main/proto/example.proto
index a5463d5a015..44e038a6651 100644
--- a/model/src/main/proto/example.proto
+++ b/model/src/main/proto/example.proto
@@ -7,7 +7,10 @@ option java_multiple_files = true;
 
 message UserAppHistory {
   bool already_opened_app = 1;
-  bool already_on_boarded_app = 2;
+}
+
+message OnboardingFlow {
+  bool already_on_boarded_app = 1;
 }
 
 message TestMessage {

From e62071ef9574bd5721879cc17399e3fef4898d2a Mon Sep 17 00:00:00 2001
From: marysoloman <nikitamarysolomanpvt@gmail.com>
Date: Thu, 26 Dec 2019 17:45:22 +0530
Subject: [PATCH 03/19] test cases for onboarding flow

---
 .../main/java/org/oppia/domain/OnboardingFlowController.kt  | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/domain/src/main/java/org/oppia/domain/OnboardingFlowController.kt b/domain/src/main/java/org/oppia/domain/OnboardingFlowController.kt
index 020bfcf9814..f7b80337ef5 100644
--- a/domain/src/main/java/org/oppia/domain/OnboardingFlowController.kt
+++ b/domain/src/main/java/org/oppia/domain/OnboardingFlowController.kt
@@ -27,7 +27,7 @@ class OnboardingFlowController @Inject constructor(
   }
 
   /**
-   * Saves that the user has opened the app. Note that this does not notify existing subscribers of the changed state,
+   * Saves that the user has completed on-boarding the app. Note that this does not notify existing subscribers of the changed state,
    * nor can future subscribers observe this state until app restart.
    */
   fun markOnboardingFlowCompleted() {
@@ -40,7 +40,7 @@ class OnboardingFlowController @Inject constructor(
     }
   }
 
-  /** Clears any indication that the user has previously opened the application. */
+  /** Clears any indication that the user has previously completed on-boarding the application. */
   fun clearOnboardingFlow() {
     appHistoryStore.clearCacheAsync().invokeOnCompletion {
       it?.let {
@@ -51,7 +51,7 @@ class OnboardingFlowController @Inject constructor(
 
   /**
    * Returns a [LiveData] result indicating whether the user has previously opened the app. This is guaranteed to
-   * provide the state of the store upon the creation of this controller even if [markUserOpenedApp] has since been
+   * provide the state of the store upon the creation of this controller even if [markOnboardingFlowCompleted] has since been
    * called.
    */
   fun getOnboardingFlow(): LiveData<AsyncResult<OnboardingFlow>> {

From 4e19665aa5c1e5bedb7f45904f6f54716dd8ce05 Mon Sep 17 00:00:00 2001
From: marysoloman <nikitamarysolomanpvt@gmail.com>
Date: Thu, 2 Jan 2020 11:21:09 +0530
Subject: [PATCH 04/19] package change in onboarding classes

---
 app/src/main/AndroidManifest.xml                                | 2 +-
 app/src/main/java/org/oppia/app/activity/ActivityComponent.kt   | 2 +-
 .../org/oppia/app/{splash => onboarding}/OnboardingActivity.kt  | 2 +-
 .../app/{splash => onboarding}/OnboardingActivityPresenter.kt   | 0
 .../main/java/org/oppia/app/splash/SplashActivityPresenter.kt   | 2 +-
 5 files changed, 4 insertions(+), 4 deletions(-)
 rename app/src/main/java/org/oppia/app/{splash => onboarding}/OnboardingActivity.kt (95%)
 rename app/src/main/java/org/oppia/app/{splash => onboarding}/OnboardingActivityPresenter.kt (100%)

diff --git a/app/src/main/AndroidManifest.xml b/app/src/main/AndroidManifest.xml
index 5e6ad587093..ef04d933aa3 100644
--- a/app/src/main/AndroidManifest.xml
+++ b/app/src/main/AndroidManifest.xml
@@ -63,7 +63,7 @@
       android:name=".settings.profile.ProfileResetPinActivity"
       android:screenOrientation="portrait" />
     <activity
-      android:name=".splash.OnboardingActivity"
+      android:name=".onboarding.OnboardingActivity"
       android:screenOrientation="portrait"
       android:theme="@style/OppiaThemeWithoutActionBar" />
     <activity
diff --git a/app/src/main/java/org/oppia/app/activity/ActivityComponent.kt b/app/src/main/java/org/oppia/app/activity/ActivityComponent.kt
index d61bd11b8a4..cd07f163052 100644
--- a/app/src/main/java/org/oppia/app/activity/ActivityComponent.kt
+++ b/app/src/main/java/org/oppia/app/activity/ActivityComponent.kt
@@ -8,6 +8,7 @@ import org.oppia.app.help.HelpActivity
 import org.oppia.app.home.HomeActivity
 import org.oppia.app.home.continueplaying.ContinuePlayingActivity
 import org.oppia.app.mydownloads.MyDownloadsActivity
+import org.oppia.app.onboarding.OnboardingActivity
 import org.oppia.app.player.exploration.ExplorationActivity
 import org.oppia.app.profile.AddProfileActivity
 import org.oppia.app.profile.AdminAuthActivity
@@ -18,7 +19,6 @@ import org.oppia.app.settings.profile.ProfileEditActivity
 import org.oppia.app.settings.profile.ProfileListActivity
 import org.oppia.app.settings.profile.ProfileRenameActivity
 import org.oppia.app.settings.profile.ProfileResetPinActivity
-import org.oppia.app.splash.OnboardingActivity
 import org.oppia.app.splash.SplashActivity
 import org.oppia.app.story.StoryActivity
 import org.oppia.app.story.testing.StoryFragmentTestActivity
diff --git a/app/src/main/java/org/oppia/app/splash/OnboardingActivity.kt b/app/src/main/java/org/oppia/app/onboarding/OnboardingActivity.kt
similarity index 95%
rename from app/src/main/java/org/oppia/app/splash/OnboardingActivity.kt
rename to app/src/main/java/org/oppia/app/onboarding/OnboardingActivity.kt
index 386ac862406..762d7a61b06 100644
--- a/app/src/main/java/org/oppia/app/splash/OnboardingActivity.kt
+++ b/app/src/main/java/org/oppia/app/onboarding/OnboardingActivity.kt
@@ -1,4 +1,4 @@
-package org.oppia.app.splash
+package org.oppia.app.onboarding
 
 import android.os.Bundle
 import org.oppia.app.activity.InjectableAppCompatActivity
diff --git a/app/src/main/java/org/oppia/app/splash/OnboardingActivityPresenter.kt b/app/src/main/java/org/oppia/app/onboarding/OnboardingActivityPresenter.kt
similarity index 100%
rename from app/src/main/java/org/oppia/app/splash/OnboardingActivityPresenter.kt
rename to app/src/main/java/org/oppia/app/onboarding/OnboardingActivityPresenter.kt
diff --git a/app/src/main/java/org/oppia/app/splash/SplashActivityPresenter.kt b/app/src/main/java/org/oppia/app/splash/SplashActivityPresenter.kt
index e632c9c20b6..15dc8d42e0f 100644
--- a/app/src/main/java/org/oppia/app/splash/SplashActivityPresenter.kt
+++ b/app/src/main/java/org/oppia/app/splash/SplashActivityPresenter.kt
@@ -9,8 +9,8 @@ import androidx.lifecycle.Transformations
 import org.oppia.app.R
 import org.oppia.app.activity.ActivityScope
 import org.oppia.app.model.OnboardingFlow
+import org.oppia.app.onboarding.OnboardingActivity
 import org.oppia.app.profile.ProfileActivity
-import org.oppia.app.splash.OnboardingActivity
 import org.oppia.domain.OnboardingFlowController
 import org.oppia.util.data.AsyncResult
 import javax.inject.Inject

From 4fdc6be5b676fff2a64461376fb8145eb87bd23d Mon Sep 17 00:00:00 2001
From: marysoloman <nikitamarysolomanpvt@gmail.com>
Date: Thu, 2 Jan 2020 17:40:31 +0530
Subject: [PATCH 05/19] SplashActivityTest updated

---
 app/src/main/AndroidManifest.xml              |  8 +--
 .../oppia/app/splash/SplashActivityTest.kt    | 66 +++++++++++--------
 2 files changed, 44 insertions(+), 30 deletions(-)

diff --git a/app/src/main/AndroidManifest.xml b/app/src/main/AndroidManifest.xml
index ef04d933aa3..e3b524e4d72 100644
--- a/app/src/main/AndroidManifest.xml
+++ b/app/src/main/AndroidManifest.xml
@@ -29,6 +29,10 @@
       android:name=".mydownloads.MyDownloadsActivity"
       android:screenOrientation="portrait"
       android:theme="@style/OppiaThemeWithoutActionBar" />
+    <activity
+      android:name=".onboarding.OnboardingActivity"
+      android:screenOrientation="portrait"
+      android:theme="@style/OppiaThemeWithoutActionBar" />
     <activity
       android:name=".player.exploration.ExplorationActivity"
       android:screenOrientation="portrait"
@@ -62,10 +66,6 @@
     <activity
       android:name=".settings.profile.ProfileResetPinActivity"
       android:screenOrientation="portrait" />
-    <activity
-      android:name=".onboarding.OnboardingActivity"
-      android:screenOrientation="portrait"
-      android:theme="@style/OppiaThemeWithoutActionBar" />
     <activity
       android:name=".splash.SplashActivity"
       android:screenOrientation="portrait"
diff --git a/app/src/sharedTest/java/org/oppia/app/splash/SplashActivityTest.kt b/app/src/sharedTest/java/org/oppia/app/splash/SplashActivityTest.kt
index bbab2d172dc..2c396d29c22 100644
--- a/app/src/sharedTest/java/org/oppia/app/splash/SplashActivityTest.kt
+++ b/app/src/sharedTest/java/org/oppia/app/splash/SplashActivityTest.kt
@@ -31,7 +31,9 @@ import dagger.Component
 import dagger.Module
 import dagger.Provides
 import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.asCoroutineDispatcher
+import kotlinx.coroutines.test.TestCoroutineDispatcher
 import org.hamcrest.Matcher
 import org.junit.After
 import org.junit.Before
@@ -39,13 +41,18 @@ import org.junit.Rule
 import org.junit.Test
 import org.junit.runner.RunWith
 import org.oppia.app.R
-import org.oppia.app.profile.ProfileActivity
+import org.oppia.app.onboarding.OnboardingActivity
 import org.oppia.domain.OnboardingFlowController
+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 java.util.concurrent.AbstractExecutorService
 import java.util.concurrent.TimeUnit
 import java.util.concurrent.TimeoutException
+import javax.inject.Qualifier
 import javax.inject.Singleton
 
 /**
@@ -67,15 +74,11 @@ class SplashActivityTest {
     Intents.release()
   }
 
-
-
   @Test
-  fun testMainActivity_secondOpen_showsProfileChooserScreenAndHasSelectYourProfileString() {
+  fun testSplashActivity_secondOpen_showsProfileChooserScreenAndHasSelectYourProfileString() {
     simulateAppAlreadyOpened()
-
     launch(SplashActivity::class.java).use {
       // Wait until the expected text appears on the screen, and ensure it's for the welcome text view.
-//      waitForTheView(withText(R.string.profile_chooser_select))
       onView(withId(R.id.profile_select_text)).check(matches(withText(R.string.profile_chooser_select)))
     }
   }
@@ -146,6 +149,9 @@ class SplashActivityTest {
     }
   }
 
+  @Qualifier
+  annotation class TestDispatcher
+
   @Module
   class TestModule {
     @Provides
@@ -154,17 +160,35 @@ class SplashActivityTest {
       return application
     }
 
-    // TODO(#89): Introduce a proper IdlingResource for background dispatchers to ensure they all complete before
-    //  proceeding in an Espresso test. This solution should also be interoperative with Robolectric contexts by using a
-    //  test coroutine dispatcher.
+    @ExperimentalCoroutinesApi
+    @Singleton
+    @Provides
+    @TestDispatcher
+    fun provideTestDispatcher(): CoroutineDispatcher {
+      return TestCoroutineDispatcher()
+    }
 
     @Singleton
     @Provides
     @BackgroundDispatcher
-    fun provideBackgroundDispatcher(@BlockingDispatcher blockingDispatcher: CoroutineDispatcher): CoroutineDispatcher {
-      return blockingDispatcher
+    fun provideBackgroundDispatcher(@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
+
     @Singleton
     @Provides
     @BlockingDispatcher
@@ -180,10 +204,12 @@ class SplashActivityTest {
     interface Builder {
       @BindsInstance
       fun setApplication(application: Application): Builder
+
       fun build(): TestApplicationComponent
     }
 
     fun getOnboardingFlowController(): OnboardingFlowController
+    fun inject(splashActivityTest: SplashActivityTest)
   }
 
   // TODO(#59): Move this to a general-purpose testing library that replaces all CoroutineExecutors with an
@@ -195,7 +221,7 @@ class SplashActivityTest {
    * An executor service that schedules all [Runnable]s to run asynchronously on the main thread. This is based on:
    * https://android.googlesource.com/platform/packages/apps/TV/+/android-live-tv/src/com/android/tv/util/MainThreadExecutor.java.
    */
-  private object MainThreadExecutor: AbstractExecutorService() {
+  private object MainThreadExecutor : AbstractExecutorService() {
     override fun isTerminated(): Boolean = false
 
     private val handler = Handler(Looper.getMainLooper())
@@ -227,8 +253,6 @@ class SplashActivityTest {
     }
   }
 
-
-
   // The initialTouchMode enables the activity to be launched in touch mode. The launchActivity is
   // disabled to launch Activity explicitly within each test case.
   @get:Rule
@@ -236,19 +260,9 @@ class SplashActivityTest {
     SplashActivity::class.java, /* initialTouchMode= */ true, /* launchActivity= */ false
   )
 
-//  @Before
-//  fun setUp() {
-//    Intents.init()
-//  }
-
   @Test
-  fun testSplashActivity_initialOpen_routesToSplashActivity() {
+  fun testSplashActivity_initialOpen_routesToOnboardingActivity() {
     activityTestRule.launchActivity(null)
-    intended(hasComponent(ProfileActivity::class.java.name))
+    intended(hasComponent(OnboardingActivity::class.java.name))
   }
-
-//  @After
-//  fun tearDown() {
-//    Intents.release()
-//  }
 }

From 552b9d96f2de3c61534733da85406e92cc79d1f9 Mon Sep 17 00:00:00 2001
From: marysoloman <nikitamarysolomanpvt@gmail.com>
Date: Thu, 2 Jan 2020 18:51:22 +0530
Subject: [PATCH 06/19] SplashActivityTest updated

---
 .../java/org/oppia/app/home/UserAppHistoryViewModel.kt    | 3 ---
 .../java/org/oppia/app/onboarding/OnboardingActivity.kt   | 1 -
 .../oppia/app/onboarding/OnboardingActivityPresenter.kt   | 2 +-
 .../java/org/oppia/domain/OnboardingFlowController.kt     | 8 ++++----
 4 files changed, 5 insertions(+), 9 deletions(-)

diff --git a/app/src/main/java/org/oppia/app/home/UserAppHistoryViewModel.kt b/app/src/main/java/org/oppia/app/home/UserAppHistoryViewModel.kt
index 48d7260c72e..6b43dd7787f 100644
--- a/app/src/main/java/org/oppia/app/home/UserAppHistoryViewModel.kt
+++ b/app/src/main/java/org/oppia/app/home/UserAppHistoryViewModel.kt
@@ -8,7 +8,4 @@ class UserAppHistoryViewModel : HomeItemViewModel() {
   var isAppAlreadyOpened = ObservableField<Boolean>(false)
 
   fun setAlreadyAppOpened(alreadyOpenedApp: Boolean) = isAppAlreadyOpened.set(alreadyOpenedApp)
-  var isAppAlreadyOnboarded = ObservableField<Boolean>(false)
-
-  fun setAlreadyAppOnboarded(isalreadyOnboardedApp: Boolean) = isAppAlreadyOnboarded.set(isalreadyOnboardedApp)
 }
diff --git a/app/src/main/java/org/oppia/app/onboarding/OnboardingActivity.kt b/app/src/main/java/org/oppia/app/onboarding/OnboardingActivity.kt
index 762d7a61b06..a766a521879 100644
--- a/app/src/main/java/org/oppia/app/onboarding/OnboardingActivity.kt
+++ b/app/src/main/java/org/oppia/app/onboarding/OnboardingActivity.kt
@@ -2,7 +2,6 @@ package org.oppia.app.onboarding
 
 import android.os.Bundle
 import org.oppia.app.activity.InjectableAppCompatActivity
-import org.oppia.app.help.OnboardingActivityPresenter
 import org.oppia.app.profile.ProfileActivity
 import javax.inject.Inject
 
diff --git a/app/src/main/java/org/oppia/app/onboarding/OnboardingActivityPresenter.kt b/app/src/main/java/org/oppia/app/onboarding/OnboardingActivityPresenter.kt
index 2059d506518..7987c1bb698 100644
--- a/app/src/main/java/org/oppia/app/onboarding/OnboardingActivityPresenter.kt
+++ b/app/src/main/java/org/oppia/app/onboarding/OnboardingActivityPresenter.kt
@@ -1,4 +1,4 @@
-package org.oppia.app.help
+package org.oppia.app.onboarding
 
 import android.content.Intent
 import androidx.appcompat.app.AppCompatActivity
diff --git a/domain/src/main/java/org/oppia/domain/OnboardingFlowController.kt b/domain/src/main/java/org/oppia/domain/OnboardingFlowController.kt
index f7b80337ef5..5783f0c0441 100644
--- a/domain/src/main/java/org/oppia/domain/OnboardingFlowController.kt
+++ b/domain/src/main/java/org/oppia/domain/OnboardingFlowController.kt
@@ -9,7 +9,7 @@ import org.oppia.util.logging.Logger
 import javax.inject.Inject
 import javax.inject.Singleton
 
-/** Controller for persisting and retrieving the previous user history of using the app. */
+/** Controller for persisting and retrieving the user onboarding information of the app. */
 @Singleton
 class OnboardingFlowController @Inject constructor(
   cacheStoreFactory: PersistentCacheStore.Factory, private val dataProviders: DataProviders,
@@ -18,7 +18,7 @@ class OnboardingFlowController @Inject constructor(
   private val appHistoryStore = cacheStoreFactory.create("onboarding_flow", OnboardingFlow.getDefaultInstance())
 
   init {
-    // Prime the cache ahead of time so that any existing history is read prior to any calls to markUserOpenedApp().
+    // Prime the cache ahead of time so that any existing history is read prior to any calls to markOnboardingFlowCompleted().
     appHistoryStore.primeCacheAsync().invokeOnCompletion {
       it?.let {
         logger.e("DOMAIN", "Failed to prime cache ahead of LiveData conversion for user app open history.", it)
@@ -35,7 +35,7 @@ class OnboardingFlowController @Inject constructor(
       it.toBuilder().setAlreadyOnBoardedApp(true).build()
     }.invokeOnCompletion {
       it?.let {
-        logger.e("DOMAIN", "Failed when storing that the user already opened the app.", it)
+        logger.e("DOMAIN", "Failed when storing that the user already onboarded the app.", it)
       }
     }
   }
@@ -50,7 +50,7 @@ class OnboardingFlowController @Inject constructor(
   }
 
   /**
-   * Returns a [LiveData] result indicating whether the user has previously opened the app. This is guaranteed to
+   * Returns a [LiveData] result indicating whether the user has onboarded the app. This is guaranteed to
    * provide the state of the store upon the creation of this controller even if [markOnboardingFlowCompleted] has since been
    * called.
    */

From f238ad2d12912198a75cb1131b1b5b60416ffb56 Mon Sep 17 00:00:00 2001
From: marysoloman <nikitamarysolomanpvt@gmail.com>
Date: Thu, 2 Jan 2020 19:21:03 +0530
Subject: [PATCH 07/19] nit

---
 .../org/oppia/app/splash/SplashActivity.kt    |  1 -
 .../oppia/app/splash/SplashActivityTest.kt    | 94 +++++--------------
 2 files changed, 23 insertions(+), 72 deletions(-)

diff --git a/app/src/main/java/org/oppia/app/splash/SplashActivity.kt b/app/src/main/java/org/oppia/app/splash/SplashActivity.kt
index e62d5e46486..b558f6163aa 100644
--- a/app/src/main/java/org/oppia/app/splash/SplashActivity.kt
+++ b/app/src/main/java/org/oppia/app/splash/SplashActivity.kt
@@ -17,5 +17,4 @@ class SplashActivity : InjectableAppCompatActivity() {
     activityComponent.inject(this)
     splashActivityPresenter.handleOnCreate()
   }
-
 }
diff --git a/app/src/sharedTest/java/org/oppia/app/splash/SplashActivityTest.kt b/app/src/sharedTest/java/org/oppia/app/splash/SplashActivityTest.kt
index 2c396d29c22..49d742ce7a3 100644
--- a/app/src/sharedTest/java/org/oppia/app/splash/SplashActivityTest.kt
+++ b/app/src/sharedTest/java/org/oppia/app/splash/SplashActivityTest.kt
@@ -4,26 +4,18 @@ import android.app.Application
 import android.content.Context
 import android.os.Handler
 import android.os.Looper
-import android.view.View
 import androidx.test.core.app.ActivityScenario.launch
 import androidx.test.core.app.ApplicationProvider
 import androidx.test.espresso.Espresso.onIdle
 import androidx.test.espresso.Espresso.onView
 import androidx.test.espresso.IdlingRegistry
-import androidx.test.espresso.PerformException
-import androidx.test.espresso.UiController
-import androidx.test.espresso.ViewAction
-import androidx.test.espresso.ViewInteraction
 import androidx.test.espresso.assertion.ViewAssertions.matches
 import androidx.test.espresso.idling.CountingIdlingResource
 import androidx.test.espresso.intent.Intents
 import androidx.test.espresso.intent.Intents.intended
 import androidx.test.espresso.intent.matcher.IntentMatchers.hasComponent
-import androidx.test.espresso.matcher.ViewMatchers.isRoot
 import androidx.test.espresso.matcher.ViewMatchers.withId
 import androidx.test.espresso.matcher.ViewMatchers.withText
-import androidx.test.espresso.util.HumanReadables
-import androidx.test.espresso.util.TreeIterables
 import androidx.test.ext.junit.runners.AndroidJUnit4
 import androidx.test.rule.ActivityTestRule
 import dagger.BindsInstance
@@ -34,7 +26,6 @@ import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.asCoroutineDispatcher
 import kotlinx.coroutines.test.TestCoroutineDispatcher
-import org.hamcrest.Matcher
 import org.junit.After
 import org.junit.Before
 import org.junit.Rule
@@ -42,6 +33,7 @@ import org.junit.Test
 import org.junit.runner.RunWith
 import org.oppia.app.R
 import org.oppia.app.onboarding.OnboardingActivity
+import org.oppia.app.profile.ProfileActivity
 import org.oppia.domain.OnboardingFlowController
 import org.oppia.util.logging.EnableConsoleLog
 import org.oppia.util.logging.EnableFileLog
@@ -51,7 +43,6 @@ import org.oppia.util.threading.BackgroundDispatcher
 import org.oppia.util.threading.BlockingDispatcher
 import java.util.concurrent.AbstractExecutorService
 import java.util.concurrent.TimeUnit
-import java.util.concurrent.TimeoutException
 import javax.inject.Qualifier
 import javax.inject.Singleton
 
@@ -74,8 +65,29 @@ class SplashActivityTest {
     Intents.release()
   }
 
+  // The initialTouchMode enables the activity to be launched in touch mode. The launchActivity is
+  // disabled to launch Activity explicitly within each test case.
+  @get:Rule
+  var activityTestRule: ActivityTestRule<SplashActivity> = ActivityTestRule(
+    SplashActivity::class.java, /* initialTouchMode= */ true, /* launchActivity= */ false
+  )
+
   @Test
-  fun testSplashActivity_secondOpen_showsProfileChooserScreenAndHasSelectYourProfileString() {
+  fun testSplashActivity_initialOpen_routesToOnboardingActivity() {
+    activityTestRule.launchActivity(null)
+    intended(hasComponent(OnboardingActivity::class.java.name))
+  }
+
+  @Test
+  fun testSplashActivity_secondOpen_routesToChooseProfileActivity() {
+    simulateAppAlreadyOpened()
+    launch(SplashActivity::class.java).use {
+      intended(hasComponent(ProfileActivity::class.java.name))
+    }
+  }
+
+  @Test
+  fun testSplashActivity_secondOpen_profileChooserScreenContentVerified() {
     simulateAppAlreadyOpened()
     launch(SplashActivity::class.java).use {
       // Wait until the expected text appears on the screen, and ensure it's for the welcome text view.
@@ -102,53 +114,6 @@ class SplashActivityTest {
       .build()
   }
 
-  private fun waitForTheView(viewMatcher: Matcher<View>): ViewInteraction {
-    return onView(isRoot()).perform(waitForMatch(viewMatcher, 30000L))
-  }
-
-  // TODO(#59): Remove these waits once we can ensure that the production executors are not depended on in tests.
-  //  Sleeping is really bad practice in Espresso tests, and can lead to test flakiness. It shouldn't be necessary if we
-  //  use a test executor service with a counting idle resource, but right now Gradle mixes dependencies such that both
-  //  the test and production blocking executors are being used. The latter cannot be updated to notify Espresso of any
-  //  active coroutines, so the test attempts to assert state before it's ready. This artificial delay in the Espresso
-  //  thread helps to counter that.
-  /**
-   * Perform action of waiting for a specific matcher to finish. Adapted from:
-   * https://stackoverflow.com/a/22563297/3689782.
-   */
-  private fun waitForMatch(viewMatcher: Matcher<View>, millis: Long): ViewAction {
-    return object : ViewAction {
-      override fun getDescription(): String {
-        return "wait for a specific view with matcher <$viewMatcher> during $millis millis."
-      }
-
-      override fun getConstraints(): Matcher<View> {
-        return isRoot()
-      }
-
-      override fun perform(uiController: UiController?, view: View?) {
-        checkNotNull(uiController)
-        uiController.loopMainThreadUntilIdle()
-        val startTime = System.currentTimeMillis()
-        val endTime = startTime + millis
-
-        do {
-          if (TreeIterables.breadthFirstViewTraversal(view).any { viewMatcher.matches(it) }) {
-            return
-          }
-          uiController.loopMainThreadForAtLeast(50)
-        } while (System.currentTimeMillis() < endTime)
-
-        // Couldn't match in time.
-        throw PerformException.Builder()
-          .withActionDescription(description)
-          .withViewDescription(HumanReadables.describe(view))
-          .withCause(TimeoutException())
-          .build()
-      }
-    }
-  }
-
   @Qualifier
   annotation class TestDispatcher
 
@@ -252,17 +217,4 @@ class SplashActivityTest {
       throw UnsupportedOperationException()
     }
   }
-
-  // The initialTouchMode enables the activity to be launched in touch mode. The launchActivity is
-  // disabled to launch Activity explicitly within each test case.
-  @get:Rule
-  var activityTestRule: ActivityTestRule<SplashActivity> = ActivityTestRule(
-    SplashActivity::class.java, /* initialTouchMode= */ true, /* launchActivity= */ false
-  )
-
-  @Test
-  fun testSplashActivity_initialOpen_routesToOnboardingActivity() {
-    activityTestRule.launchActivity(null)
-    intended(hasComponent(OnboardingActivity::class.java.name))
-  }
 }

From 21d561c85f4cfae5b5281ffc39c2cbbd0ee0885b Mon Sep 17 00:00:00 2001
From: marysoloman <nikitamarysolomanpvt@gmail.com>
Date: Thu, 2 Jan 2020 19:41:39 +0530
Subject: [PATCH 08/19] nit

---
 .../src/main/java/org/oppia/domain/OnboardingFlowController.kt  | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/domain/src/main/java/org/oppia/domain/OnboardingFlowController.kt b/domain/src/main/java/org/oppia/domain/OnboardingFlowController.kt
index 5783f0c0441..477bdcc8c4e 100644
--- a/domain/src/main/java/org/oppia/domain/OnboardingFlowController.kt
+++ b/domain/src/main/java/org/oppia/domain/OnboardingFlowController.kt
@@ -57,4 +57,4 @@ class OnboardingFlowController @Inject constructor(
   fun getOnboardingFlow(): LiveData<AsyncResult<OnboardingFlow>> {
     return dataProviders.convertToLiveData(appHistoryStore)
   }
-}
\ No newline at end of file
+}

From fb6ea487d79d4e5207159b0e469a8f43b6bc30ac Mon Sep 17 00:00:00 2001
From: marysoloman <nikitamarysolomanpvt@gmail.com>
Date: Fri, 3 Jan 2020 16:13:05 +0530
Subject: [PATCH 09/19] nit

---
 app/src/main/AndroidManifest.xml              |  2 +-
 .../oppia/app/activity/ActivityComponent.kt   |  4 +-
 .../app/onBoarding/OnBoardingActivity.kt      | 20 ++++++
 .../onBoarding/OnBoardingActivityPresenter.kt | 30 +++++++++
 .../app/onboarding/OnboardingActivity.kt      | 20 ------
 .../onboarding/OnboardingActivityPresenter.kt | 30 ---------
 .../app/splash/SplashActivityPresenter.kt     | 32 +++++-----
 .../{dummy_onboard.xml => dummy_on_board.xml} |  4 +-
 .../oppia/app/splash/SplashActivityTest.kt    | 14 ++--
 .../oppia/domain/OnboardingFlowController.kt  | 32 +++++-----
 .../domain/OnboardingFlowControllerTest.kt    | 64 +++++++++----------
 model/src/main/proto/example.proto            |  2 +-
 12 files changed, 127 insertions(+), 127 deletions(-)
 create mode 100644 app/src/main/java/org/oppia/app/onBoarding/OnBoardingActivity.kt
 create mode 100644 app/src/main/java/org/oppia/app/onBoarding/OnBoardingActivityPresenter.kt
 delete mode 100644 app/src/main/java/org/oppia/app/onboarding/OnboardingActivity.kt
 delete mode 100644 app/src/main/java/org/oppia/app/onboarding/OnboardingActivityPresenter.kt
 rename app/src/main/res/layout/{dummy_onboard.xml => dummy_on_board.xml} (85%)

diff --git a/app/src/main/AndroidManifest.xml b/app/src/main/AndroidManifest.xml
index e3b524e4d72..8ef03828ce0 100644
--- a/app/src/main/AndroidManifest.xml
+++ b/app/src/main/AndroidManifest.xml
@@ -30,7 +30,7 @@
       android:screenOrientation="portrait"
       android:theme="@style/OppiaThemeWithoutActionBar" />
     <activity
-      android:name=".onboarding.OnboardingActivity"
+      android:name=".onBoarding.OnBoardingingActivity"
       android:screenOrientation="portrait"
       android:theme="@style/OppiaThemeWithoutActionBar" />
     <activity
diff --git a/app/src/main/java/org/oppia/app/activity/ActivityComponent.kt b/app/src/main/java/org/oppia/app/activity/ActivityComponent.kt
index cd07f163052..81f76c51349 100644
--- a/app/src/main/java/org/oppia/app/activity/ActivityComponent.kt
+++ b/app/src/main/java/org/oppia/app/activity/ActivityComponent.kt
@@ -8,7 +8,7 @@ import org.oppia.app.help.HelpActivity
 import org.oppia.app.home.HomeActivity
 import org.oppia.app.home.continueplaying.ContinuePlayingActivity
 import org.oppia.app.mydownloads.MyDownloadsActivity
-import org.oppia.app.onboarding.OnboardingActivity
+import org.oppia.app.onBoarding.OnBoardingingActivity
 import org.oppia.app.player.exploration.ExplorationActivity
 import org.oppia.app.profile.AddProfileActivity
 import org.oppia.app.profile.AdminAuthActivity
@@ -68,7 +68,7 @@ interface ActivityComponent {
   fun inject(htmlParserTestActivity: HtmlParserTestActivity)
   fun inject(myDownloadsActivity: MyDownloadsActivity)
   fun inject(navigationDrawerTestActivity: NavigationDrawerTestActivity)
-  fun inject(onboardingActivity: OnboardingActivity)
+  fun inject(onBoardingActivity: OnBoardingingActivity)
   fun inject(pinPasswordActivity: PinPasswordActivity)
   fun inject(profileActivity: ProfileActivity)
   fun inject(questionPlayerActivity: QuestionPlayerActivity)
diff --git a/app/src/main/java/org/oppia/app/onBoarding/OnBoardingActivity.kt b/app/src/main/java/org/oppia/app/onBoarding/OnBoardingActivity.kt
new file mode 100644
index 00000000000..bd727557068
--- /dev/null
+++ b/app/src/main/java/org/oppia/app/onBoarding/OnBoardingActivity.kt
@@ -0,0 +1,20 @@
+package org.oppia.app.onBoarding
+
+import android.os.Bundle
+import org.oppia.app.activity.InjectableAppCompatActivity
+import org.oppia.app.profile.ProfileActivity
+import javax.inject.Inject
+
+/** An activity that shows a temporary Onboardinging page until the app is onborarded then navigates to [ProfileActivity]. */
+class OnBoardingingActivity : InjectableAppCompatActivity() {
+
+  @Inject
+  lateinit var onBoardingActivityPresenter: OnBoardingingActivityPresenter
+
+  override fun onCreate(savedInstanceState: Bundle?) {
+    super.onCreate(savedInstanceState)
+    activityComponent.inject(this)
+    onBoardingActivityPresenter.handleOnCreate()
+  }
+}
+
diff --git a/app/src/main/java/org/oppia/app/onBoarding/OnBoardingActivityPresenter.kt b/app/src/main/java/org/oppia/app/onBoarding/OnBoardingActivityPresenter.kt
new file mode 100644
index 00000000000..e0bb4905bb5
--- /dev/null
+++ b/app/src/main/java/org/oppia/app/onBoarding/OnBoardingActivityPresenter.kt
@@ -0,0 +1,30 @@
+package org.oppia.app.onBoarding
+
+import android.content.Intent
+import androidx.appcompat.app.AppCompatActivity
+import kotlinx.android.synthetic.main.dummy_on_board.*
+import org.oppia.app.R
+import org.oppia.app.activity.ActivityScope
+import org.oppia.app.profile.ProfileActivity
+import org.oppia.domain.OnboardingingFlowController
+import javax.inject.Inject
+
+/** The presenter for [OnBoardingingActivity]. */
+@ActivityScope
+class OnBoardingingActivityPresenter @Inject constructor(
+  private val activity: AppCompatActivity,
+  private val onBoardingFlowController: OnboardingingFlowController
+) {
+
+  fun handleOnCreate() {
+    activity.setContentView(R.layout.dummy_on_board)
+    activity.onBoard.setOnClickListener({ subscribeToUserAppHistory() })
+  }
+
+  private fun subscribeToUserAppHistory() {
+    onBoardingFlowController.markOnboardingingFlowCompleted()
+    val intent = Intent(activity, ProfileActivity::class.java)
+    activity.startActivity(intent)
+    activity.finish()
+  }
+}
diff --git a/app/src/main/java/org/oppia/app/onboarding/OnboardingActivity.kt b/app/src/main/java/org/oppia/app/onboarding/OnboardingActivity.kt
deleted file mode 100644
index a766a521879..00000000000
--- a/app/src/main/java/org/oppia/app/onboarding/OnboardingActivity.kt
+++ /dev/null
@@ -1,20 +0,0 @@
-package org.oppia.app.onboarding
-
-import android.os.Bundle
-import org.oppia.app.activity.InjectableAppCompatActivity
-import org.oppia.app.profile.ProfileActivity
-import javax.inject.Inject
-
-/** An activity that shows a temporary Onboarding page until the app is onborarded then navigates to [ProfileActivity]. */
-class OnboardingActivity : InjectableAppCompatActivity() {
-
-  @Inject
-  lateinit var onboardingActivityPresenter: OnboardingActivityPresenter
-
-  override fun onCreate(savedInstanceState: Bundle?) {
-    super.onCreate(savedInstanceState)
-    activityComponent.inject(this)
-    onboardingActivityPresenter.handleOnCreate()
-  }
-}
-
diff --git a/app/src/main/java/org/oppia/app/onboarding/OnboardingActivityPresenter.kt b/app/src/main/java/org/oppia/app/onboarding/OnboardingActivityPresenter.kt
deleted file mode 100644
index 7987c1bb698..00000000000
--- a/app/src/main/java/org/oppia/app/onboarding/OnboardingActivityPresenter.kt
+++ /dev/null
@@ -1,30 +0,0 @@
-package org.oppia.app.onboarding
-
-import android.content.Intent
-import androidx.appcompat.app.AppCompatActivity
-import kotlinx.android.synthetic.main.dummy_onboard.*
-import org.oppia.app.R
-import org.oppia.app.activity.ActivityScope
-import org.oppia.app.profile.ProfileActivity
-import org.oppia.domain.OnboardingFlowController
-import javax.inject.Inject
-
-/** The presenter for [OnboardingActivity]. */
-@ActivityScope
-class OnboardingActivityPresenter @Inject constructor(
-  private val activity: AppCompatActivity,
-  private val onboardingFlowController: OnboardingFlowController
-) {
-
-  fun handleOnCreate() {
-    activity.setContentView(R.layout.dummy_onboard)
-    activity.onboard.setOnClickListener({ subscribeToUserAppHistory() })
-  }
-
-  private fun subscribeToUserAppHistory() {
-    onboardingFlowController.markOnboardingFlowCompleted()
-    val intent = Intent(activity, ProfileActivity::class.java)
-    activity.startActivity(intent)
-    activity.finish()
-  }
-}
diff --git a/app/src/main/java/org/oppia/app/splash/SplashActivityPresenter.kt b/app/src/main/java/org/oppia/app/splash/SplashActivityPresenter.kt
index 15dc8d42e0f..921cbf80922 100644
--- a/app/src/main/java/org/oppia/app/splash/SplashActivityPresenter.kt
+++ b/app/src/main/java/org/oppia/app/splash/SplashActivityPresenter.kt
@@ -8,54 +8,54 @@ import androidx.lifecycle.Observer
 import androidx.lifecycle.Transformations
 import org.oppia.app.R
 import org.oppia.app.activity.ActivityScope
-import org.oppia.app.model.OnboardingFlow
-import org.oppia.app.onboarding.OnboardingActivity
+import org.oppia.app.model.OnboardingingFlow
+import org.oppia.app.onBoarding.OnBoardingingActivity
 import org.oppia.app.profile.ProfileActivity
-import org.oppia.domain.OnboardingFlowController
+import org.oppia.domain.OnboardingingFlowController
 import org.oppia.util.data.AsyncResult
 import javax.inject.Inject
 
-/** The presenter for [OnboardingActivity]. */
+/** The presenter for [OnBoardingingActivity]. */
 @ActivityScope
 class SplashActivityPresenter @Inject constructor(
   private val activity: AppCompatActivity,
-  onboardingFlowController: OnboardingFlowController
+  onBoardingFlowController: OnboardingingFlowController
 ) {
 
-  val sample = onboardingFlowController.getOnboardingFlow()
+  val sample = onBoardingFlowController.getOnboardingingFlow()
 
   fun handleOnCreate() {
     activity.setContentView(R.layout.splash_activity)
     activity.window.setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN);
-    subscribeToOnboardingFlow()
+    subscribeToOnboardingingFlow()
   }
 
-  private fun showOnboardingActivity() {
-    val intent = Intent(activity, OnboardingActivity::class.java)
+  private fun showOnboardingingActivity() {
+    val intent = Intent(activity, OnBoardingingActivity::class.java)
     activity.startActivity(intent)
     activity.finish()
   }
 
-  private fun subscribeToOnboardingFlow() {
-    getOnboardingFlow().observe(activity, Observer<OnboardingFlow> { result ->
+  private fun subscribeToOnboardingingFlow() {
+    getOnboardingingFlow().observe(activity, Observer<OnboardingingFlow> { result ->
       if (result.alreadyOnBoardedApp) {
         val intent = Intent(activity, ProfileActivity::class.java)
         activity.startActivity(intent)
         activity.finish()
       } else {
-        showOnboardingActivity()
+        showOnboardingingActivity()
       }
     })
   }
 
-  private fun getOnboardingFlow(): LiveData<OnboardingFlow> {
+  private fun getOnboardingingFlow(): LiveData<OnboardingingFlow> {
     // If there's an error loading the data, assume the default.
-    return Transformations.map(sample, ::processOnboardingFlowResult)
+    return Transformations.map(sample, ::processOnboardingingFlowResult)
   }
 
-  private fun processOnboardingFlowResult(appHistoryResult: AsyncResult<OnboardingFlow>): OnboardingFlow {
+  private fun processOnboardingingFlowResult(appHistoryResult: AsyncResult<OnboardingingFlow>): OnboardingingFlow {
     if (appHistoryResult.isFailure()) {
     }
-    return appHistoryResult.getOrDefault(OnboardingFlow.getDefaultInstance())
+    return appHistoryResult.getOrDefault(OnboardingingFlow.getDefaultInstance())
   }
 }
diff --git a/app/src/main/res/layout/dummy_onboard.xml b/app/src/main/res/layout/dummy_on_board.xml
similarity index 85%
rename from app/src/main/res/layout/dummy_onboard.xml
rename to app/src/main/res/layout/dummy_on_board.xml
index 93a72ff47e4..2871441b705 100644
--- a/app/src/main/res/layout/dummy_onboard.xml
+++ b/app/src/main/res/layout/dummy_on_board.xml
@@ -6,9 +6,9 @@
   android:orientation="vertical">
 
   <Button
-    android:id="@+id/onboard"
+    android:id="@+id/onBoard"
     android:layout_width="wrap_content"
     android:layout_height="wrap_content"
-    android:text="onboard" />
+    android:text="on-board" />
 </LinearLayout>
 
diff --git a/app/src/sharedTest/java/org/oppia/app/splash/SplashActivityTest.kt b/app/src/sharedTest/java/org/oppia/app/splash/SplashActivityTest.kt
index 49d742ce7a3..0123bd998a4 100644
--- a/app/src/sharedTest/java/org/oppia/app/splash/SplashActivityTest.kt
+++ b/app/src/sharedTest/java/org/oppia/app/splash/SplashActivityTest.kt
@@ -32,9 +32,9 @@ import org.junit.Rule
 import org.junit.Test
 import org.junit.runner.RunWith
 import org.oppia.app.R
-import org.oppia.app.onboarding.OnboardingActivity
+import org.oppia.app.onBoarding.OnBoardingingActivity
 import org.oppia.app.profile.ProfileActivity
-import org.oppia.domain.OnboardingFlowController
+import org.oppia.domain.OnboardingingFlowController
 import org.oppia.util.logging.EnableConsoleLog
 import org.oppia.util.logging.EnableFileLog
 import org.oppia.util.logging.GlobalLogLevel
@@ -73,9 +73,9 @@ class SplashActivityTest {
   )
 
   @Test
-  fun testSplashActivity_initialOpen_routesToOnboardingActivity() {
+  fun testSplashActivity_initialOpen_routesToOnboardingingActivity() {
     activityTestRule.launchActivity(null)
-    intended(hasComponent(OnboardingActivity::class.java.name))
+    intended(hasComponent(OnBoardingingActivity::class.java.name))
   }
 
   @Test
@@ -97,14 +97,14 @@ class SplashActivityTest {
 
   private fun simulateNewAppInstance() {
     // Simulate a fresh app install by clearing any potential on-disk caches using an isolated app history controller.
-    createTestRootComponent().getOnboardingFlowController().clearOnboardingFlow()
+    createTestRootComponent().getOnboardingingFlowController().clearOnboardingingFlow()
     onIdle()
   }
 
   private fun simulateAppAlreadyOpened() {
     // Simulate the app was already opened by creating an isolated app history controller and saving the opened status
     // on the system before the activity is opened.
-    createTestRootComponent().getOnboardingFlowController().markOnboardingFlowCompleted()
+    createTestRootComponent().getOnboardingingFlowController().markOnboardingingFlowCompleted()
     onIdle()
   }
 
@@ -173,7 +173,7 @@ class SplashActivityTest {
       fun build(): TestApplicationComponent
     }
 
-    fun getOnboardingFlowController(): OnboardingFlowController
+    fun getOnboardingingFlowController(): OnboardingingFlowController
     fun inject(splashActivityTest: SplashActivityTest)
   }
 
diff --git a/domain/src/main/java/org/oppia/domain/OnboardingFlowController.kt b/domain/src/main/java/org/oppia/domain/OnboardingFlowController.kt
index 477bdcc8c4e..285067b6454 100644
--- a/domain/src/main/java/org/oppia/domain/OnboardingFlowController.kt
+++ b/domain/src/main/java/org/oppia/domain/OnboardingFlowController.kt
@@ -1,7 +1,7 @@
 package org.oppia.domain
 
 import androidx.lifecycle.LiveData
-import org.oppia.app.model.OnboardingFlow
+import org.oppia.app.model.OnboardingingFlow
 import org.oppia.data.persistence.PersistentCacheStore
 import org.oppia.util.data.AsyncResult
 import org.oppia.util.data.DataProviders
@@ -9,17 +9,17 @@ import org.oppia.util.logging.Logger
 import javax.inject.Inject
 import javax.inject.Singleton
 
-/** Controller for persisting and retrieving the user onboarding information of the app. */
+/** Controller for persisting and retrieving the user onBoarding information of the app. */
 @Singleton
-class OnboardingFlowController @Inject constructor(
+class OnboardingingFlowController @Inject constructor(
   cacheStoreFactory: PersistentCacheStore.Factory, private val dataProviders: DataProviders,
   private val logger: Logger
 ) {
-  private val appHistoryStore = cacheStoreFactory.create("onboarding_flow", OnboardingFlow.getDefaultInstance())
+  private val onBoardingStore = cacheStoreFactory.create("onBoarding_flow", OnboardingingFlow.getDefaultInstance())
 
   init {
-    // Prime the cache ahead of time so that any existing history is read prior to any calls to markOnboardingFlowCompleted().
-    appHistoryStore.primeCacheAsync().invokeOnCompletion {
+    // Prime the cache ahead of time so that any existing history is read prior to any calls to markOnboardingingFlowCompleted().
+    onBoardingStore.primeCacheAsync().invokeOnCompletion {
       it?.let {
         logger.e("DOMAIN", "Failed to prime cache ahead of LiveData conversion for user app open history.", it)
       }
@@ -30,31 +30,31 @@ class OnboardingFlowController @Inject constructor(
    * Saves that the user has completed on-boarding the app. Note that this does not notify existing subscribers of the changed state,
    * nor can future subscribers observe this state until app restart.
    */
-  fun markOnboardingFlowCompleted() {
-    appHistoryStore.storeDataAsync(updateInMemoryCache = false) {
+  fun markOnboardingingFlowCompleted() {
+    onBoardingStore.storeDataAsync(updateInMemoryCache = false) {
       it.toBuilder().setAlreadyOnBoardedApp(true).build()
     }.invokeOnCompletion {
       it?.let {
-        logger.e("DOMAIN", "Failed when storing that the user already onboarded the app.", it)
+        logger.e("DOMAIN", "Failed when storing that the user already onBoarded the app.", it)
       }
     }
   }
 
   /** Clears any indication that the user has previously completed on-boarding the application. */
-  fun clearOnboardingFlow() {
-    appHistoryStore.clearCacheAsync().invokeOnCompletion {
+  fun clearOnboardingingFlow() {
+    onBoardingStore.clearCacheAsync().invokeOnCompletion {
       it?.let {
-        logger.e("DOMAIN", "Failed to clear onboarding flow.", it)
+        logger.e("DOMAIN", "Failed to clear onBoarding flow.", it)
       }
     }
   }
 
   /**
-   * Returns a [LiveData] result indicating whether the user has onboarded the app. This is guaranteed to
-   * provide the state of the store upon the creation of this controller even if [markOnboardingFlowCompleted] has since been
+   * Returns a [LiveData] result indicating whether the user has onBoarded the app. This is guaranteed to
+   * provide the state of the store upon the creation of this controller even if [markOnboardingingFlowCompleted] has since been
    * called.
    */
-  fun getOnboardingFlow(): LiveData<AsyncResult<OnboardingFlow>> {
-    return dataProviders.convertToLiveData(appHistoryStore)
+  fun getOnboardingingFlow(): LiveData<AsyncResult<OnboardingingFlow>> {
+    return dataProviders.convertToLiveData(onBoardingStore)
   }
 }
diff --git a/domain/src/test/java/org/oppia/domain/OnboardingFlowControllerTest.kt b/domain/src/test/java/org/oppia/domain/OnboardingFlowControllerTest.kt
index 2273f25ecbf..2450c65a4ba 100644
--- a/domain/src/test/java/org/oppia/domain/OnboardingFlowControllerTest.kt
+++ b/domain/src/test/java/org/oppia/domain/OnboardingFlowControllerTest.kt
@@ -32,7 +32,7 @@ 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.OnboardingFlow
+import org.oppia.app.model.OnboardingingFlow
 import org.oppia.util.data.AsyncResult
 import org.oppia.util.logging.EnableConsoleLog
 import org.oppia.util.logging.EnableFileLog
@@ -46,10 +46,10 @@ import javax.inject.Qualifier
 import javax.inject.Singleton
 import kotlin.coroutines.EmptyCoroutineContext
 
-/** Tests for [OnboardingFlowController]. */
+/** Tests for [OnboardingingFlowController]. */
 @RunWith(AndroidJUnit4::class)
 @Config(manifest = Config.NONE)
-class OnboardingFlowControllerTest {
+class OnboardingingFlowControllerTest {
   @Rule
   @JvmField
   val mockitoRule: MockitoRule = MockitoJUnit.rule()
@@ -59,7 +59,7 @@ class OnboardingFlowControllerTest {
   val executorRule = InstantTaskExecutorRule()
 
   @Inject
-  lateinit var onboardingFlowController: OnboardingFlowController
+  lateinit var onBoardingFlowController: OnboardingingFlowController
 
   @Inject
   @field:TestDispatcher
@@ -70,10 +70,10 @@ class OnboardingFlowControllerTest {
   }
 
   @Mock
-  lateinit var mockAppHistoryObserver: Observer<AsyncResult<OnboardingFlow>>
+  lateinit var mockOnboardingingObserver: Observer<AsyncResult<OnboardingingFlow>>
 
   @Captor
-  lateinit var appHistoryResultCaptor: ArgumentCaptor<AsyncResult<OnboardingFlow>>
+  lateinit var onBoardingResultCaptor: ArgumentCaptor<AsyncResult<OnboardingingFlow>>
 
   // https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-test/
   @ObsoleteCoroutinesApi
@@ -96,7 +96,7 @@ class OnboardingFlowControllerTest {
   }
 
   private fun setUpTestApplicationComponent() {
-    DaggerOnboardingFlowControllerTest_TestApplicationComponent.builder()
+    DaggerOnboardingingFlowControllerTest_TestApplicationComponent.builder()
       .setApplication(ApplicationProvider.getApplicationContext())
       .build()
       .inject(this)
@@ -105,67 +105,67 @@ class OnboardingFlowControllerTest {
   @Test
   @ExperimentalCoroutinesApi
   fun testController_providesInitialLiveData_thatIndicatesUserHasNotOpenedTheApp() = runBlockingTest(coroutineContext) {
-    val appHistory = onboardingFlowController.getOnboardingFlow()
+    val onBoarding = onBoardingFlowController.getOnboardingingFlow()
     advanceUntilIdle()
-    appHistory.observeForever(mockAppHistoryObserver)
+    onBoarding.observeForever(mockOnboardingingObserver)
 
-    verify(mockAppHistoryObserver, atLeastOnce()).onChanged(appHistoryResultCaptor.capture())
-    assertThat(appHistoryResultCaptor.value.isSuccess()).isTrue()
-    assertThat(appHistoryResultCaptor.value.getOrThrow().alreadyOnBoardedApp).isFalse()
+    verify(mockOnboardingingObserver, atLeastOnce()).onChanged(onBoardingResultCaptor.capture())
+    assertThat(onBoardingResultCaptor.value.isSuccess()).isTrue()
+    assertThat(onBoardingResultCaptor.value.getOrThrow().alreadyOnBoardedApp).isFalse()
   }
 
   @Test
   @ExperimentalCoroutinesApi
   fun testControllerObserver_observedAfterSettingAppOpened_providesLiveData_userDidNotOpenApp() =
     runBlockingTest(coroutineContext) {
-      val appHistory = onboardingFlowController.getOnboardingFlow()
+      val onBoarding = onBoardingFlowController.getOnboardingingFlow()
 
-      appHistory.observeForever(mockAppHistoryObserver)
-      onboardingFlowController.markOnboardingFlowCompleted()
+      onBoarding.observeForever(mockOnboardingingObserver)
+      onBoardingFlowController.markOnboardingingFlowCompleted()
       advanceUntilIdle()
 
       // The result should not indicate that the user opened the app because markUserOpenedApp does not notify observers
       // of the change.
-      verify(mockAppHistoryObserver, atLeastOnce()).onChanged(appHistoryResultCaptor.capture())
-      assertThat(appHistoryResultCaptor.value.isSuccess()).isTrue()
-      assertThat(appHistoryResultCaptor.value.getOrThrow().alreadyOnBoardedApp).isFalse()
+      verify(mockOnboardingingObserver, atLeastOnce()).onChanged(onBoardingResultCaptor.capture())
+      assertThat(onBoardingResultCaptor.value.isSuccess()).isTrue()
+      assertThat(onBoardingResultCaptor.value.getOrThrow().alreadyOnBoardedApp).isFalse()
     }
 
   @Test
   @ExperimentalCoroutinesApi
   fun testController_settingAppOpened_observedNewController_userOpenedApp() = runBlockingTest(coroutineContext) {
-    onboardingFlowController.markOnboardingFlowCompleted()
+    onBoardingFlowController.markOnboardingingFlowCompleted()
     advanceUntilIdle()
 
     // Create the controller by creating another singleton graph and injecting it (simulating the app being recreated).
     setUpTestApplicationComponent()
-    val appHistory = onboardingFlowController.getOnboardingFlow()
-    appHistory.observeForever(mockAppHistoryObserver)
+    val onBoarding = onBoardingFlowController.getOnboardingingFlow()
+    onBoarding.observeForever(mockOnboardingingObserver)
     advanceUntilIdle()
 
     // The app should be considered open since a new LiveData instance was observed after marking the app as opened.
-    verify(mockAppHistoryObserver, atLeastOnce()).onChanged(appHistoryResultCaptor.capture())
-    assertThat(appHistoryResultCaptor.value.isSuccess()).isTrue()
-    assertThat(appHistoryResultCaptor.value.getOrThrow().alreadyOnBoardedApp).isTrue()
+    verify(mockOnboardingingObserver, atLeastOnce()).onChanged(onBoardingResultCaptor.capture())
+    assertThat(onBoardingResultCaptor.value.isSuccess()).isTrue()
+    assertThat(onBoardingResultCaptor.value.getOrThrow().alreadyOnBoardedApp).isTrue()
   }
 
   @Test
   @ExperimentalCoroutinesApi
   fun testController_openedApp_cleared_observeNewController_userDidNotOpenApp() = runBlockingTest(coroutineContext) {
-    onboardingFlowController.markOnboardingFlowCompleted()
+    onBoardingFlowController.markOnboardingingFlowCompleted()
     advanceUntilIdle()
 
     // Clear, then recreate another controller.
-    onboardingFlowController.clearOnboardingFlow()
+    onBoardingFlowController.clearOnboardingingFlow()
     setUpTestApplicationComponent()
-    val appHistory = onboardingFlowController.getOnboardingFlow()
-    appHistory.observeForever(mockAppHistoryObserver)
+    val onBoarding = onBoardingFlowController.getOnboardingingFlow()
+    onBoarding.observeForever(mockOnboardingingObserver)
     advanceUntilIdle()
 
     // The app should be considered not yet opened since the previous history was cleared.
-    verify(mockAppHistoryObserver, atLeastOnce()).onChanged(appHistoryResultCaptor.capture())
-    assertThat(appHistoryResultCaptor.value.isSuccess()).isTrue()
-    assertThat(appHistoryResultCaptor.value.getOrThrow().alreadyOnBoardedApp).isFalse()
+    verify(mockOnboardingingObserver, atLeastOnce()).onChanged(onBoardingResultCaptor.capture())
+    assertThat(onBoardingResultCaptor.value.isSuccess()).isTrue()
+    assertThat(onBoardingResultCaptor.value.getOrThrow().alreadyOnBoardedApp).isFalse()
   }
 
   @Qualifier
@@ -229,6 +229,6 @@ class OnboardingFlowControllerTest {
       fun build(): TestApplicationComponent
     }
 
-    fun inject(onboardingFlowControllerTest: OnboardingFlowControllerTest)
+    fun inject(onBoardingFlowControllerTest: OnboardingingFlowControllerTest)
   }
 }
diff --git a/model/src/main/proto/example.proto b/model/src/main/proto/example.proto
index 44e038a6651..60e8f3ba319 100644
--- a/model/src/main/proto/example.proto
+++ b/model/src/main/proto/example.proto
@@ -9,7 +9,7 @@ message UserAppHistory {
   bool already_opened_app = 1;
 }
 
-message OnboardingFlow {
+message OnboardingingFlow {
   bool already_on_boarded_app = 1;
 }
 

From 7333c3e4da4a89ac0e9b1fdd3c90abb6acee1b5b Mon Sep 17 00:00:00 2001
From: marysoloman <nikitamarysolomanpvt@gmail.com>
Date: Fri, 3 Jan 2020 16:55:08 +0530
Subject: [PATCH 10/19] nit

---
 .../onBoarding/OnBoardingActivityPresenter.kt |  4 +-
 .../app/splash/SplashActivityPresenter.kt     |  6 +--
 .../domain/UserAppHistoryControllerTest.kt    | 38 +++++++++----------
 3 files changed, 23 insertions(+), 25 deletions(-)

diff --git a/app/src/main/java/org/oppia/app/onBoarding/OnBoardingActivityPresenter.kt b/app/src/main/java/org/oppia/app/onBoarding/OnBoardingActivityPresenter.kt
index e0bb4905bb5..ec47aef75f1 100644
--- a/app/src/main/java/org/oppia/app/onBoarding/OnBoardingActivityPresenter.kt
+++ b/app/src/main/java/org/oppia/app/onBoarding/OnBoardingActivityPresenter.kt
@@ -18,10 +18,10 @@ class OnBoardingingActivityPresenter @Inject constructor(
 
   fun handleOnCreate() {
     activity.setContentView(R.layout.dummy_on_board)
-    activity.onBoard.setOnClickListener({ subscribeToUserAppHistory() })
+    activity.onBoard.setOnClickListener({ subscribeOnBoarding() })
   }
 
-  private fun subscribeToUserAppHistory() {
+  private fun subscribeOnBoarding() {
     onBoardingFlowController.markOnboardingingFlowCompleted()
     val intent = Intent(activity, ProfileActivity::class.java)
     activity.startActivity(intent)
diff --git a/app/src/main/java/org/oppia/app/splash/SplashActivityPresenter.kt b/app/src/main/java/org/oppia/app/splash/SplashActivityPresenter.kt
index 921cbf80922..98595ac2c09 100644
--- a/app/src/main/java/org/oppia/app/splash/SplashActivityPresenter.kt
+++ b/app/src/main/java/org/oppia/app/splash/SplashActivityPresenter.kt
@@ -53,9 +53,9 @@ class SplashActivityPresenter @Inject constructor(
     return Transformations.map(sample, ::processOnboardingingFlowResult)
   }
 
-  private fun processOnboardingingFlowResult(appHistoryResult: AsyncResult<OnboardingingFlow>): OnboardingingFlow {
-    if (appHistoryResult.isFailure()) {
+  private fun processOnboardingingFlowResult(onboardingResult: AsyncResult<OnboardingingFlow>): OnboardingingFlow {
+    if (onboardingResult.isFailure()) {
     }
-    return appHistoryResult.getOrDefault(OnboardingingFlow.getDefaultInstance())
+    return onboardingResult.getOrDefault(OnboardingingFlow.getDefaultInstance())
   }
 }
diff --git a/domain/src/test/java/org/oppia/domain/UserAppHistoryControllerTest.kt b/domain/src/test/java/org/oppia/domain/UserAppHistoryControllerTest.kt
index 1e6a1d53141..f73881afbe2 100644
--- a/domain/src/test/java/org/oppia/domain/UserAppHistoryControllerTest.kt
+++ b/domain/src/test/java/org/oppia/domain/UserAppHistoryControllerTest.kt
@@ -58,8 +58,7 @@ class UserAppHistoryControllerTest {
   @JvmField
   val executorRule = InstantTaskExecutorRule()
 
-  @Inject
-  lateinit var userAppHistoryController: UserAppHistoryController
+  @Inject lateinit var userAppHistoryController: UserAppHistoryController
 
   @Inject
   @field:TestDispatcher
@@ -116,24 +115,25 @@ class UserAppHistoryControllerTest {
 
   @Test
   @ExperimentalCoroutinesApi
-  fun testControllerObserver_observedAfterSettingAppOpened_providesLiveData_userDidNotOpenApp() =
-    runBlockingTest(coroutineContext) {
-      val appHistory = userAppHistoryController.getUserAppHistory()
-
-      appHistory.observeForever(mockAppHistoryObserver)
-      userAppHistoryController.markUserOpenedApp()
-      advanceUntilIdle()
-
-      // The result should not indicate that the user opened the app because markUserOpenedApp does not notify observers
-      // of the change.
-      verify(mockAppHistoryObserver, atLeastOnce()).onChanged(appHistoryResultCaptor.capture())
-      assertThat(appHistoryResultCaptor.value.isSuccess()).isTrue()
-      assertThat(appHistoryResultCaptor.value.getOrThrow().alreadyOpenedApp).isFalse()
-    }
+  fun testControllerObserver_observedAfterSettingAppOpened_providesLiveData_userDidNotOpenApp()
+      = runBlockingTest(coroutineContext) {
+    val appHistory = userAppHistoryController.getUserAppHistory()
+
+    appHistory.observeForever(mockAppHistoryObserver)
+    userAppHistoryController.markUserOpenedApp()
+    advanceUntilIdle()
+
+    // The result should not indicate that the user opened the app because markUserOpenedApp does not notify observers
+    // of the change.
+    verify(mockAppHistoryObserver, atLeastOnce()).onChanged(appHistoryResultCaptor.capture())
+    assertThat(appHistoryResultCaptor.value.isSuccess()).isTrue()
+    assertThat(appHistoryResultCaptor.value.getOrThrow().alreadyOpenedApp).isFalse()
+  }
 
   @Test
   @ExperimentalCoroutinesApi
-  fun testController_settingAppOpened_observedNewController_userOpenedApp() = runBlockingTest(coroutineContext) {
+  fun testController_settingAppOpened_observedNewController_userOpenedApp()
+      = runBlockingTest(coroutineContext) {
     userAppHistoryController.markUserOpenedApp()
     advanceUntilIdle()
 
@@ -168,8 +168,7 @@ class UserAppHistoryControllerTest {
     assertThat(appHistoryResultCaptor.value.getOrThrow().alreadyOpenedApp).isFalse()
   }
 
-  @Qualifier
-  annotation class TestDispatcher
+  @Qualifier annotation class TestDispatcher
 
   // TODO(#89): Move this to a common test application component.
   @Module
@@ -225,7 +224,6 @@ class UserAppHistoryControllerTest {
     interface Builder {
       @BindsInstance
       fun setApplication(application: Application): Builder
-
       fun build(): TestApplicationComponent
     }
 

From b3e091cb23f8163017f92ef186047b2293298a79 Mon Sep 17 00:00:00 2001
From: marysoloman <nikitamarysolomanpvt@gmail.com>
Date: Fri, 3 Jan 2020 17:10:29 +0530
Subject: [PATCH 11/19] nit

---
 .../org/oppia/app/splash/SplashActivityTest.kt     |  4 ++--
 .../org/oppia/domain/OnboardingFlowController.kt   |  2 +-
 .../oppia/domain/OnboardingFlowControllerTest.kt   | 14 +++++++-------
 3 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/app/src/sharedTest/java/org/oppia/app/splash/SplashActivityTest.kt b/app/src/sharedTest/java/org/oppia/app/splash/SplashActivityTest.kt
index 0123bd998a4..057910fcbe0 100644
--- a/app/src/sharedTest/java/org/oppia/app/splash/SplashActivityTest.kt
+++ b/app/src/sharedTest/java/org/oppia/app/splash/SplashActivityTest.kt
@@ -96,13 +96,13 @@ class SplashActivityTest {
   }
 
   private fun simulateNewAppInstance() {
-    // Simulate a fresh app install by clearing any potential on-disk caches using an isolated app history controller.
+    // Simulate a fresh app install by clearing any potential on-disk caches using an isolated on-boarding flow controller.
     createTestRootComponent().getOnboardingingFlowController().clearOnboardingingFlow()
     onIdle()
   }
 
   private fun simulateAppAlreadyOpened() {
-    // Simulate the app was already opened by creating an isolated app history controller and saving the opened status
+    // Simulate the app was already onboarded by creating an isolated on-boarding flow controller and saving the onboarding status
     // on the system before the activity is opened.
     createTestRootComponent().getOnboardingingFlowController().markOnboardingingFlowCompleted()
     onIdle()
diff --git a/domain/src/main/java/org/oppia/domain/OnboardingFlowController.kt b/domain/src/main/java/org/oppia/domain/OnboardingFlowController.kt
index 285067b6454..b98c2220cfb 100644
--- a/domain/src/main/java/org/oppia/domain/OnboardingFlowController.kt
+++ b/domain/src/main/java/org/oppia/domain/OnboardingFlowController.kt
@@ -21,7 +21,7 @@ class OnboardingingFlowController @Inject constructor(
     // Prime the cache ahead of time so that any existing history is read prior to any calls to markOnboardingingFlowCompleted().
     onBoardingStore.primeCacheAsync().invokeOnCompletion {
       it?.let {
-        logger.e("DOMAIN", "Failed to prime cache ahead of LiveData conversion for user app open history.", it)
+        logger.e("DOMAIN", "Failed to prime cache ahead of LiveData conversion for user on-boarding data.", it)
       }
     }
   }
diff --git a/domain/src/test/java/org/oppia/domain/OnboardingFlowControllerTest.kt b/domain/src/test/java/org/oppia/domain/OnboardingFlowControllerTest.kt
index 2450c65a4ba..b5c446548ee 100644
--- a/domain/src/test/java/org/oppia/domain/OnboardingFlowControllerTest.kt
+++ b/domain/src/test/java/org/oppia/domain/OnboardingFlowControllerTest.kt
@@ -104,7 +104,7 @@ class OnboardingingFlowControllerTest {
 
   @Test
   @ExperimentalCoroutinesApi
-  fun testController_providesInitialLiveData_thatIndicatesUserHasNotOpenedTheApp() = runBlockingTest(coroutineContext) {
+  fun testController_providesInitialLiveData_thatIndicatesUserHasNotOnBoardedTheApp() = runBlockingTest(coroutineContext) {
     val onBoarding = onBoardingFlowController.getOnboardingingFlow()
     advanceUntilIdle()
     onBoarding.observeForever(mockOnboardingingObserver)
@@ -116,7 +116,7 @@ class OnboardingingFlowControllerTest {
 
   @Test
   @ExperimentalCoroutinesApi
-  fun testControllerObserver_observedAfterSettingAppOpened_providesLiveData_userDidNotOpenApp() =
+  fun testControllerObserver_observedAfterSettingAppOnBoarded_providesLiveData_userDidNotOpenApp() =
     runBlockingTest(coroutineContext) {
       val onBoarding = onBoardingFlowController.getOnboardingingFlow()
 
@@ -124,7 +124,7 @@ class OnboardingingFlowControllerTest {
       onBoardingFlowController.markOnboardingingFlowCompleted()
       advanceUntilIdle()
 
-      // The result should not indicate that the user opened the app because markUserOpenedApp does not notify observers
+      // The result should not indicate that the user onBoarded the app because markUserOnBoardedApp does not notify observers
       // of the change.
       verify(mockOnboardingingObserver, atLeastOnce()).onChanged(onBoardingResultCaptor.capture())
       assertThat(onBoardingResultCaptor.value.isSuccess()).isTrue()
@@ -133,7 +133,7 @@ class OnboardingingFlowControllerTest {
 
   @Test
   @ExperimentalCoroutinesApi
-  fun testController_settingAppOpened_observedNewController_userOpenedApp() = runBlockingTest(coroutineContext) {
+  fun testController_settingAppOnBoarded_observedNewController_userOnBoardedApp() = runBlockingTest(coroutineContext) {
     onBoardingFlowController.markOnboardingingFlowCompleted()
     advanceUntilIdle()
 
@@ -143,7 +143,7 @@ class OnboardingingFlowControllerTest {
     onBoarding.observeForever(mockOnboardingingObserver)
     advanceUntilIdle()
 
-    // The app should be considered open since a new LiveData instance was observed after marking the app as opened.
+    // The app should be considered open since a new LiveData instance was observed after marking the app as onBoarded.
     verify(mockOnboardingingObserver, atLeastOnce()).onChanged(onBoardingResultCaptor.capture())
     assertThat(onBoardingResultCaptor.value.isSuccess()).isTrue()
     assertThat(onBoardingResultCaptor.value.getOrThrow().alreadyOnBoardedApp).isTrue()
@@ -151,7 +151,7 @@ class OnboardingingFlowControllerTest {
 
   @Test
   @ExperimentalCoroutinesApi
-  fun testController_openedApp_cleared_observeNewController_userDidNotOpenApp() = runBlockingTest(coroutineContext) {
+  fun testController_onBoardedApp_cleared_observeNewController_userDidNotOpenApp() = runBlockingTest(coroutineContext) {
     onBoardingFlowController.markOnboardingingFlowCompleted()
     advanceUntilIdle()
 
@@ -162,7 +162,7 @@ class OnboardingingFlowControllerTest {
     onBoarding.observeForever(mockOnboardingingObserver)
     advanceUntilIdle()
 
-    // The app should be considered not yet opened since the previous history was cleared.
+    // The app should be considered not yet onBoarded since the previous history was cleared.
     verify(mockOnboardingingObserver, atLeastOnce()).onChanged(onBoardingResultCaptor.capture())
     assertThat(onBoardingResultCaptor.value.isSuccess()).isTrue()
     assertThat(onBoardingResultCaptor.value.getOrThrow().alreadyOnBoardedApp).isFalse()

From 39a0acf4830f15f4a284fc77f0ce9b393fb4c18e Mon Sep 17 00:00:00 2001
From: marysoloman <nikitamarysolomanpvt@gmail.com>
Date: Fri, 3 Jan 2020 17:25:26 +0530
Subject: [PATCH 12/19] nit

---
 .../java/org/oppia/app/splash/SplashActivityTest.kt         | 6 +++---
 .../java/org/oppia/domain/OnboardingFlowControllerTest.kt   | 6 +++---
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/app/src/sharedTest/java/org/oppia/app/splash/SplashActivityTest.kt b/app/src/sharedTest/java/org/oppia/app/splash/SplashActivityTest.kt
index 057910fcbe0..af4ea897907 100644
--- a/app/src/sharedTest/java/org/oppia/app/splash/SplashActivityTest.kt
+++ b/app/src/sharedTest/java/org/oppia/app/splash/SplashActivityTest.kt
@@ -80,7 +80,7 @@ class SplashActivityTest {
 
   @Test
   fun testSplashActivity_secondOpen_routesToChooseProfileActivity() {
-    simulateAppAlreadyOpened()
+    simulateAppAlreadyOnBoarded()
     launch(SplashActivity::class.java).use {
       intended(hasComponent(ProfileActivity::class.java.name))
     }
@@ -88,7 +88,7 @@ class SplashActivityTest {
 
   @Test
   fun testSplashActivity_secondOpen_profileChooserScreenContentVerified() {
-    simulateAppAlreadyOpened()
+    simulateAppAlreadyOnBoarded()
     launch(SplashActivity::class.java).use {
       // Wait until the expected text appears on the screen, and ensure it's for the welcome text view.
       onView(withId(R.id.profile_select_text)).check(matches(withText(R.string.profile_chooser_select)))
@@ -101,7 +101,7 @@ class SplashActivityTest {
     onIdle()
   }
 
-  private fun simulateAppAlreadyOpened() {
+  private fun simulateAppAlreadyOnBoarded() {
     // Simulate the app was already onboarded by creating an isolated on-boarding flow controller and saving the onboarding status
     // on the system before the activity is opened.
     createTestRootComponent().getOnboardingingFlowController().markOnboardingingFlowCompleted()
diff --git a/domain/src/test/java/org/oppia/domain/OnboardingFlowControllerTest.kt b/domain/src/test/java/org/oppia/domain/OnboardingFlowControllerTest.kt
index b5c446548ee..e8944262959 100644
--- a/domain/src/test/java/org/oppia/domain/OnboardingFlowControllerTest.kt
+++ b/domain/src/test/java/org/oppia/domain/OnboardingFlowControllerTest.kt
@@ -116,7 +116,7 @@ class OnboardingingFlowControllerTest {
 
   @Test
   @ExperimentalCoroutinesApi
-  fun testControllerObserver_observedAfterSettingAppOnBoarded_providesLiveData_userDidNotOpenApp() =
+  fun testControllerObserver_observedAfterSettingAppOnBoarded_providesLiveData_userDidNotOnBoardApp() =
     runBlockingTest(coroutineContext) {
       val onBoarding = onBoardingFlowController.getOnboardingingFlow()
 
@@ -143,7 +143,7 @@ class OnboardingingFlowControllerTest {
     onBoarding.observeForever(mockOnboardingingObserver)
     advanceUntilIdle()
 
-    // The app should be considered open since a new LiveData instance was observed after marking the app as onBoarded.
+    // The app should be considered on-boarded since a new LiveData instance was observed after marking the app as on-boarded.
     verify(mockOnboardingingObserver, atLeastOnce()).onChanged(onBoardingResultCaptor.capture())
     assertThat(onBoardingResultCaptor.value.isSuccess()).isTrue()
     assertThat(onBoardingResultCaptor.value.getOrThrow().alreadyOnBoardedApp).isTrue()
@@ -151,7 +151,7 @@ class OnboardingingFlowControllerTest {
 
   @Test
   @ExperimentalCoroutinesApi
-  fun testController_onBoardedApp_cleared_observeNewController_userDidNotOpenApp() = runBlockingTest(coroutineContext) {
+  fun testController_onBoardedApp_cleared_observeNewController_userDidNotOnBoardApp() = runBlockingTest(coroutineContext) {
     onBoardingFlowController.markOnboardingingFlowCompleted()
     advanceUntilIdle()
 

From 3926562afa80c655d0e7a2a240ca6ac780ad0ef8 Mon Sep 17 00:00:00 2001
From: marysoloman <nikitamarysolomanpvt@gmail.com>
Date: Tue, 7 Jan 2020 13:25:36 +0530
Subject: [PATCH 13/19] nit

---
 .../app/onBoarding/OnBoardingActivity.kt      |  5 +-
 .../onBoarding/OnBoardingActivityPresenter.kt | 10 ++--
 .../org/oppia/app/splash/SplashActivity.kt    |  3 +-
 .../app/splash/SplashActivityPresenter.kt     | 28 +++++------
 ..._on_board.xml => on_boarding_activity.xml} |  1 -
 .../oppia/app/splash/SplashActivityTest.kt    | 24 ++-------
 .../oppia/domain/OnboardingFlowController.kt  | 27 +++++-----
 .../domain/OnboardingFlowControllerTest.kt    | 49 +++++++++----------
 model/src/main/proto/example.proto            |  2 +-
 9 files changed, 66 insertions(+), 83 deletions(-)
 rename app/src/main/res/layout/{dummy_on_board.xml => on_boarding_activity.xml} (99%)

diff --git a/app/src/main/java/org/oppia/app/onBoarding/OnBoardingActivity.kt b/app/src/main/java/org/oppia/app/onBoarding/OnBoardingActivity.kt
index bd727557068..d0efb79d9fe 100644
--- a/app/src/main/java/org/oppia/app/onBoarding/OnBoardingActivity.kt
+++ b/app/src/main/java/org/oppia/app/onBoarding/OnBoardingActivity.kt
@@ -5,11 +5,10 @@ import org.oppia.app.activity.InjectableAppCompatActivity
 import org.oppia.app.profile.ProfileActivity
 import javax.inject.Inject
 
-/** An activity that shows a temporary Onboardinging page until the app is onborarded then navigates to [ProfileActivity]. */
+/** An activity that shows a temporary OnBoardinging page until the app is onborarded then navigates to [ProfileActivity]. */
 class OnBoardingingActivity : InjectableAppCompatActivity() {
 
-  @Inject
-  lateinit var onBoardingActivityPresenter: OnBoardingingActivityPresenter
+  @Inject lateinit var onBoardingActivityPresenter: OnBoardingingActivityPresenter
 
   override fun onCreate(savedInstanceState: Bundle?) {
     super.onCreate(savedInstanceState)
diff --git a/app/src/main/java/org/oppia/app/onBoarding/OnBoardingActivityPresenter.kt b/app/src/main/java/org/oppia/app/onBoarding/OnBoardingActivityPresenter.kt
index ec47aef75f1..03d0169cca3 100644
--- a/app/src/main/java/org/oppia/app/onBoarding/OnBoardingActivityPresenter.kt
+++ b/app/src/main/java/org/oppia/app/onBoarding/OnBoardingActivityPresenter.kt
@@ -2,27 +2,27 @@ package org.oppia.app.onBoarding
 
 import android.content.Intent
 import androidx.appcompat.app.AppCompatActivity
-import kotlinx.android.synthetic.main.dummy_on_board.*
+import kotlinx.android.synthetic.main.on_boarding_activity.*
 import org.oppia.app.R
 import org.oppia.app.activity.ActivityScope
 import org.oppia.app.profile.ProfileActivity
-import org.oppia.domain.OnboardingingFlowController
+import org.oppia.domain.OnBoardingingFlowController
 import javax.inject.Inject
 
 /** The presenter for [OnBoardingingActivity]. */
 @ActivityScope
 class OnBoardingingActivityPresenter @Inject constructor(
   private val activity: AppCompatActivity,
-  private val onBoardingFlowController: OnboardingingFlowController
+  private val onBoardingFlowController: OnBoardingingFlowController
 ) {
 
   fun handleOnCreate() {
-    activity.setContentView(R.layout.dummy_on_board)
+    activity.setContentView(R.layout.on_boarding_activity)
     activity.onBoard.setOnClickListener({ subscribeOnBoarding() })
   }
 
   private fun subscribeOnBoarding() {
-    onBoardingFlowController.markOnboardingingFlowCompleted()
+    onBoardingFlowController.markOnBoardingingFlowCompleted()
     val intent = Intent(activity, ProfileActivity::class.java)
     activity.startActivity(intent)
     activity.finish()
diff --git a/app/src/main/java/org/oppia/app/splash/SplashActivity.kt b/app/src/main/java/org/oppia/app/splash/SplashActivity.kt
index b558f6163aa..b5a791785b2 100644
--- a/app/src/main/java/org/oppia/app/splash/SplashActivity.kt
+++ b/app/src/main/java/org/oppia/app/splash/SplashActivity.kt
@@ -9,8 +9,7 @@ import javax.inject.Inject
 /** An activity that shows a temporary loading page until the app is fully loaded then navigates to [ProfileActivity]. */
 class SplashActivity : InjectableAppCompatActivity() {
 
-  @Inject
-  lateinit var splashActivityPresenter: SplashActivityPresenter
+  @Inject lateinit var splashActivityPresenter: SplashActivityPresenter
 
   override fun onCreate(savedInstanceState: Bundle?) {
     super.onCreate(savedInstanceState)
diff --git a/app/src/main/java/org/oppia/app/splash/SplashActivityPresenter.kt b/app/src/main/java/org/oppia/app/splash/SplashActivityPresenter.kt
index 98595ac2c09..c6735d2762d 100644
--- a/app/src/main/java/org/oppia/app/splash/SplashActivityPresenter.kt
+++ b/app/src/main/java/org/oppia/app/splash/SplashActivityPresenter.kt
@@ -8,54 +8,54 @@ import androidx.lifecycle.Observer
 import androidx.lifecycle.Transformations
 import org.oppia.app.R
 import org.oppia.app.activity.ActivityScope
-import org.oppia.app.model.OnboardingingFlow
+import org.oppia.app.model.OnBoardingingFlow
 import org.oppia.app.onBoarding.OnBoardingingActivity
 import org.oppia.app.profile.ProfileActivity
-import org.oppia.domain.OnboardingingFlowController
+import org.oppia.domain.OnBoardingingFlowController
 import org.oppia.util.data.AsyncResult
 import javax.inject.Inject
 
-/** The presenter for [OnBoardingingActivity]. */
+/** The presenter for [SplashActivity]. */
 @ActivityScope
 class SplashActivityPresenter @Inject constructor(
   private val activity: AppCompatActivity,
-  onBoardingFlowController: OnboardingingFlowController
+  onBoardingFlowController: OnBoardingingFlowController
 ) {
 
-  val sample = onBoardingFlowController.getOnboardingingFlow()
+  val onBoardingFlow = onBoardingFlowController.getOnBoardingingFlow()
 
   fun handleOnCreate() {
     activity.setContentView(R.layout.splash_activity)
     activity.window.setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN);
-    subscribeToOnboardingingFlow()
+    subscribeToOnBoardingingFlow()
   }
 
-  private fun showOnboardingingActivity() {
+  private fun showOnBoardingingActivity() {
     val intent = Intent(activity, OnBoardingingActivity::class.java)
     activity.startActivity(intent)
     activity.finish()
   }
 
-  private fun subscribeToOnboardingingFlow() {
-    getOnboardingingFlow().observe(activity, Observer<OnboardingingFlow> { result ->
+  private fun subscribeToOnBoardingingFlow() {
+    getOnBoardingingFlow().observe(activity, Observer<OnBoardingingFlow> { result ->
       if (result.alreadyOnBoardedApp) {
         val intent = Intent(activity, ProfileActivity::class.java)
         activity.startActivity(intent)
         activity.finish()
       } else {
-        showOnboardingingActivity()
+        showOnBoardingingActivity()
       }
     })
   }
 
-  private fun getOnboardingingFlow(): LiveData<OnboardingingFlow> {
+  private fun getOnBoardingingFlow(): LiveData<OnBoardingingFlow> {
     // If there's an error loading the data, assume the default.
-    return Transformations.map(sample, ::processOnboardingingFlowResult)
+    return Transformations.map(onBoardingFlow, ::processOnBoardingingFlowResult)
   }
 
-  private fun processOnboardingingFlowResult(onboardingResult: AsyncResult<OnboardingingFlow>): OnboardingingFlow {
+  private fun processOnBoardingingFlowResult(onboardingResult: AsyncResult<OnBoardingingFlow>): OnBoardingingFlow {
     if (onboardingResult.isFailure()) {
     }
-    return onboardingResult.getOrDefault(OnboardingingFlow.getDefaultInstance())
+    return onboardingResult.getOrDefault(OnBoardingingFlow.getDefaultInstance())
   }
 }
diff --git a/app/src/main/res/layout/dummy_on_board.xml b/app/src/main/res/layout/on_boarding_activity.xml
similarity index 99%
rename from app/src/main/res/layout/dummy_on_board.xml
rename to app/src/main/res/layout/on_boarding_activity.xml
index 2871441b705..f26641a5abc 100644
--- a/app/src/main/res/layout/dummy_on_board.xml
+++ b/app/src/main/res/layout/on_boarding_activity.xml
@@ -11,4 +11,3 @@
     android:layout_height="wrap_content"
     android:text="on-board" />
 </LinearLayout>
-
diff --git a/app/src/sharedTest/java/org/oppia/app/splash/SplashActivityTest.kt b/app/src/sharedTest/java/org/oppia/app/splash/SplashActivityTest.kt
index af4ea897907..1be5fb40ba2 100644
--- a/app/src/sharedTest/java/org/oppia/app/splash/SplashActivityTest.kt
+++ b/app/src/sharedTest/java/org/oppia/app/splash/SplashActivityTest.kt
@@ -7,15 +7,11 @@ import android.os.Looper
 import androidx.test.core.app.ActivityScenario.launch
 import androidx.test.core.app.ApplicationProvider
 import androidx.test.espresso.Espresso.onIdle
-import androidx.test.espresso.Espresso.onView
 import androidx.test.espresso.IdlingRegistry
-import androidx.test.espresso.assertion.ViewAssertions.matches
 import androidx.test.espresso.idling.CountingIdlingResource
 import androidx.test.espresso.intent.Intents
 import androidx.test.espresso.intent.Intents.intended
 import androidx.test.espresso.intent.matcher.IntentMatchers.hasComponent
-import androidx.test.espresso.matcher.ViewMatchers.withId
-import androidx.test.espresso.matcher.ViewMatchers.withText
 import androidx.test.ext.junit.runners.AndroidJUnit4
 import androidx.test.rule.ActivityTestRule
 import dagger.BindsInstance
@@ -31,10 +27,9 @@ import org.junit.Before
 import org.junit.Rule
 import org.junit.Test
 import org.junit.runner.RunWith
-import org.oppia.app.R
 import org.oppia.app.onBoarding.OnBoardingingActivity
 import org.oppia.app.profile.ProfileActivity
-import org.oppia.domain.OnboardingingFlowController
+import org.oppia.domain.OnBoardingingFlowController
 import org.oppia.util.logging.EnableConsoleLog
 import org.oppia.util.logging.EnableFileLog
 import org.oppia.util.logging.GlobalLogLevel
@@ -73,7 +68,7 @@ class SplashActivityTest {
   )
 
   @Test
-  fun testSplashActivity_initialOpen_routesToOnboardingingActivity() {
+  fun testSplashActivity_initialOpen_routesToOnBoardingingActivity() {
     activityTestRule.launchActivity(null)
     intended(hasComponent(OnBoardingingActivity::class.java.name))
   }
@@ -86,25 +81,16 @@ class SplashActivityTest {
     }
   }
 
-  @Test
-  fun testSplashActivity_secondOpen_profileChooserScreenContentVerified() {
-    simulateAppAlreadyOnBoarded()
-    launch(SplashActivity::class.java).use {
-      // Wait until the expected text appears on the screen, and ensure it's for the welcome text view.
-      onView(withId(R.id.profile_select_text)).check(matches(withText(R.string.profile_chooser_select)))
-    }
-  }
-
   private fun simulateNewAppInstance() {
     // Simulate a fresh app install by clearing any potential on-disk caches using an isolated on-boarding flow controller.
-    createTestRootComponent().getOnboardingingFlowController().clearOnboardingingFlow()
+    createTestRootComponent().getOnBoardingingFlowController().clearOnBoardingingFlow()
     onIdle()
   }
 
   private fun simulateAppAlreadyOnBoarded() {
     // Simulate the app was already onboarded by creating an isolated on-boarding flow controller and saving the onboarding status
     // on the system before the activity is opened.
-    createTestRootComponent().getOnboardingingFlowController().markOnboardingingFlowCompleted()
+    createTestRootComponent().getOnBoardingingFlowController().markOnBoardingingFlowCompleted()
     onIdle()
   }
 
@@ -173,7 +159,7 @@ class SplashActivityTest {
       fun build(): TestApplicationComponent
     }
 
-    fun getOnboardingingFlowController(): OnboardingingFlowController
+    fun getOnBoardingingFlowController(): OnBoardingingFlowController
     fun inject(splashActivityTest: SplashActivityTest)
   }
 
diff --git a/domain/src/main/java/org/oppia/domain/OnboardingFlowController.kt b/domain/src/main/java/org/oppia/domain/OnboardingFlowController.kt
index b98c2220cfb..036a4d8a3f6 100644
--- a/domain/src/main/java/org/oppia/domain/OnboardingFlowController.kt
+++ b/domain/src/main/java/org/oppia/domain/OnboardingFlowController.kt
@@ -1,7 +1,7 @@
 package org.oppia.domain
 
 import androidx.lifecycle.LiveData
-import org.oppia.app.model.OnboardingingFlow
+import org.oppia.app.model.OnBoardingingFlow
 import org.oppia.data.persistence.PersistentCacheStore
 import org.oppia.util.data.AsyncResult
 import org.oppia.util.data.DataProviders
@@ -11,15 +11,16 @@ import javax.inject.Singleton
 
 /** Controller for persisting and retrieving the user onBoarding information of the app. */
 @Singleton
-class OnboardingingFlowController @Inject constructor(
-  cacheStoreFactory: PersistentCacheStore.Factory, private val dataProviders: DataProviders,
+class OnBoardingingFlowController @Inject constructor(
+  cacheStoreFactory: PersistentCacheStore.Factory,
+  private val dataProviders: DataProviders,
   private val logger: Logger
 ) {
-  private val onBoardingStore = cacheStoreFactory.create("onBoarding_flow", OnboardingingFlow.getDefaultInstance())
+  private val onBoardingFlowStore = cacheStoreFactory.create("onBoarding_flow", OnBoardingingFlow.getDefaultInstance())
 
   init {
-    // Prime the cache ahead of time so that any existing history is read prior to any calls to markOnboardingingFlowCompleted().
-    onBoardingStore.primeCacheAsync().invokeOnCompletion {
+    // Prime the cache ahead of time so that any existing history is read prior to any calls to markOnBoardingingFlowCompleted().
+    onBoardingFlowStore.primeCacheAsync().invokeOnCompletion {
       it?.let {
         logger.e("DOMAIN", "Failed to prime cache ahead of LiveData conversion for user on-boarding data.", it)
       }
@@ -30,8 +31,8 @@ class OnboardingingFlowController @Inject constructor(
    * Saves that the user has completed on-boarding the app. Note that this does not notify existing subscribers of the changed state,
    * nor can future subscribers observe this state until app restart.
    */
-  fun markOnboardingingFlowCompleted() {
-    onBoardingStore.storeDataAsync(updateInMemoryCache = false) {
+  fun markOnBoardingingFlowCompleted() {
+    onBoardingFlowStore.storeDataAsync(updateInMemoryCache = false) {
       it.toBuilder().setAlreadyOnBoardedApp(true).build()
     }.invokeOnCompletion {
       it?.let {
@@ -41,8 +42,8 @@ class OnboardingingFlowController @Inject constructor(
   }
 
   /** Clears any indication that the user has previously completed on-boarding the application. */
-  fun clearOnboardingingFlow() {
-    onBoardingStore.clearCacheAsync().invokeOnCompletion {
+  fun clearOnBoardingingFlow() {
+    onBoardingFlowStore.clearCacheAsync().invokeOnCompletion {
       it?.let {
         logger.e("DOMAIN", "Failed to clear onBoarding flow.", it)
       }
@@ -51,10 +52,10 @@ class OnboardingingFlowController @Inject constructor(
 
   /**
    * Returns a [LiveData] result indicating whether the user has onBoarded the app. This is guaranteed to
-   * provide the state of the store upon the creation of this controller even if [markOnboardingingFlowCompleted] has since been
+   * provide the state of the store upon the creation of this controller even if [markOnBoardingingFlowCompleted] has since been
    * called.
    */
-  fun getOnboardingingFlow(): LiveData<AsyncResult<OnboardingingFlow>> {
-    return dataProviders.convertToLiveData(onBoardingStore)
+  fun getOnBoardingingFlow(): LiveData<AsyncResult<OnBoardingingFlow>> {
+    return dataProviders.convertToLiveData(onBoardingFlowStore)
   }
 }
diff --git a/domain/src/test/java/org/oppia/domain/OnboardingFlowControllerTest.kt b/domain/src/test/java/org/oppia/domain/OnboardingFlowControllerTest.kt
index e8944262959..d4ab3736e9c 100644
--- a/domain/src/test/java/org/oppia/domain/OnboardingFlowControllerTest.kt
+++ b/domain/src/test/java/org/oppia/domain/OnboardingFlowControllerTest.kt
@@ -32,7 +32,7 @@ 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.OnboardingingFlow
+import org.oppia.app.model.OnBoardingingFlow
 import org.oppia.util.data.AsyncResult
 import org.oppia.util.logging.EnableConsoleLog
 import org.oppia.util.logging.EnableFileLog
@@ -46,10 +46,10 @@ import javax.inject.Qualifier
 import javax.inject.Singleton
 import kotlin.coroutines.EmptyCoroutineContext
 
-/** Tests for [OnboardingingFlowController]. */
+/** Tests for [OnBoardingingFlowController]. */
 @RunWith(AndroidJUnit4::class)
 @Config(manifest = Config.NONE)
-class OnboardingingFlowControllerTest {
+class OnBoardingingFlowControllerTest {
   @Rule
   @JvmField
   val mockitoRule: MockitoRule = MockitoJUnit.rule()
@@ -58,8 +58,7 @@ class OnboardingingFlowControllerTest {
   @JvmField
   val executorRule = InstantTaskExecutorRule()
 
-  @Inject
-  lateinit var onBoardingFlowController: OnboardingingFlowController
+  @Inject lateinit var onBoardingFlowController: OnBoardingingFlowController
 
   @Inject
   @field:TestDispatcher
@@ -70,10 +69,10 @@ class OnboardingingFlowControllerTest {
   }
 
   @Mock
-  lateinit var mockOnboardingingObserver: Observer<AsyncResult<OnboardingingFlow>>
+  lateinit var mockOnBoardingingObserver: Observer<AsyncResult<OnBoardingingFlow>>
 
   @Captor
-  lateinit var onBoardingResultCaptor: ArgumentCaptor<AsyncResult<OnboardingingFlow>>
+  lateinit var onBoardingResultCaptor: ArgumentCaptor<AsyncResult<OnBoardingingFlow>>
 
   // https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-test/
   @ObsoleteCoroutinesApi
@@ -96,7 +95,7 @@ class OnboardingingFlowControllerTest {
   }
 
   private fun setUpTestApplicationComponent() {
-    DaggerOnboardingingFlowControllerTest_TestApplicationComponent.builder()
+    DaggerOnBoardingingFlowControllerTest_TestApplicationComponent.builder()
       .setApplication(ApplicationProvider.getApplicationContext())
       .build()
       .inject(this)
@@ -105,11 +104,11 @@ class OnboardingingFlowControllerTest {
   @Test
   @ExperimentalCoroutinesApi
   fun testController_providesInitialLiveData_thatIndicatesUserHasNotOnBoardedTheApp() = runBlockingTest(coroutineContext) {
-    val onBoarding = onBoardingFlowController.getOnboardingingFlow()
+    val onBoarding = onBoardingFlowController.getOnBoardingingFlow()
     advanceUntilIdle()
-    onBoarding.observeForever(mockOnboardingingObserver)
+    onBoarding.observeForever(mockOnBoardingingObserver)
 
-    verify(mockOnboardingingObserver, atLeastOnce()).onChanged(onBoardingResultCaptor.capture())
+    verify(mockOnBoardingingObserver, atLeastOnce()).onChanged(onBoardingResultCaptor.capture())
     assertThat(onBoardingResultCaptor.value.isSuccess()).isTrue()
     assertThat(onBoardingResultCaptor.value.getOrThrow().alreadyOnBoardedApp).isFalse()
   }
@@ -118,15 +117,15 @@ class OnboardingingFlowControllerTest {
   @ExperimentalCoroutinesApi
   fun testControllerObserver_observedAfterSettingAppOnBoarded_providesLiveData_userDidNotOnBoardApp() =
     runBlockingTest(coroutineContext) {
-      val onBoarding = onBoardingFlowController.getOnboardingingFlow()
+      val onBoarding = onBoardingFlowController.getOnBoardingingFlow()
 
-      onBoarding.observeForever(mockOnboardingingObserver)
-      onBoardingFlowController.markOnboardingingFlowCompleted()
+      onBoarding.observeForever(mockOnBoardingingObserver)
+      onBoardingFlowController.markOnBoardingingFlowCompleted()
       advanceUntilIdle()
 
       // The result should not indicate that the user onBoarded the app because markUserOnBoardedApp does not notify observers
       // of the change.
-      verify(mockOnboardingingObserver, atLeastOnce()).onChanged(onBoardingResultCaptor.capture())
+      verify(mockOnBoardingingObserver, atLeastOnce()).onChanged(onBoardingResultCaptor.capture())
       assertThat(onBoardingResultCaptor.value.isSuccess()).isTrue()
       assertThat(onBoardingResultCaptor.value.getOrThrow().alreadyOnBoardedApp).isFalse()
     }
@@ -134,17 +133,17 @@ class OnboardingingFlowControllerTest {
   @Test
   @ExperimentalCoroutinesApi
   fun testController_settingAppOnBoarded_observedNewController_userOnBoardedApp() = runBlockingTest(coroutineContext) {
-    onBoardingFlowController.markOnboardingingFlowCompleted()
+    onBoardingFlowController.markOnBoardingingFlowCompleted()
     advanceUntilIdle()
 
     // Create the controller by creating another singleton graph and injecting it (simulating the app being recreated).
     setUpTestApplicationComponent()
-    val onBoarding = onBoardingFlowController.getOnboardingingFlow()
-    onBoarding.observeForever(mockOnboardingingObserver)
+    val onBoarding = onBoardingFlowController.getOnBoardingingFlow()
+    onBoarding.observeForever(mockOnBoardingingObserver)
     advanceUntilIdle()
 
     // The app should be considered on-boarded since a new LiveData instance was observed after marking the app as on-boarded.
-    verify(mockOnboardingingObserver, atLeastOnce()).onChanged(onBoardingResultCaptor.capture())
+    verify(mockOnBoardingingObserver, atLeastOnce()).onChanged(onBoardingResultCaptor.capture())
     assertThat(onBoardingResultCaptor.value.isSuccess()).isTrue()
     assertThat(onBoardingResultCaptor.value.getOrThrow().alreadyOnBoardedApp).isTrue()
   }
@@ -152,18 +151,18 @@ class OnboardingingFlowControllerTest {
   @Test
   @ExperimentalCoroutinesApi
   fun testController_onBoardedApp_cleared_observeNewController_userDidNotOnBoardApp() = runBlockingTest(coroutineContext) {
-    onBoardingFlowController.markOnboardingingFlowCompleted()
+    onBoardingFlowController.markOnBoardingingFlowCompleted()
     advanceUntilIdle()
 
     // Clear, then recreate another controller.
-    onBoardingFlowController.clearOnboardingingFlow()
+    onBoardingFlowController.clearOnBoardingingFlow()
     setUpTestApplicationComponent()
-    val onBoarding = onBoardingFlowController.getOnboardingingFlow()
-    onBoarding.observeForever(mockOnboardingingObserver)
+    val onBoarding = onBoardingFlowController.getOnBoardingingFlow()
+    onBoarding.observeForever(mockOnBoardingingObserver)
     advanceUntilIdle()
 
     // The app should be considered not yet onBoarded since the previous history was cleared.
-    verify(mockOnboardingingObserver, atLeastOnce()).onChanged(onBoardingResultCaptor.capture())
+    verify(mockOnBoardingingObserver, atLeastOnce()).onChanged(onBoardingResultCaptor.capture())
     assertThat(onBoardingResultCaptor.value.isSuccess()).isTrue()
     assertThat(onBoardingResultCaptor.value.getOrThrow().alreadyOnBoardedApp).isFalse()
   }
@@ -229,6 +228,6 @@ class OnboardingingFlowControllerTest {
       fun build(): TestApplicationComponent
     }
 
-    fun inject(onBoardingFlowControllerTest: OnboardingingFlowControllerTest)
+    fun inject(onBoardingFlowControllerTest: OnBoardingingFlowControllerTest)
   }
 }
diff --git a/model/src/main/proto/example.proto b/model/src/main/proto/example.proto
index 60e8f3ba319..2eba8e467d1 100644
--- a/model/src/main/proto/example.proto
+++ b/model/src/main/proto/example.proto
@@ -9,7 +9,7 @@ message UserAppHistory {
   bool already_opened_app = 1;
 }
 
-message OnboardingingFlow {
+message OnBoardingingFlow {
   bool already_on_boarded_app = 1;
 }
 

From f3c9e7fb003907eeaa33ac95196aac81d5a3c458 Mon Sep 17 00:00:00 2001
From: marysoloman <nikitamarysolomanpvt@gmail.com>
Date: Thu, 9 Jan 2020 14:38:45 +0530
Subject: [PATCH 14/19] naming fix

---
 app/src/main/AndroidManifest.xml              |  2 +-
 .../oppia/app/activity/ActivityComponent.kt   |  4 +-
 .../app/onBoarding/OnBoardingActivity.kt      |  4 +-
 .../onBoarding/OnBoardingActivityPresenter.kt |  8 ++--
 .../app/splash/SplashActivityPresenter.kt     | 30 ++++++------
 .../oppia/app/splash/SplashActivityTest.kt    | 14 +++---
 .../oppia/domain/OnboardingFlowController.kt  | 12 ++---
 .../domain/OnboardingFlowControllerTest.kt    | 46 +++++++++----------
 model/src/main/proto/example.proto            |  2 +-
 9 files changed, 61 insertions(+), 61 deletions(-)

diff --git a/app/src/main/AndroidManifest.xml b/app/src/main/AndroidManifest.xml
index 8ef03828ce0..439401432c5 100644
--- a/app/src/main/AndroidManifest.xml
+++ b/app/src/main/AndroidManifest.xml
@@ -30,7 +30,7 @@
       android:screenOrientation="portrait"
       android:theme="@style/OppiaThemeWithoutActionBar" />
     <activity
-      android:name=".onBoarding.OnBoardingingActivity"
+      android:name=".onBoarding.OnBoardingActivity"
       android:screenOrientation="portrait"
       android:theme="@style/OppiaThemeWithoutActionBar" />
     <activity
diff --git a/app/src/main/java/org/oppia/app/activity/ActivityComponent.kt b/app/src/main/java/org/oppia/app/activity/ActivityComponent.kt
index 81f76c51349..0bc5a8760b7 100644
--- a/app/src/main/java/org/oppia/app/activity/ActivityComponent.kt
+++ b/app/src/main/java/org/oppia/app/activity/ActivityComponent.kt
@@ -8,7 +8,7 @@ import org.oppia.app.help.HelpActivity
 import org.oppia.app.home.HomeActivity
 import org.oppia.app.home.continueplaying.ContinuePlayingActivity
 import org.oppia.app.mydownloads.MyDownloadsActivity
-import org.oppia.app.onBoarding.OnBoardingingActivity
+import org.oppia.app.onBoarding.OnBoardingActivity
 import org.oppia.app.player.exploration.ExplorationActivity
 import org.oppia.app.profile.AddProfileActivity
 import org.oppia.app.profile.AdminAuthActivity
@@ -68,7 +68,7 @@ interface ActivityComponent {
   fun inject(htmlParserTestActivity: HtmlParserTestActivity)
   fun inject(myDownloadsActivity: MyDownloadsActivity)
   fun inject(navigationDrawerTestActivity: NavigationDrawerTestActivity)
-  fun inject(onBoardingActivity: OnBoardingingActivity)
+  fun inject(onBoardingActivity: OnBoardingActivity)
   fun inject(pinPasswordActivity: PinPasswordActivity)
   fun inject(profileActivity: ProfileActivity)
   fun inject(questionPlayerActivity: QuestionPlayerActivity)
diff --git a/app/src/main/java/org/oppia/app/onBoarding/OnBoardingActivity.kt b/app/src/main/java/org/oppia/app/onBoarding/OnBoardingActivity.kt
index d0efb79d9fe..7b1328c9ae8 100644
--- a/app/src/main/java/org/oppia/app/onBoarding/OnBoardingActivity.kt
+++ b/app/src/main/java/org/oppia/app/onBoarding/OnBoardingActivity.kt
@@ -6,9 +6,9 @@ import org.oppia.app.profile.ProfileActivity
 import javax.inject.Inject
 
 /** An activity that shows a temporary OnBoardinging page until the app is onborarded then navigates to [ProfileActivity]. */
-class OnBoardingingActivity : InjectableAppCompatActivity() {
+class OnBoardingActivity : InjectableAppCompatActivity() {
 
-  @Inject lateinit var onBoardingActivityPresenter: OnBoardingingActivityPresenter
+  @Inject lateinit var onBoardingActivityPresenter: OnBoardingActivityPresenter
 
   override fun onCreate(savedInstanceState: Bundle?) {
     super.onCreate(savedInstanceState)
diff --git a/app/src/main/java/org/oppia/app/onBoarding/OnBoardingActivityPresenter.kt b/app/src/main/java/org/oppia/app/onBoarding/OnBoardingActivityPresenter.kt
index 03d0169cca3..01becb24254 100644
--- a/app/src/main/java/org/oppia/app/onBoarding/OnBoardingActivityPresenter.kt
+++ b/app/src/main/java/org/oppia/app/onBoarding/OnBoardingActivityPresenter.kt
@@ -6,14 +6,14 @@ import kotlinx.android.synthetic.main.on_boarding_activity.*
 import org.oppia.app.R
 import org.oppia.app.activity.ActivityScope
 import org.oppia.app.profile.ProfileActivity
-import org.oppia.domain.OnBoardingingFlowController
+import org.oppia.domain.OnBoardingFlowController
 import javax.inject.Inject
 
 /** The presenter for [OnBoardingingActivity]. */
 @ActivityScope
-class OnBoardingingActivityPresenter @Inject constructor(
+class OnBoardingActivityPresenter @Inject constructor(
   private val activity: AppCompatActivity,
-  private val onBoardingFlowController: OnBoardingingFlowController
+  private val onBoardingFlowController: OnBoardingFlowController
 ) {
 
   fun handleOnCreate() {
@@ -22,7 +22,7 @@ class OnBoardingingActivityPresenter @Inject constructor(
   }
 
   private fun subscribeOnBoarding() {
-    onBoardingFlowController.markOnBoardingingFlowCompleted()
+    onBoardingFlowController.markOnBoardingFlowCompleted()
     val intent = Intent(activity, ProfileActivity::class.java)
     activity.startActivity(intent)
     activity.finish()
diff --git a/app/src/main/java/org/oppia/app/splash/SplashActivityPresenter.kt b/app/src/main/java/org/oppia/app/splash/SplashActivityPresenter.kt
index c6735d2762d..833c07ab799 100644
--- a/app/src/main/java/org/oppia/app/splash/SplashActivityPresenter.kt
+++ b/app/src/main/java/org/oppia/app/splash/SplashActivityPresenter.kt
@@ -8,10 +8,10 @@ import androidx.lifecycle.Observer
 import androidx.lifecycle.Transformations
 import org.oppia.app.R
 import org.oppia.app.activity.ActivityScope
-import org.oppia.app.model.OnBoardingingFlow
-import org.oppia.app.onBoarding.OnBoardingingActivity
+import org.oppia.app.model.OnBoardingFlow
+import org.oppia.app.onBoarding.OnBoardingActivity
 import org.oppia.app.profile.ProfileActivity
-import org.oppia.domain.OnBoardingingFlowController
+import org.oppia.domain.OnBoardingFlowController
 import org.oppia.util.data.AsyncResult
 import javax.inject.Inject
 
@@ -19,43 +19,43 @@ import javax.inject.Inject
 @ActivityScope
 class SplashActivityPresenter @Inject constructor(
   private val activity: AppCompatActivity,
-  onBoardingFlowController: OnBoardingingFlowController
+  onBoardingFlowController: OnBoardingFlowController
 ) {
 
-  val onBoardingFlow = onBoardingFlowController.getOnBoardingingFlow()
+  val onBoardingFlowData = onBoardingFlowController.getOnBoardingFlow()
 
   fun handleOnCreate() {
     activity.setContentView(R.layout.splash_activity)
     activity.window.setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN);
-    subscribeToOnBoardingingFlow()
+    subscribeToOnBoardingFlow()
   }
 
-  private fun showOnBoardingingActivity() {
-    val intent = Intent(activity, OnBoardingingActivity::class.java)
+  private fun showOnBoardingActivity() {
+    val intent = Intent(activity, OnBoardingActivity::class.java)
     activity.startActivity(intent)
     activity.finish()
   }
 
-  private fun subscribeToOnBoardingingFlow() {
-    getOnBoardingingFlow().observe(activity, Observer<OnBoardingingFlow> { result ->
+  private fun subscribeToOnBoardingFlow() {
+    getOnBoardingFlow().observe(activity, Observer<OnBoardingFlow> { result ->
       if (result.alreadyOnBoardedApp) {
         val intent = Intent(activity, ProfileActivity::class.java)
         activity.startActivity(intent)
         activity.finish()
       } else {
-        showOnBoardingingActivity()
+        showOnBoardingActivity()
       }
     })
   }
 
-  private fun getOnBoardingingFlow(): LiveData<OnBoardingingFlow> {
+  private fun getOnBoardingFlow(): LiveData<OnBoardingFlow> {
     // If there's an error loading the data, assume the default.
-    return Transformations.map(onBoardingFlow, ::processOnBoardingingFlowResult)
+    return Transformations.map(onBoardingFlowData, ::processOnBoardingFlowResult)
   }
 
-  private fun processOnBoardingingFlowResult(onboardingResult: AsyncResult<OnBoardingingFlow>): OnBoardingingFlow {
+  private fun processOnBoardingFlowResult(onboardingResult: AsyncResult<OnBoardingFlow>): OnBoardingFlow {
     if (onboardingResult.isFailure()) {
     }
-    return onboardingResult.getOrDefault(OnBoardingingFlow.getDefaultInstance())
+    return onboardingResult.getOrDefault(OnBoardingFlow.getDefaultInstance())
   }
 }
diff --git a/app/src/sharedTest/java/org/oppia/app/splash/SplashActivityTest.kt b/app/src/sharedTest/java/org/oppia/app/splash/SplashActivityTest.kt
index 1be5fb40ba2..c96e69f5042 100644
--- a/app/src/sharedTest/java/org/oppia/app/splash/SplashActivityTest.kt
+++ b/app/src/sharedTest/java/org/oppia/app/splash/SplashActivityTest.kt
@@ -27,9 +27,9 @@ import org.junit.Before
 import org.junit.Rule
 import org.junit.Test
 import org.junit.runner.RunWith
-import org.oppia.app.onBoarding.OnBoardingingActivity
+import org.oppia.app.onBoarding.OnBoardingActivity
 import org.oppia.app.profile.ProfileActivity
-import org.oppia.domain.OnBoardingingFlowController
+import org.oppia.domain.OnBoardingFlowController
 import org.oppia.util.logging.EnableConsoleLog
 import org.oppia.util.logging.EnableFileLog
 import org.oppia.util.logging.GlobalLogLevel
@@ -68,9 +68,9 @@ class SplashActivityTest {
   )
 
   @Test
-  fun testSplashActivity_initialOpen_routesToOnBoardingingActivity() {
+  fun testSplashActivity_initialOpen_routesToOnBoardingActivity() {
     activityTestRule.launchActivity(null)
-    intended(hasComponent(OnBoardingingActivity::class.java.name))
+    intended(hasComponent(OnBoardingActivity::class.java.name))
   }
 
   @Test
@@ -83,14 +83,14 @@ class SplashActivityTest {
 
   private fun simulateNewAppInstance() {
     // Simulate a fresh app install by clearing any potential on-disk caches using an isolated on-boarding flow controller.
-    createTestRootComponent().getOnBoardingingFlowController().clearOnBoardingingFlow()
+    createTestRootComponent().getOnBoardingFlowController().clearOnBoardingFlow()
     onIdle()
   }
 
   private fun simulateAppAlreadyOnBoarded() {
     // Simulate the app was already onboarded by creating an isolated on-boarding flow controller and saving the onboarding status
     // on the system before the activity is opened.
-    createTestRootComponent().getOnBoardingingFlowController().markOnBoardingingFlowCompleted()
+    createTestRootComponent().getOnBoardingFlowController().markOnBoardingFlowCompleted()
     onIdle()
   }
 
@@ -159,7 +159,7 @@ class SplashActivityTest {
       fun build(): TestApplicationComponent
     }
 
-    fun getOnBoardingingFlowController(): OnBoardingingFlowController
+    fun getOnBoardingFlowController(): OnBoardingFlowController
     fun inject(splashActivityTest: SplashActivityTest)
   }
 
diff --git a/domain/src/main/java/org/oppia/domain/OnboardingFlowController.kt b/domain/src/main/java/org/oppia/domain/OnboardingFlowController.kt
index 036a4d8a3f6..34e6db7e1af 100644
--- a/domain/src/main/java/org/oppia/domain/OnboardingFlowController.kt
+++ b/domain/src/main/java/org/oppia/domain/OnboardingFlowController.kt
@@ -1,7 +1,7 @@
 package org.oppia.domain
 
 import androidx.lifecycle.LiveData
-import org.oppia.app.model.OnBoardingingFlow
+import org.oppia.app.model.OnBoardingFlow
 import org.oppia.data.persistence.PersistentCacheStore
 import org.oppia.util.data.AsyncResult
 import org.oppia.util.data.DataProviders
@@ -11,12 +11,12 @@ import javax.inject.Singleton
 
 /** Controller for persisting and retrieving the user onBoarding information of the app. */
 @Singleton
-class OnBoardingingFlowController @Inject constructor(
+class OnBoardingFlowController @Inject constructor(
   cacheStoreFactory: PersistentCacheStore.Factory,
   private val dataProviders: DataProviders,
   private val logger: Logger
 ) {
-  private val onBoardingFlowStore = cacheStoreFactory.create("onBoarding_flow", OnBoardingingFlow.getDefaultInstance())
+  private val onBoardingFlowStore = cacheStoreFactory.create("onBoarding_flow", OnBoardingFlow.getDefaultInstance())
 
   init {
     // Prime the cache ahead of time so that any existing history is read prior to any calls to markOnBoardingingFlowCompleted().
@@ -31,7 +31,7 @@ class OnBoardingingFlowController @Inject constructor(
    * Saves that the user has completed on-boarding the app. Note that this does not notify existing subscribers of the changed state,
    * nor can future subscribers observe this state until app restart.
    */
-  fun markOnBoardingingFlowCompleted() {
+  fun markOnBoardingFlowCompleted() {
     onBoardingFlowStore.storeDataAsync(updateInMemoryCache = false) {
       it.toBuilder().setAlreadyOnBoardedApp(true).build()
     }.invokeOnCompletion {
@@ -42,7 +42,7 @@ class OnBoardingingFlowController @Inject constructor(
   }
 
   /** Clears any indication that the user has previously completed on-boarding the application. */
-  fun clearOnBoardingingFlow() {
+  fun clearOnBoardingFlow() {
     onBoardingFlowStore.clearCacheAsync().invokeOnCompletion {
       it?.let {
         logger.e("DOMAIN", "Failed to clear onBoarding flow.", it)
@@ -55,7 +55,7 @@ class OnBoardingingFlowController @Inject constructor(
    * provide the state of the store upon the creation of this controller even if [markOnBoardingingFlowCompleted] has since been
    * called.
    */
-  fun getOnBoardingingFlow(): LiveData<AsyncResult<OnBoardingingFlow>> {
+  fun getOnBoardingFlow(): LiveData<AsyncResult<OnBoardingFlow>> {
     return dataProviders.convertToLiveData(onBoardingFlowStore)
   }
 }
diff --git a/domain/src/test/java/org/oppia/domain/OnboardingFlowControllerTest.kt b/domain/src/test/java/org/oppia/domain/OnboardingFlowControllerTest.kt
index d4ab3736e9c..c380a34fa2b 100644
--- a/domain/src/test/java/org/oppia/domain/OnboardingFlowControllerTest.kt
+++ b/domain/src/test/java/org/oppia/domain/OnboardingFlowControllerTest.kt
@@ -32,7 +32,7 @@ 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.OnBoardingingFlow
+import org.oppia.app.model.OnBoardingFlow
 import org.oppia.util.data.AsyncResult
 import org.oppia.util.logging.EnableConsoleLog
 import org.oppia.util.logging.EnableFileLog
@@ -49,7 +49,7 @@ import kotlin.coroutines.EmptyCoroutineContext
 /** Tests for [OnBoardingingFlowController]. */
 @RunWith(AndroidJUnit4::class)
 @Config(manifest = Config.NONE)
-class OnBoardingingFlowControllerTest {
+class OnBoardingFlowControllerTest {
   @Rule
   @JvmField
   val mockitoRule: MockitoRule = MockitoJUnit.rule()
@@ -58,7 +58,7 @@ class OnBoardingingFlowControllerTest {
   @JvmField
   val executorRule = InstantTaskExecutorRule()
 
-  @Inject lateinit var onBoardingFlowController: OnBoardingingFlowController
+  @Inject lateinit var onBoardingFlowController: OnBoardingFlowController
 
   @Inject
   @field:TestDispatcher
@@ -69,10 +69,10 @@ class OnBoardingingFlowControllerTest {
   }
 
   @Mock
-  lateinit var mockOnBoardingingObserver: Observer<AsyncResult<OnBoardingingFlow>>
+  lateinit var mockOnBoardingObserver: Observer<AsyncResult<OnBoardingFlow>>
 
   @Captor
-  lateinit var onBoardingResultCaptor: ArgumentCaptor<AsyncResult<OnBoardingingFlow>>
+  lateinit var onBoardingResultCaptor: ArgumentCaptor<AsyncResult<OnBoardingFlow>>
 
   // https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-test/
   @ObsoleteCoroutinesApi
@@ -95,7 +95,7 @@ class OnBoardingingFlowControllerTest {
   }
 
   private fun setUpTestApplicationComponent() {
-    DaggerOnBoardingingFlowControllerTest_TestApplicationComponent.builder()
+    DaggerOnBoardingFlowControllerTest_TestApplicationComponent.builder()
       .setApplication(ApplicationProvider.getApplicationContext())
       .build()
       .inject(this)
@@ -104,11 +104,11 @@ class OnBoardingingFlowControllerTest {
   @Test
   @ExperimentalCoroutinesApi
   fun testController_providesInitialLiveData_thatIndicatesUserHasNotOnBoardedTheApp() = runBlockingTest(coroutineContext) {
-    val onBoarding = onBoardingFlowController.getOnBoardingingFlow()
+    val onBoarding = onBoardingFlowController.getOnBoardingFlow()
     advanceUntilIdle()
-    onBoarding.observeForever(mockOnBoardingingObserver)
+    onBoarding.observeForever(mockOnBoardingObserver)
 
-    verify(mockOnBoardingingObserver, atLeastOnce()).onChanged(onBoardingResultCaptor.capture())
+    verify(mockOnBoardingObserver, atLeastOnce()).onChanged(onBoardingResultCaptor.capture())
     assertThat(onBoardingResultCaptor.value.isSuccess()).isTrue()
     assertThat(onBoardingResultCaptor.value.getOrThrow().alreadyOnBoardedApp).isFalse()
   }
@@ -117,15 +117,15 @@ class OnBoardingingFlowControllerTest {
   @ExperimentalCoroutinesApi
   fun testControllerObserver_observedAfterSettingAppOnBoarded_providesLiveData_userDidNotOnBoardApp() =
     runBlockingTest(coroutineContext) {
-      val onBoarding = onBoardingFlowController.getOnBoardingingFlow()
+      val onBoarding = onBoardingFlowController.getOnBoardingFlow()
 
-      onBoarding.observeForever(mockOnBoardingingObserver)
-      onBoardingFlowController.markOnBoardingingFlowCompleted()
+      onBoarding.observeForever(mockOnBoardingObserver)
+      onBoardingFlowController.markOnBoardingFlowCompleted()
       advanceUntilIdle()
 
       // The result should not indicate that the user onBoarded the app because markUserOnBoardedApp does not notify observers
       // of the change.
-      verify(mockOnBoardingingObserver, atLeastOnce()).onChanged(onBoardingResultCaptor.capture())
+      verify(mockOnBoardingObserver, atLeastOnce()).onChanged(onBoardingResultCaptor.capture())
       assertThat(onBoardingResultCaptor.value.isSuccess()).isTrue()
       assertThat(onBoardingResultCaptor.value.getOrThrow().alreadyOnBoardedApp).isFalse()
     }
@@ -133,17 +133,17 @@ class OnBoardingingFlowControllerTest {
   @Test
   @ExperimentalCoroutinesApi
   fun testController_settingAppOnBoarded_observedNewController_userOnBoardedApp() = runBlockingTest(coroutineContext) {
-    onBoardingFlowController.markOnBoardingingFlowCompleted()
+    onBoardingFlowController.markOnBoardingFlowCompleted()
     advanceUntilIdle()
 
     // Create the controller by creating another singleton graph and injecting it (simulating the app being recreated).
     setUpTestApplicationComponent()
-    val onBoarding = onBoardingFlowController.getOnBoardingingFlow()
-    onBoarding.observeForever(mockOnBoardingingObserver)
+    val onBoarding = onBoardingFlowController.getOnBoardingFlow()
+    onBoarding.observeForever(mockOnBoardingObserver)
     advanceUntilIdle()
 
     // The app should be considered on-boarded since a new LiveData instance was observed after marking the app as on-boarded.
-    verify(mockOnBoardingingObserver, atLeastOnce()).onChanged(onBoardingResultCaptor.capture())
+    verify(mockOnBoardingObserver, atLeastOnce()).onChanged(onBoardingResultCaptor.capture())
     assertThat(onBoardingResultCaptor.value.isSuccess()).isTrue()
     assertThat(onBoardingResultCaptor.value.getOrThrow().alreadyOnBoardedApp).isTrue()
   }
@@ -151,18 +151,18 @@ class OnBoardingingFlowControllerTest {
   @Test
   @ExperimentalCoroutinesApi
   fun testController_onBoardedApp_cleared_observeNewController_userDidNotOnBoardApp() = runBlockingTest(coroutineContext) {
-    onBoardingFlowController.markOnBoardingingFlowCompleted()
+    onBoardingFlowController.markOnBoardingFlowCompleted()
     advanceUntilIdle()
 
     // Clear, then recreate another controller.
-    onBoardingFlowController.clearOnBoardingingFlow()
+    onBoardingFlowController.clearOnBoardingFlow()
     setUpTestApplicationComponent()
-    val onBoarding = onBoardingFlowController.getOnBoardingingFlow()
-    onBoarding.observeForever(mockOnBoardingingObserver)
+    val onBoarding = onBoardingFlowController.getOnBoardingFlow()
+    onBoarding.observeForever(mockOnBoardingObserver)
     advanceUntilIdle()
 
     // The app should be considered not yet onBoarded since the previous history was cleared.
-    verify(mockOnBoardingingObserver, atLeastOnce()).onChanged(onBoardingResultCaptor.capture())
+    verify(mockOnBoardingObserver, atLeastOnce()).onChanged(onBoardingResultCaptor.capture())
     assertThat(onBoardingResultCaptor.value.isSuccess()).isTrue()
     assertThat(onBoardingResultCaptor.value.getOrThrow().alreadyOnBoardedApp).isFalse()
   }
@@ -228,6 +228,6 @@ class OnBoardingingFlowControllerTest {
       fun build(): TestApplicationComponent
     }
 
-    fun inject(onBoardingFlowControllerTest: OnBoardingingFlowControllerTest)
+    fun inject(onBoardingFlowControllerTest: OnBoardingFlowControllerTest)
   }
 }
diff --git a/model/src/main/proto/example.proto b/model/src/main/proto/example.proto
index 2eba8e467d1..ae1189b08f2 100644
--- a/model/src/main/proto/example.proto
+++ b/model/src/main/proto/example.proto
@@ -9,7 +9,7 @@ message UserAppHistory {
   bool already_opened_app = 1;
 }
 
-message OnBoardingingFlow {
+message OnBoardingFlow {
   bool already_on_boarded_app = 1;
 }
 

From 7d5d5867368704d035274fdf76ef5f4bca297dbb Mon Sep 17 00:00:00 2001
From: marysoloman <nikitamarysolomanpvt@gmail.com>
Date: Thu, 9 Jan 2020 15:00:52 +0530
Subject: [PATCH 15/19] Merge branches 'develop' and 'domain-onboarding-flag'
 of https://github.com/oppia/oppia-android into domain-onboarding-flag

# Conflicts:
#	app/src/main/java/org/oppia/app/splash/SplashActivity.kt
---
 .../org/oppia/app/topic/info/TopicInfoFragmentPresenter.kt    | 1 +
 data/src/test/java/org/oppia/data/backends/ApiUtils.kt        | 2 +-
 .../org/oppia/domain/profile/ProfileManagementController.kt   | 4 +++-
 3 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/app/src/main/java/org/oppia/app/topic/info/TopicInfoFragmentPresenter.kt b/app/src/main/java/org/oppia/app/topic/info/TopicInfoFragmentPresenter.kt
index f0bc90e4ea4..5d9aac8e76a 100644
--- a/app/src/main/java/org/oppia/app/topic/info/TopicInfoFragmentPresenter.kt
+++ b/app/src/main/java/org/oppia/app/topic/info/TopicInfoFragmentPresenter.kt
@@ -8,6 +8,7 @@ import androidx.lifecycle.LiveData
 import androidx.lifecycle.Observer
 import androidx.lifecycle.Transformations
 import org.oppia.app.R
+import org.oppia.app.databinding.TopicInfoFragmentBinding
 import org.oppia.app.fragment.FragmentScope
 import org.oppia.app.model.Topic
 import org.oppia.app.topic.TOPIC_ID_ARGUMENT_KEY
diff --git a/data/src/test/java/org/oppia/data/backends/ApiUtils.kt b/data/src/test/java/org/oppia/data/backends/ApiUtils.kt
index 0294ced59d3..b6862309ab9 100644
--- a/data/src/test/java/org/oppia/data/backends/ApiUtils.kt
+++ b/data/src/test/java/org/oppia/data/backends/ApiUtils.kt
@@ -1,7 +1,7 @@
 package org.oppia.data.backends
 
-import org.json.JSONException
 import org.json.JSONObject
+import org.json.JSONException
 import java.io.FileInputStream
 
 /** A class that loads json responses for test cases */
diff --git a/domain/src/main/java/org/oppia/domain/profile/ProfileManagementController.kt b/domain/src/main/java/org/oppia/domain/profile/ProfileManagementController.kt
index 236957e445e..70d55a86517 100644
--- a/domain/src/main/java/org/oppia/domain/profile/ProfileManagementController.kt
+++ b/domain/src/main/java/org/oppia/domain/profile/ProfileManagementController.kt
@@ -22,7 +22,9 @@ import org.oppia.util.logging.Logger
 import org.oppia.util.profile.DirectoryManagementUtil
 import java.io.File
 import java.io.FileOutputStream
-import java.util.*
+import java.lang.Exception
+import java.util.Date
+import java.util.Locale
 import javax.inject.Inject
 import javax.inject.Singleton
 

From cc0328784c8bd3dc5ab7345bd2189d2e2980f1be Mon Sep 17 00:00:00 2001
From: marysoloman <nikitamarysolomanpvt@gmail.com>
Date: Thu, 9 Jan 2020 15:03:01 +0530
Subject: [PATCH 16/19] Merge branches 'develop' and 'domain-onboarding-flag'
 of https://github.com/oppia/oppia-android into domain-onboarding-flag

# Conflicts:
#	app/src/main/java/org/oppia/app/splash/SplashActivity.kt
---
 app/src/main/java/org/oppia/app/fragment/FragmentComponent.kt   | 2 +-
 app/src/main/java/org/oppia/app/recyclerview/BindableAdapter.kt | 2 --
 2 files changed, 1 insertion(+), 3 deletions(-)

diff --git a/app/src/main/java/org/oppia/app/fragment/FragmentComponent.kt b/app/src/main/java/org/oppia/app/fragment/FragmentComponent.kt
index de23a24ebdd..136012b4ce3 100644
--- a/app/src/main/java/org/oppia/app/fragment/FragmentComponent.kt
+++ b/app/src/main/java/org/oppia/app/fragment/FragmentComponent.kt
@@ -13,8 +13,8 @@ import org.oppia.app.mydownloads.UpdatesTabFragment
 import org.oppia.app.player.audio.AudioFragment
 import org.oppia.app.player.exploration.ExplorationFragment
 import org.oppia.app.player.state.StateFragment
-import org.oppia.app.player.state.itemviewmodel.InteractionViewModelModule
 import org.oppia.app.profile.AdminSettingsDialogFragment
+import org.oppia.app.player.state.itemviewmodel.InteractionViewModelModule
 import org.oppia.app.profile.ProfileChooserFragment
 import org.oppia.app.profile.ResetPinDialogFragment
 import org.oppia.app.story.StoryFragment
diff --git a/app/src/main/java/org/oppia/app/recyclerview/BindableAdapter.kt b/app/src/main/java/org/oppia/app/recyclerview/BindableAdapter.kt
index 140b77d8e88..8efdd711f45 100644
--- a/app/src/main/java/org/oppia/app/recyclerview/BindableAdapter.kt
+++ b/app/src/main/java/org/oppia/app/recyclerview/BindableAdapter.kt
@@ -5,8 +5,6 @@ import android.view.View
 import android.view.ViewGroup
 import androidx.databinding.ViewDataBinding
 import androidx.recyclerview.widget.RecyclerView
-import org.oppia.app.recyclerview.BindableAdapter.MultiTypeBuilder.Companion.newBuilder
-import org.oppia.app.recyclerview.BindableAdapter.SingleTypeBuilder.Companion.newBuilder
 import kotlin.reflect.KClass
 
 /** A function that returns the integer-based type of view that can bind the specified data object. */

From 493d415992745ba30825226b3a9212f37fbf72b1 Mon Sep 17 00:00:00 2001
From: marysoloman <nikitamarysolomanpvt@gmail.com>
Date: Thu, 9 Jan 2020 20:34:29 +0530
Subject: [PATCH 17/19] nit as per review suggestions in renaming.

---
 app/src/main/AndroidManifest.xml                     |  2 +-
 .../java/org/oppia/app/activity/ActivityComponent.kt |  2 +-
 .../{onBoarding => onboarding}/OnBoardingActivity.kt |  5 ++---
 .../OnBoardingActivityPresenter.kt                   |  6 +++---
 .../main/java/org/oppia/app/splash/SplashActivity.kt |  1 -
 .../org/oppia/app/splash/SplashActivityPresenter.kt  | 12 ++++++------
 app/src/main/res/layout/on_boarding_activity.xml     |  2 +-
 .../java/org/oppia/app/splash/SplashActivityTest.kt  |  4 ++--
 .../org/oppia/domain/OnboardingFlowController.kt     | 12 ++++++------
 .../org/oppia/domain/OnboardingFlowControllerTest.kt |  6 +++---
 10 files changed, 25 insertions(+), 27 deletions(-)
 rename app/src/main/java/org/oppia/app/{onBoarding => onboarding}/OnBoardingActivity.kt (75%)
 rename app/src/main/java/org/oppia/app/{onBoarding => onboarding}/OnBoardingActivityPresenter.kt (84%)

diff --git a/app/src/main/AndroidManifest.xml b/app/src/main/AndroidManifest.xml
index 65047c10dc3..7c5560c02f4 100644
--- a/app/src/main/AndroidManifest.xml
+++ b/app/src/main/AndroidManifest.xml
@@ -30,7 +30,7 @@
       android:screenOrientation="portrait"
       android:theme="@style/OppiaThemeWithoutActionBar" />
     <activity
-      android:name=".onBoarding.OnBoardingActivity"
+      android:name=".onboarding.OnBoardingActivity"
       android:screenOrientation="portrait"
       android:theme="@style/OppiaThemeWithoutActionBar" />
     <activity
diff --git a/app/src/main/java/org/oppia/app/activity/ActivityComponent.kt b/app/src/main/java/org/oppia/app/activity/ActivityComponent.kt
index 0bc5a8760b7..2cac3744084 100644
--- a/app/src/main/java/org/oppia/app/activity/ActivityComponent.kt
+++ b/app/src/main/java/org/oppia/app/activity/ActivityComponent.kt
@@ -8,7 +8,7 @@ import org.oppia.app.help.HelpActivity
 import org.oppia.app.home.HomeActivity
 import org.oppia.app.home.continueplaying.ContinuePlayingActivity
 import org.oppia.app.mydownloads.MyDownloadsActivity
-import org.oppia.app.onBoarding.OnBoardingActivity
+import org.oppia.app.onboarding.OnBoardingActivity
 import org.oppia.app.player.exploration.ExplorationActivity
 import org.oppia.app.profile.AddProfileActivity
 import org.oppia.app.profile.AdminAuthActivity
diff --git a/app/src/main/java/org/oppia/app/onBoarding/OnBoardingActivity.kt b/app/src/main/java/org/oppia/app/onboarding/OnBoardingActivity.kt
similarity index 75%
rename from app/src/main/java/org/oppia/app/onBoarding/OnBoardingActivity.kt
rename to app/src/main/java/org/oppia/app/onboarding/OnBoardingActivity.kt
index 7b1328c9ae8..699eea45969 100644
--- a/app/src/main/java/org/oppia/app/onBoarding/OnBoardingActivity.kt
+++ b/app/src/main/java/org/oppia/app/onboarding/OnBoardingActivity.kt
@@ -1,11 +1,11 @@
-package org.oppia.app.onBoarding
+package org.oppia.app.onboarding
 
 import android.os.Bundle
 import org.oppia.app.activity.InjectableAppCompatActivity
 import org.oppia.app.profile.ProfileActivity
 import javax.inject.Inject
 
-/** An activity that shows a temporary OnBoardinging page until the app is onborarded then navigates to [ProfileActivity]. */
+/** An activity that shows a temporary on_boarding screen until the app is on-boarded then navigates to [ProfileActivity]. */
 class OnBoardingActivity : InjectableAppCompatActivity() {
 
   @Inject lateinit var onBoardingActivityPresenter: OnBoardingActivityPresenter
@@ -16,4 +16,3 @@ class OnBoardingActivity : InjectableAppCompatActivity() {
     onBoardingActivityPresenter.handleOnCreate()
   }
 }
-
diff --git a/app/src/main/java/org/oppia/app/onBoarding/OnBoardingActivityPresenter.kt b/app/src/main/java/org/oppia/app/onboarding/OnBoardingActivityPresenter.kt
similarity index 84%
rename from app/src/main/java/org/oppia/app/onBoarding/OnBoardingActivityPresenter.kt
rename to app/src/main/java/org/oppia/app/onboarding/OnBoardingActivityPresenter.kt
index 01becb24254..49d4ac24f03 100644
--- a/app/src/main/java/org/oppia/app/onBoarding/OnBoardingActivityPresenter.kt
+++ b/app/src/main/java/org/oppia/app/onboarding/OnBoardingActivityPresenter.kt
@@ -1,4 +1,4 @@
-package org.oppia.app.onBoarding
+package org.oppia.app.onboarding
 
 import android.content.Intent
 import androidx.appcompat.app.AppCompatActivity
@@ -9,7 +9,7 @@ import org.oppia.app.profile.ProfileActivity
 import org.oppia.domain.OnBoardingFlowController
 import javax.inject.Inject
 
-/** The presenter for [OnBoardingingActivity]. */
+/** The presenter for [OnBoardingActivity]. */
 @ActivityScope
 class OnBoardingActivityPresenter @Inject constructor(
   private val activity: AppCompatActivity,
@@ -18,7 +18,7 @@ class OnBoardingActivityPresenter @Inject constructor(
 
   fun handleOnCreate() {
     activity.setContentView(R.layout.on_boarding_activity)
-    activity.onBoard.setOnClickListener({ subscribeOnBoarding() })
+    activity.on_board.setOnClickListener { subscribeOnBoarding() }
   }
 
   private fun subscribeOnBoarding() {
diff --git a/app/src/main/java/org/oppia/app/splash/SplashActivity.kt b/app/src/main/java/org/oppia/app/splash/SplashActivity.kt
index b5a791785b2..5c3592714a8 100644
--- a/app/src/main/java/org/oppia/app/splash/SplashActivity.kt
+++ b/app/src/main/java/org/oppia/app/splash/SplashActivity.kt
@@ -2,7 +2,6 @@ package org.oppia.app.splash
 
 import android.os.Bundle
 import org.oppia.app.activity.InjectableAppCompatActivity
-import org.oppia.app.help.SplashActivityPresenter
 import org.oppia.app.profile.ProfileActivity
 import javax.inject.Inject
 
diff --git a/app/src/main/java/org/oppia/app/splash/SplashActivityPresenter.kt b/app/src/main/java/org/oppia/app/splash/SplashActivityPresenter.kt
index 833c07ab799..e8ce23d1f0d 100644
--- a/app/src/main/java/org/oppia/app/splash/SplashActivityPresenter.kt
+++ b/app/src/main/java/org/oppia/app/splash/SplashActivityPresenter.kt
@@ -1,4 +1,4 @@
-package org.oppia.app.help
+package org.oppia.app.splash
 
 import android.content.Intent
 import android.view.WindowManager
@@ -9,7 +9,7 @@ import androidx.lifecycle.Transformations
 import org.oppia.app.R
 import org.oppia.app.activity.ActivityScope
 import org.oppia.app.model.OnBoardingFlow
-import org.oppia.app.onBoarding.OnBoardingActivity
+import org.oppia.app.onboarding.OnBoardingActivity
 import org.oppia.app.profile.ProfileActivity
 import org.oppia.domain.OnBoardingFlowController
 import org.oppia.util.data.AsyncResult
@@ -22,7 +22,7 @@ class SplashActivityPresenter @Inject constructor(
   onBoardingFlowController: OnBoardingFlowController
 ) {
 
-  val onBoardingFlowData = onBoardingFlowController.getOnBoardingFlow()
+  private val onBoardingFlowData = onBoardingFlowController.getOnBoardingFlow()
 
   fun handleOnCreate() {
     activity.setContentView(R.layout.splash_activity)
@@ -53,9 +53,9 @@ class SplashActivityPresenter @Inject constructor(
     return Transformations.map(onBoardingFlowData, ::processOnBoardingFlowResult)
   }
 
-  private fun processOnBoardingFlowResult(onboardingResult: AsyncResult<OnBoardingFlow>): OnBoardingFlow {
-    if (onboardingResult.isFailure()) {
+  private fun processOnBoardingFlowResult(onBoardingResult: AsyncResult<OnBoardingFlow>): OnBoardingFlow {
+    if (onBoardingResult.isFailure()) {
     }
-    return onboardingResult.getOrDefault(OnBoardingFlow.getDefaultInstance())
+    return onBoardingResult.getOrDefault(OnBoardingFlow.getDefaultInstance())
   }
 }
diff --git a/app/src/main/res/layout/on_boarding_activity.xml b/app/src/main/res/layout/on_boarding_activity.xml
index f26641a5abc..031ce91cab2 100644
--- a/app/src/main/res/layout/on_boarding_activity.xml
+++ b/app/src/main/res/layout/on_boarding_activity.xml
@@ -6,7 +6,7 @@
   android:orientation="vertical">
 
   <Button
-    android:id="@+id/onBoard"
+    android:id="@+id/on_board"
     android:layout_width="wrap_content"
     android:layout_height="wrap_content"
     android:text="on-board" />
diff --git a/app/src/sharedTest/java/org/oppia/app/splash/SplashActivityTest.kt b/app/src/sharedTest/java/org/oppia/app/splash/SplashActivityTest.kt
index c96e69f5042..50b39e629f4 100644
--- a/app/src/sharedTest/java/org/oppia/app/splash/SplashActivityTest.kt
+++ b/app/src/sharedTest/java/org/oppia/app/splash/SplashActivityTest.kt
@@ -27,7 +27,7 @@ import org.junit.Before
 import org.junit.Rule
 import org.junit.Test
 import org.junit.runner.RunWith
-import org.oppia.app.onBoarding.OnBoardingActivity
+import org.oppia.app.onboarding.OnBoardingActivity
 import org.oppia.app.profile.ProfileActivity
 import org.oppia.domain.OnBoardingFlowController
 import org.oppia.util.logging.EnableConsoleLog
@@ -88,7 +88,7 @@ class SplashActivityTest {
   }
 
   private fun simulateAppAlreadyOnBoarded() {
-    // Simulate the app was already onboarded by creating an isolated on-boarding flow controller and saving the onboarding status
+    // Simulate the app was already on-boarded by creating an isolated on-boarding flow controller and saving the on-boarding status
     // on the system before the activity is opened.
     createTestRootComponent().getOnBoardingFlowController().markOnBoardingFlowCompleted()
     onIdle()
diff --git a/domain/src/main/java/org/oppia/domain/OnboardingFlowController.kt b/domain/src/main/java/org/oppia/domain/OnboardingFlowController.kt
index 34e6db7e1af..ec24a6db6c7 100644
--- a/domain/src/main/java/org/oppia/domain/OnboardingFlowController.kt
+++ b/domain/src/main/java/org/oppia/domain/OnboardingFlowController.kt
@@ -9,17 +9,17 @@ import org.oppia.util.logging.Logger
 import javax.inject.Inject
 import javax.inject.Singleton
 
-/** Controller for persisting and retrieving the user onBoarding information of the app. */
+/** Controller for persisting and retrieving the user on-boarding information of the app. */
 @Singleton
 class OnBoardingFlowController @Inject constructor(
   cacheStoreFactory: PersistentCacheStore.Factory,
   private val dataProviders: DataProviders,
   private val logger: Logger
 ) {
-  private val onBoardingFlowStore = cacheStoreFactory.create("onBoarding_flow", OnBoardingFlow.getDefaultInstance())
+  private val onBoardingFlowStore = cacheStoreFactory.create("on_boarding_flow", OnBoardingFlow.getDefaultInstance())
 
   init {
-    // Prime the cache ahead of time so that any existing history is read prior to any calls to markOnBoardingingFlowCompleted().
+    // Prime the cache ahead of time so that any existing history is read prior to any calls to markOnBoardingFlowCompleted().
     onBoardingFlowStore.primeCacheAsync().invokeOnCompletion {
       it?.let {
         logger.e("DOMAIN", "Failed to prime cache ahead of LiveData conversion for user on-boarding data.", it)
@@ -36,7 +36,7 @@ class OnBoardingFlowController @Inject constructor(
       it.toBuilder().setAlreadyOnBoardedApp(true).build()
     }.invokeOnCompletion {
       it?.let {
-        logger.e("DOMAIN", "Failed when storing that the user already onBoarded the app.", it)
+        logger.e("DOMAIN", "Failed when storing that the user already on-boarded the app.", it)
       }
     }
   }
@@ -51,8 +51,8 @@ class OnBoardingFlowController @Inject constructor(
   }
 
   /**
-   * Returns a [LiveData] result indicating whether the user has onBoarded the app. This is guaranteed to
-   * provide the state of the store upon the creation of this controller even if [markOnBoardingingFlowCompleted] has since been
+   * Returns a [LiveData] result indicating whether the user has on-boarded the app. This is guaranteed to
+   * provide the state of the store upon the creation of this controller even if [markOnBoardingFlowCompleted] has since been
    * called.
    */
   fun getOnBoardingFlow(): LiveData<AsyncResult<OnBoardingFlow>> {
diff --git a/domain/src/test/java/org/oppia/domain/OnboardingFlowControllerTest.kt b/domain/src/test/java/org/oppia/domain/OnboardingFlowControllerTest.kt
index c380a34fa2b..60f25b2557e 100644
--- a/domain/src/test/java/org/oppia/domain/OnboardingFlowControllerTest.kt
+++ b/domain/src/test/java/org/oppia/domain/OnboardingFlowControllerTest.kt
@@ -46,7 +46,7 @@ import javax.inject.Qualifier
 import javax.inject.Singleton
 import kotlin.coroutines.EmptyCoroutineContext
 
-/** Tests for [OnBoardingingFlowController]. */
+/** Tests for [OnBoardingFlowController]. */
 @RunWith(AndroidJUnit4::class)
 @Config(manifest = Config.NONE)
 class OnBoardingFlowControllerTest {
@@ -123,7 +123,7 @@ class OnBoardingFlowControllerTest {
       onBoardingFlowController.markOnBoardingFlowCompleted()
       advanceUntilIdle()
 
-      // The result should not indicate that the user onBoarded the app because markUserOnBoardedApp does not notify observers
+      // The result should not indicate that the user on-boarded the app because markUserOnBoardedApp does not notify observers
       // of the change.
       verify(mockOnBoardingObserver, atLeastOnce()).onChanged(onBoardingResultCaptor.capture())
       assertThat(onBoardingResultCaptor.value.isSuccess()).isTrue()
@@ -161,7 +161,7 @@ class OnBoardingFlowControllerTest {
     onBoarding.observeForever(mockOnBoardingObserver)
     advanceUntilIdle()
 
-    // The app should be considered not yet onBoarded since the previous history was cleared.
+    // The app should be considered not yet on-boarded since the previous history was cleared.
     verify(mockOnBoardingObserver, atLeastOnce()).onChanged(onBoardingResultCaptor.capture())
     assertThat(onBoardingResultCaptor.value.isSuccess()).isTrue()
     assertThat(onBoardingResultCaptor.value.getOrThrow().alreadyOnBoardedApp).isFalse()

From ea5122b208bd661144190bfc2f8de13d9dde77b3 Mon Sep 17 00:00:00 2001
From: marysoloman <nikitamarysolomanpvt@gmail.com>
Date: Thu, 9 Jan 2020 20:52:01 +0530
Subject: [PATCH 18/19] nit

---
 .../{OnboardingFlowController.kt => OnBoardingFlowController.kt}  | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename domain/src/main/java/org/oppia/domain/{OnboardingFlowController.kt => OnBoardingFlowController.kt} (100%)

diff --git a/domain/src/main/java/org/oppia/domain/OnboardingFlowController.kt b/domain/src/main/java/org/oppia/domain/OnBoardingFlowController.kt
similarity index 100%
rename from domain/src/main/java/org/oppia/domain/OnboardingFlowController.kt
rename to domain/src/main/java/org/oppia/domain/OnBoardingFlowController.kt

From 56d9091e6505f34a8c558cd07b78817dc19685a7 Mon Sep 17 00:00:00 2001
From: marysoloman <nikitamarysolomanpvt@gmail.com>
Date: Fri, 10 Jan 2020 11:11:24 +0530
Subject: [PATCH 19/19] nit

---
 .../main/java/org/oppia/app/onboarding/OnBoardingActivity.kt    | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/app/src/main/java/org/oppia/app/onboarding/OnBoardingActivity.kt b/app/src/main/java/org/oppia/app/onboarding/OnBoardingActivity.kt
index 699eea45969..ef11e1bc878 100644
--- a/app/src/main/java/org/oppia/app/onboarding/OnBoardingActivity.kt
+++ b/app/src/main/java/org/oppia/app/onboarding/OnBoardingActivity.kt
@@ -5,7 +5,7 @@ import org.oppia.app.activity.InjectableAppCompatActivity
 import org.oppia.app.profile.ProfileActivity
 import javax.inject.Inject
 
-/** An activity that shows a temporary on_boarding screen until the app is on-boarded then navigates to [ProfileActivity]. */
+/** An activity that shows a temporary on-boarding screen until the app is on-boarded then navigates to [ProfileActivity]. */
 class OnBoardingActivity : InjectableAppCompatActivity() {
 
   @Inject lateinit var onBoardingActivityPresenter: OnBoardingActivityPresenter