Fix #5093: Fix start-up crash on SDK versions <24

app/src/sharedTest/java/org/oppia/android/app/parser/HtmlParserTest.kt

@@ -852,8 +852,10 @@ class HtmlParserTest {
     }
   }
 
-  private fun createDisplayLocaleImpl(context: OppiaLocaleContext): DisplayLocaleImpl =
-    DisplayLocaleImpl(context, machineLocale, androidLocaleFactory, formatterFactory)
+  private fun createDisplayLocaleImpl(context: OppiaLocaleContext): DisplayLocaleImpl {
+    val formattingLocale = androidLocaleFactory.createOneOffAndroidLocale(context)
+    return DisplayLocaleImpl(context, formattingLocale, machineLocale, formatterFactory)
+  }
 
   private fun <A : Activity> ActivityScenario<A>.getDimensionPixelSize(
     @DimenRes dimenResId: Int

app/src/test/java/org/oppia/android/app/parser/ListItemLeadingMarginSpanTest.kt

@@ -1044,8 +1044,10 @@ class ListItemLeadingMarginSpanTest {
     return valueCaptor.value
   }
 
-  private fun createDisplayLocaleImpl(context: OppiaLocaleContext): DisplayLocaleImpl =
-    DisplayLocaleImpl(context, machineLocale, androidLocaleFactory, formatterFactory)
+  private fun createDisplayLocaleImpl(context: OppiaLocaleContext): DisplayLocaleImpl {
+    val formattingLocale = androidLocaleFactory.createOneOffAndroidLocale(context)
+    return DisplayLocaleImpl(context, formattingLocale, machineLocale, formatterFactory)
+  }
 
   private fun setUpTestApplicationComponent() {
     ApplicationProvider.getApplicationContext<TestApplication>().inject(this)

domain/src/main/java/org/oppia/android/domain/locale/LocaleController.kt

@@ -62,7 +62,8 @@ class LocaleController @Inject constructor(
   private val asyncDataSubscriptionManager: AsyncDataSubscriptionManager,
   private val machineLocale: MachineLocale,
   private val androidLocaleFactory: AndroidLocaleFactory,
-  private val formatterFactory: OppiaBidiFormatter.Factory
+  private val formatterFactory: OppiaBidiFormatter.Factory,
+  private val androidLocaleProfileFactory: AndroidLocaleProfile.Factory
 ) {
   private val definitionsLock = ReentrantLock()
   private lateinit var supportedLanguages: SupportedLanguages
@@ -115,9 +116,8 @@ class LocaleController @Inject constructor(
    * for cases in which the user changed their selected language).
    */
   fun reconstituteDisplayLocale(oppiaLocaleContext: OppiaLocaleContext): DisplayLocale {
-    return DisplayLocaleImpl(
-      oppiaLocaleContext, machineLocale, androidLocaleFactory, formatterFactory
-    )
+    val formattingLocale = androidLocaleFactory.createOneOffAndroidLocale(oppiaLocaleContext)
+    return DisplayLocaleImpl(oppiaLocaleContext, formattingLocale, machineLocale, formatterFactory)
   }
 
   /**
@@ -257,7 +257,7 @@ class LocaleController @Inject constructor(
 
   private fun getSystemLocaleProfile(): DataProvider<AndroidLocaleProfile> {
     return dataProviders.createInMemoryDataProvider(ANDROID_SYSTEM_LOCALE_DATA_PROVIDER_ID) {
-      AndroidLocaleProfile.createFrom(getSystemLocale())
+      androidLocaleProfileFactory.createFrom(getSystemLocale())
     }
   }
 
@@ -293,7 +293,7 @@ class LocaleController @Inject constructor(
   @Suppress("DEPRECATION") // Old API is needed for SDK versions < N.
   private fun getDefaultLocale(configuration: Configuration): Locale = configuration.locale
 
-  private suspend fun <T : OppiaLocale> computeLocaleResult(
+  private suspend inline fun <reified T : OppiaLocale> computeLocaleResult(
     language: OppiaLanguage,
     systemLocaleProfile: AndroidLocaleProfile,
     usageMode: LanguageUsageMode
@@ -302,7 +302,6 @@ class LocaleController @Inject constructor(
     // internal weirdness that would lead to a wrong type being produced from the generic helpers.
     // This shouldn't actually ever happen in practice, but this code gracefully fails to a null
     // (and thus a failure).
-    @Suppress("UNCHECKED_CAST") // as? should always be a safe cast, even if unchecked.
     val locale = computeLocale(language, systemLocaleProfile, usageMode) as? T
     return locale?.let {
       AsyncResult.Success(it)
@@ -324,7 +323,13 @@ class LocaleController @Inject constructor(
       retrieveLanguageDefinition(languageDefinition.fallbackMacroLanguage)?.let {
         fallbackLanguageDefinition = it
       }
-      regionDefinition = retrieveRegionDefinition(systemLocaleProfile.regionCode)
+      val regionCode = when (systemLocaleProfile) {
+        is AndroidLocaleProfile.LanguageAndRegionProfile -> systemLocaleProfile.regionCode
+        is AndroidLocaleProfile.RegionOnlyProfile -> systemLocaleProfile.regionCode
+        is AndroidLocaleProfile.LanguageAndWildcardRegionProfile,
+        is AndroidLocaleProfile.LanguageOnlyProfile, is AndroidLocaleProfile.RootProfile -> ""
+      }
+      regionDefinition = retrieveRegionDefinition(regionCode)
       this.usageMode = usageMode
     }.build()
 
@@ -343,8 +348,10 @@ class LocaleController @Inject constructor(
     }
 
     return when (usageMode) {
-      APP_STRINGS ->
-        DisplayLocaleImpl(localeContext, machineLocale, androidLocaleFactory, formatterFactory)
+      APP_STRINGS -> {
+        val formattingLocale = androidLocaleFactory.createAndroidLocaleAsync(localeContext).await()
+        DisplayLocaleImpl(localeContext, formattingLocale, machineLocale, formatterFactory)
+      }
       CONTENT_STRINGS, AUDIO_TRANSLATIONS -> ContentLocaleImpl(localeContext)
       USAGE_MODE_UNSPECIFIED, UNRECOGNIZED -> null
     }
@@ -413,9 +420,7 @@ class LocaleController @Inject constructor(
       return@mapNotNull definition.retrieveAppLanguageProfile()?.let { profile ->
         profile to definition
       }
-    }.find { (profile, _) ->
-      localeProfile.matches(machineLocale, profile)
-    }?.let { (_, definition) -> definition }
+    }.find { (profile, _) -> localeProfile.matches(profile) }?.let { (_, definition) -> definition }
   }
 
   private suspend fun retrieveRegionDefinition(countryCode: String): RegionSupportDefinition {
@@ -431,7 +436,7 @@ class LocaleController @Inject constructor(
     } ?: RegionSupportDefinition.newBuilder().apply {
       region = OppiaRegion.REGION_UNSPECIFIED
       regionId = RegionSupportDefinition.IetfBcp47RegionId.newBuilder().apply {
-        ietfRegionTag = countryCode
+        ietfRegionTag = machineLocale.run { countryCode.toMachineUpperCase() }
       }.build()
     }.build()
   }
@@ -455,10 +460,10 @@ class LocaleController @Inject constructor(
   private fun LanguageSupportDefinition.retrieveAppLanguageProfile(): AndroidLocaleProfile? {
     return when (appStringId.languageTypeCase) {
       LanguageSupportDefinition.LanguageId.LanguageTypeCase.IETF_BCP47_ID ->
-        AndroidLocaleProfile.createFromIetfDefinitions(appStringId, regionDefinition = null)
+        androidLocaleProfileFactory.createFromIetfDefinitions(appStringId, regionDefinition = null)
       LanguageSupportDefinition.LanguageId.LanguageTypeCase.MACARONIC_ID -> {
         // Likely won't match against system languages.
-        AndroidLocaleProfile.createFromMacaronicLanguage(appStringId)
+        androidLocaleProfileFactory.createFromMacaronicLanguage(appStringId)
       }
       LanguageSupportDefinition.LanguageId.LanguageTypeCase.LANGUAGETYPE_NOT_SET, null -> null
     }
@@ -473,9 +478,12 @@ class LocaleController @Inject constructor(
     // must be part of the language definitions. Support for app strings is exposed so that a locale
     // can be constructed from it.
     appStringId = LanguageSupportDefinition.LanguageId.newBuilder().apply {
-      ietfBcp47Id = LanguageSupportDefinition.IetfBcp47LanguageId.newBuilder().apply {
-        ietfLanguageTag = systemLocaleProfile.computeIetfLanguageTag()
-      }.build()
+      // The root profile is assumed if there is no specific language ID to use.
+      if (systemLocaleProfile !is AndroidLocaleProfile.RootProfile) {
+        ietfBcp47Id = LanguageSupportDefinition.IetfBcp47LanguageId.newBuilder().apply {
+          ietfLanguageTag = systemLocaleProfile.ietfLanguageTag
+        }.build()
+      }
     }.build()
   }.build()
 

domain/src/test/java/org/oppia/android/domain/locale/LocaleControllerTest.kt

@@ -114,12 +114,16 @@ class LocaleControllerTest {
   }
 
   @Test
-  fun testReconstituteDisplayLocale_defaultContext_returnsDisplayLocaleForContext() {
+  fun testReconstituteDisplayLocale_defaultContext_throwsException() {
     val context = OppiaLocaleContext.getDefaultInstance()
 
-    val locale = localeController.reconstituteDisplayLocale(context)
+    val exception = assertThrows<IllegalStateException>() {
+      localeController.reconstituteDisplayLocale(context)
+    }
 
-    assertThat(locale.localeContext).isEqualToDefaultInstance()
+    // A default locale context isn't valid by itself (though it can represent the root locale when
+    // at least the app strings context is present & default).
+    assertThat(exception).hasMessageThat().contains("Invalid language case")
   }
 
   @Test
@@ -243,6 +247,25 @@ class LocaleControllerTest {
     assertThat(context.regionDefinition.regionId.ietfRegionTag).isEqualTo("MC")
   }
 
+  @Test
+  fun testAppStringLocale_rootLocale_defaultLang_returnsRootLocale() {
+    forceDefaultLocale(Locale.ROOT)
+
+    val localeProvider = localeController.retrieveAppStringDisplayLocale(LANGUAGE_UNSPECIFIED)
+
+    // The locale will be forced to the root locale. The root locale also should never provide an
+    // IETF BCP-47 ID.
+    val locale = monitorFactory.waitForNextSuccessfulResult(localeProvider)
+    val context = locale.localeContext
+    val languageDefinition = context.languageDefinition
+    assertThat(languageDefinition.language).isEqualTo(LANGUAGE_UNSPECIFIED)
+    assertThat(languageDefinition.fallbackMacroLanguage).isEqualTo(LANGUAGE_UNSPECIFIED)
+    assertThat(languageDefinition.appStringId.hasIetfBcp47Id()).isFalse()
+    assertThat(context.hasFallbackLanguageDefinition()).isFalse()
+    assertThat(context.regionDefinition.region).isEqualTo(REGION_UNSPECIFIED)
+    assertThat(context.regionDefinition.regionId.ietfRegionTag).isEmpty()
+  }
+
   @Test
   fun testAppStringLocale_newSystemLocale_doesNotNotifyProvider() {
     forceDefaultLocale(Locale.US)

domain/src/test/java/org/oppia/android/domain/translation/TranslationControllerTest.kt

@@ -19,6 +19,7 @@ import org.oppia.android.app.model.AppLanguageSelection.SelectionTypeCase.USE_SY
 import org.oppia.android.app.model.AudioTranslationLanguageSelection
 import org.oppia.android.app.model.HtmlTranslationList
 import org.oppia.android.app.model.LanguageSupportDefinition.LanguageId.LanguageTypeCase.IETF_BCP47_ID
+import org.oppia.android.app.model.LanguageSupportDefinition.LanguageId.LanguageTypeCase.LANGUAGETYPE_NOT_SET
 import org.oppia.android.app.model.OppiaLanguage
 import org.oppia.android.app.model.OppiaLanguage.ARABIC
 import org.oppia.android.app.model.OppiaLanguage.BRAZILIAN_PORTUGUESE
@@ -112,9 +113,7 @@ class TranslationControllerTest {
     val appStringId = context.languageDefinition.appStringId
     assertThat(context.usageMode).isEqualTo(APP_STRINGS)
     assertThat(context.languageDefinition.language).isEqualTo(LANGUAGE_UNSPECIFIED)
-    assertThat(appStringId.languageTypeCase).isEqualTo(IETF_BCP47_ID)
-    assertThat(appStringId.ietfBcp47Id.ietfLanguageTag).isEmpty()
-    assertThat(appStringId.androidResourcesLanguageId.languageCode).isEmpty()
+    assertThat(appStringId.languageTypeCase).isEqualTo(LANGUAGETYPE_NOT_SET)
     assertThat(context.regionDefinition.region).isEqualTo(REGION_UNSPECIFIED)
   }
 
@@ -290,12 +289,28 @@ class TranslationControllerTest {
     val appStringId = context.languageDefinition.appStringId
     assertThat(context.usageMode).isEqualTo(APP_STRINGS)
     assertThat(context.languageDefinition.language).isEqualTo(LANGUAGE_UNSPECIFIED)
-    assertThat(appStringId.languageTypeCase).isEqualTo(IETF_BCP47_ID)
-    assertThat(appStringId.ietfBcp47Id.ietfLanguageTag).isEmpty()
-    assertThat(appStringId.androidResourcesLanguageId.languageCode).isEmpty()
+    assertThat(appStringId.languageTypeCase).isEqualTo(LANGUAGETYPE_NOT_SET)
     assertThat(context.regionDefinition.region).isEqualTo(REGION_UNSPECIFIED)
   }
 
+  @Test
+  fun testGetAppLanguageLocale_ptBrDefLocale_returnsLocaleWithIetfAndAndroidResourcesLangIds() {
+    forceDefaultLocale(BRAZIL_PORTUGUESE_LOCALE)
+
+    val localeProvider = translationController.getAppLanguageLocale(PROFILE_ID_0)
+
+    val locale = monitorFactory.waitForNextSuccessfulResult(localeProvider)
+    val context = locale.localeContext
+    val appStringId = context.languageDefinition.appStringId
+    assertThat(context.usageMode).isEqualTo(APP_STRINGS)
+    assertThat(context.languageDefinition.language).isEqualTo(BRAZILIAN_PORTUGUESE)
+    assertThat(appStringId.languageTypeCase).isEqualTo(IETF_BCP47_ID)
+    assertThat(appStringId.ietfBcp47Id.ietfLanguageTag).isEqualTo("pt-BR")
+    assertThat(appStringId.androidResourcesLanguageId.languageCode).isEqualTo("pt")
+    assertThat(appStringId.androidResourcesLanguageId.regionCode).isEqualTo("BR")
+    assertThat(context.regionDefinition.region).isEqualTo(BRAZIL)
+  }
+
   @Test
   fun testGetAppLanguageLocale_updateLanguageToEnglish_returnsEnglishLocale() {
     forceDefaultLocale(Locale.ROOT)
@@ -1937,6 +1952,7 @@ class TranslationControllerTest {
 
   private companion object {
     private val BRAZIL_ENGLISH_LOCALE = Locale("en", "BR")
+    private val BRAZIL_PORTUGUESE_LOCALE = Locale("pt", "BR")
     private val INDIA_HINDI_LOCALE = Locale("hi", "IN")
     private val KENYA_KISWAHILI_LOCALE = Locale("sw", "KE")
 

scripts/assets/file_content_validation_checks.textproto

@@ -598,3 +598,10 @@ file_content_checks {
   exempted_file_name: "scripts/src/javatests/org/oppia/android/scripts/regex/RegexPatternValidationCheckTest.kt"
   exempted_file_name: "testing/src/test/java/org/oppia/android/testing/espresso/TextInputActionTest.kt"
 }
+file_content_checks {
+  file_path_regex: ".+?\\.kt"
+  prohibited_content_regex: "computeIfAbsent\\("
+  failure_message: "computeIfAbsent won't desugar and requires Java 8 support (SDK 24+). Suggest using an atomic Kotlin-specific solution, instead."
+  exempted_file_name: "scripts/src/javatests/org/oppia/android/scripts/regex/RegexPatternValidationCheckTest.kt"
+  exempted_file_name: "utility/src/main/java/org/oppia/android/util/caching/testing/FakeAssetRepository.kt"
+}

scripts/src/javatests/org/oppia/android/scripts/regex/RegexPatternValidationCheckTest.kt

@@ -218,6 +218,9 @@ class RegexPatternValidationCheckTest {
     "ActivityScenarioRule can result in order dependence when static state leaks across tests" +
       " (such as static module variables), and can make staging much more difficult for platform" +
       " parameters. Use ActivityScenario directly, instead."
+  private val referenceComputeIfAbsent =
+    "computeIfAbsent won't desugar and requires Java 8 support (SDK 24+). Suggest using an atomic" +
+      " Kotlin-specific solution, instead."
   private val wikiReferenceNote =
     "Refer to https://github.com/oppia/oppia-android/wiki/Static-Analysis-Checks" +
       "#regexpatternvalidation-check for more details on how to fix this."
@@ -2728,6 +2731,28 @@ class RegexPatternValidationCheckTest {
       )
   }
 
+  @Test
+  fun testFileContent_includesReferenceToComputeIfAbsent_fileContentIsNotCorrect() {
+    val prohibitedContent =
+      """
+        someMap.computeIfAbsent(key) { createOtherValue() }
+      """.trimIndent()
+    tempFolder.newFolder("testfiles", "app", "src", "main", "java", "org", "oppia", "android")
+    val stringFilePath = "app/src/main/java/org/oppia/android/TestPresenter.kt"
+    tempFolder.newFile("testfiles/$stringFilePath").writeText(prohibitedContent)
+
+    val exception = assertThrows<Exception>() { runScript() }
+
+    assertThat(exception).hasMessageThat().contains(REGEX_CHECK_FAILED_OUTPUT_INDICATOR)
+    assertThat(outContent.toString().trim())
+      .isEqualTo(
+        """
+        $stringFilePath:1: $referenceComputeIfAbsent
+        $wikiReferenceNote
+        """.trimIndent()
+      )
+  }
+
   /** Runs the regex_pattern_validation_check. */
   private fun runScript() {
     main(File(tempFolder.root, "testfiles").absolutePath)

utility/src/main/java/org/oppia/android/util/data/DataProviders.kt

@@ -11,6 +11,7 @@ import kotlinx.coroutines.flow.launchIn
 import kotlinx.coroutines.flow.onEach
 import kotlinx.coroutines.flow.transform
 import kotlinx.coroutines.launch
+import org.oppia.android.util.data.DataProviders.Companion.transform
 import org.oppia.android.util.logging.ExceptionLogger
 import org.oppia.android.util.threading.BackgroundDispatcher
 import java.util.concurrent.atomic.AtomicBoolean
@@ -74,7 +75,12 @@ class DataProviders @Inject constructor(
         override fun getId(): Any = newId
 
         override suspend fun retrieveData(): AsyncResult<O> {
-          return [email protected]().transformAsync(function)
+          return try {
+            [email protected]().transformAsync(function)
+          } catch (e: Exception) {
+            dataProviders.exceptionLogger.logException(e)
+            AsyncResult.Failure(e)
+          }
         }
       }
     }