Merge pull request #4285 from element-hq/feature/bma/appConfig

Prepare application for being configurable

Author: bmarty

app/build.gradle.kts

@@ -10,6 +10,7 @@
 import com.android.build.api.variant.FilterConfiguration.FilterType.ABI
 import com.android.build.gradle.internal.tasks.factory.dependsOn
 import com.android.build.gradle.tasks.GenerateBuildConfig
+import config.BuildTimeConfig
 import extension.AssetCopyTask
 import extension.ComponentMergingStrategy
 import extension.GitBranchNameValueSource
@@ -43,11 +44,7 @@ android {
     namespace = "io.element.android.x"
 
     defaultConfig {
-        applicationId = if (isEnterpriseBuild) {
-            "io.element.enterprise"
-        } else {
-            "io.element.android.x"
-        }
+        applicationId = BuildTimeConfig.APPLICATION_ID
         targetSdk = Versions.TARGET_SDK
         versionCode = Versions.VERSION_CODE
         versionName = Versions.VERSION_NAME
@@ -97,11 +94,7 @@ android {
         }
     }
 
-    val baseAppName = if (isEnterpriseBuild) {
-        "Element Enterprise"
-    } else {
-        "Element X"
-    }
+    val baseAppName = BuildTimeConfig.APPLICATION_NAME
     logger.warnInBox("Building $baseAppName")
 
     buildTypes {

app/src/main/kotlin/io/element/android/x/di/AppModule.kt

@@ -73,23 +73,26 @@ object AppModule {
         @ApplicationContext context: Context,
         buildType: BuildType,
         enterpriseService: EnterpriseService,
-    ) = BuildMeta(
-        isDebuggable = BuildConfig.DEBUG,
-        buildType = buildType,
-        applicationName = ApplicationConfig.APPLICATION_NAME.takeIf { it.isNotEmpty() } ?: context.getString(R.string.app_name),
-        productionApplicationName = ApplicationConfig.PRODUCTION_APPLICATION_NAME,
-        desktopApplicationName = ApplicationConfig.DESKTOP_APPLICATION_NAME,
-        applicationId = BuildConfig.APPLICATION_ID,
-        isEnterpriseBuild = enterpriseService.isEnterpriseBuild,
-        // TODO EAx Config.LOW_PRIVACY_LOG_ENABLE,
-        lowPrivacyLoggingEnabled = false,
-        versionName = BuildConfig.VERSION_NAME,
-        versionCode = context.getVersionCodeFromManifest(),
-        gitRevision = BuildConfig.GIT_REVISION,
-        gitBranchName = BuildConfig.GIT_BRANCH_NAME,
-        flavorDescription = BuildConfig.FLAVOR_DESCRIPTION,
-        flavorShortDescription = BuildConfig.SHORT_FLAVOR_DESCRIPTION,
-    )
+    ): BuildMeta {
+        val applicationName = ApplicationConfig.APPLICATION_NAME.takeIf { it.isNotEmpty() } ?: context.getString(R.string.app_name)
+        return BuildMeta(
+            isDebuggable = BuildConfig.DEBUG,
+            buildType = buildType,
+            applicationName = applicationName,
+            productionApplicationName = if (enterpriseService.isEnterpriseBuild) applicationName else ApplicationConfig.PRODUCTION_APPLICATION_NAME,
+            desktopApplicationName = if (enterpriseService.isEnterpriseBuild) applicationName else ApplicationConfig.DESKTOP_APPLICATION_NAME,
+            applicationId = BuildConfig.APPLICATION_ID,
+            isEnterpriseBuild = enterpriseService.isEnterpriseBuild,
+            // TODO EAx Config.LOW_PRIVACY_LOG_ENABLE,
+            lowPrivacyLoggingEnabled = false,
+            versionName = BuildConfig.VERSION_NAME,
+            versionCode = context.getVersionCodeFromManifest(),
+            gitRevision = BuildConfig.GIT_REVISION,
+            gitBranchName = BuildConfig.GIT_BRANCH_NAME,
+            flavorDescription = BuildConfig.FLAVOR_DESCRIPTION,
+            flavorShortDescription = BuildConfig.SHORT_FLAVOR_DESCRIPTION,
+        )
+    }
 
     @Provides
     @SingleIn(AppScope::class)

appconfig/src/main/kotlin/io/element/android/appconfig/AuthenticationConfig.kt

@@ -10,11 +10,6 @@ package io.element.android.appconfig
 object AuthenticationConfig {
     const val MATRIX_ORG_URL = "https://matrix.org"
 
-    /**
-     * Default homeserver url to sign in with, unless the user selects a different one.
-     */
-    const val DEFAULT_HOMESERVER_URL = MATRIX_ORG_URL
-
     /**
      * URL with some docs that explain what's sliding sync and how to add it to your home server.
      */

enterprise

@@ -13,6 +13,7 @@ import io.element.android.libraries.matrix.api.core.SessionId
 interface EnterpriseService {
     val isEnterpriseBuild: Boolean
     suspend fun isEnterpriseUser(sessionId: SessionId): Boolean
+    fun defaultHomeserver(): String?
 
     fun semanticColorsLight(): SemanticColors
     fun semanticColorsDark(): SemanticColors

features/enterprise/api/src/main/kotlin/io/element/android/features/enterprise/api/EnterpriseService.kt

@@ -22,6 +22,8 @@ class DefaultEnterpriseService @Inject constructor() : EnterpriseService {
 
     override suspend fun isEnterpriseUser(sessionId: SessionId) = false
 
+    override fun defaultHomeserver() = null
+
     override fun semanticColorsLight(): SemanticColors = compoundColorsLight
 
     override fun semanticColorsDark(): SemanticColors = compoundColorsDark

features/enterprise/impl/src/main/kotlin/io/element/android/features/enterprise/impl/DefaultEnterpriseService.kt

@@ -19,6 +19,12 @@ class DefaultEnterpriseServiceTest {
         assertThat(defaultEnterpriseService.isEnterpriseBuild).isFalse()
     }
 
+    @Test
+    fun `defaultHomeserver should return null`() {
+        val defaultEnterpriseService = DefaultEnterpriseService()
+        assertThat<String?>(defaultEnterpriseService.defaultHomeserver()).isNull()
+    }
+
     @Test
     fun `isEnterpriseUser always return false`() = runTest {
         val defaultEnterpriseService = DefaultEnterpriseService()

features/enterprise/impl/src/test/kotlin/io/element/android/features/enterprise/impl/DefaultEnterpriseServiceTest.kt

@@ -0,0 +1,20 @@
+/*
+ * Copyright 2025 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
+ * Please see LICENSE files in the repository root for full details.
+ */
+plugins {
+    id("io.element.android-library")
+}
+
+android {
+    namespace = "io.element.android.features.enterprise.test"
+}
+
+dependencies {
+    api(projects.features.enterprise.api)
+    implementation(libs.compound)
+    implementation(projects.libraries.matrix.api)
+    implementation(projects.tests.testutils)
+}

features/enterprise/test/build.gradle.kts

@@ -0,0 +1,42 @@
+/*
+ * Copyright 2025 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.features.enterprise.test
+
+import io.element.android.compound.tokens.generated.SemanticColors
+import io.element.android.features.enterprise.api.EnterpriseService
+import io.element.android.libraries.matrix.api.core.SessionId
+import io.element.android.tests.testutils.lambda.lambdaError
+import io.element.android.tests.testutils.simulateLongTask
+
+class FakeEnterpriseService(
+    override val isEnterpriseBuild: Boolean = false,
+    private val isEnterpriseUserResult: (SessionId) -> Boolean = { lambdaError() },
+    private val defaultHomeserverResult: () -> String? = { A_FAKE_HOMESERVER },
+    private val semanticColorsLightResult: () -> SemanticColors = { lambdaError() },
+    private val semanticColorsDarkResult: () -> SemanticColors = { lambdaError() },
+) : EnterpriseService {
+    override suspend fun isEnterpriseUser(sessionId: SessionId): Boolean = simulateLongTask {
+        isEnterpriseUserResult(sessionId)
+    }
+
+    override fun defaultHomeserver(): String? {
+        return defaultHomeserverResult()
+    }
+
+    override fun semanticColorsLight(): SemanticColors {
+        return semanticColorsLightResult()
+    }
+
+    override fun semanticColorsDark(): SemanticColors {
+        return semanticColorsDarkResult()
+    }
+
+    companion object {
+        const val A_FAKE_HOMESERVER = "a_fake_homeserver"
+    }
+}

features/enterprise/test/src/main/kotlin/io/element/android/features/enterprise/test/FakeEnterpriseService.kt

@@ -28,6 +28,7 @@ setupAnvil(componentMergingStrategy = ComponentMergingStrategy.KSP)
 
 dependencies {
     implementation(projects.appconfig)
+    implementation(projects.features.enterprise.api)
     implementation(projects.libraries.core)
     implementation(projects.libraries.androidutils)
     implementation(projects.libraries.architecture)
@@ -55,6 +56,7 @@ dependencies {
     testImplementation(libs.test.robolectric)
     testImplementation(libs.test.truth)
     testImplementation(libs.test.turbine)
+    testImplementation(projects.features.enterprise.test)
     testImplementation(projects.libraries.matrix.test)
     testImplementation(projects.libraries.oidc.impl)
     testImplementation(projects.libraries.permissions.test)

features/login/impl/build.gradle.kts

@@ -7,7 +7,8 @@
 
 package io.element.android.features.login.impl.accountprovider
 
-import io.element.android.features.login.impl.util.defaultAccountProvider
+import io.element.android.appconfig.AuthenticationConfig
+import io.element.android.features.enterprise.api.EnterpriseService
 import io.element.android.libraries.di.AppScope
 import io.element.android.libraries.di.SingleIn
 import kotlinx.coroutines.flow.MutableStateFlow
@@ -16,7 +17,18 @@ import kotlinx.coroutines.flow.asStateFlow
 import javax.inject.Inject
 
 @SingleIn(AppScope::class)
-class AccountProviderDataSource @Inject constructor() {
+class AccountProviderDataSource @Inject constructor(
+    enterpriseService: EnterpriseService,
+) {
+    private val defaultAccountProvider = (enterpriseService.defaultHomeserver() ?: AuthenticationConfig.MATRIX_ORG_URL).let { url ->
+        AccountProvider(
+            url = url,
+            subtitle = null,
+            isPublic = url == AuthenticationConfig.MATRIX_ORG_URL,
+            isMatrixOrg = url == AuthenticationConfig.MATRIX_ORG_URL,
+        )
+    }
+
     private val accountProvider: MutableStateFlow<AccountProvider> = MutableStateFlow(
         defaultAccountProvider
     )

features/login/impl/src/main/kotlin/io/element/android/features/login/impl/accountprovider/AccountProviderDataSource.kt

@@ -0,0 +1,84 @@
+/*
+ * Copyright 2025 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.features.login.impl.accountprovider
+
+import app.cash.turbine.test
+import com.google.common.truth.Truth.assertThat
+import io.element.android.appconfig.AuthenticationConfig
+import io.element.android.features.enterprise.test.FakeEnterpriseService
+import io.element.android.tests.testutils.WarmUpRule
+import kotlinx.coroutines.test.runTest
+import org.junit.Rule
+import org.junit.Test
+
+class AccountProviderDataSourceTest {
+    @get:Rule
+    val warmUpRule = WarmUpRule()
+
+    @Test
+    fun `present - initial state`() = runTest {
+        val sut = AccountProviderDataSource(FakeEnterpriseService())
+        sut.flow().test {
+            val initialState = awaitItem()
+            assertThat(initialState).isEqualTo(
+                AccountProvider(
+                    url = FakeEnterpriseService.A_FAKE_HOMESERVER,
+                    title = FakeEnterpriseService.A_FAKE_HOMESERVER,
+                    subtitle = null,
+                    isPublic = false,
+                    isMatrixOrg = false,
+                    isValid = false,
+                )
+            )
+        }
+    }
+
+    @Test
+    fun `present - initial state - matrix org`() = runTest {
+        val sut = AccountProviderDataSource(FakeEnterpriseService(
+            defaultHomeserverResult = { AuthenticationConfig.MATRIX_ORG_URL }
+        ))
+        sut.flow().test {
+            val initialState = awaitItem()
+            assertThat(initialState).isEqualTo(
+                AccountProvider(
+                    url = AuthenticationConfig.MATRIX_ORG_URL,
+                    title = "matrix.org",
+                    subtitle = null,
+                    isPublic = true,
+                    isMatrixOrg = true,
+                    isValid = false,
+                )
+            )
+        }
+    }
+
+    @Test
+    fun `present - user change and reset`() = runTest {
+        val sut = AccountProviderDataSource(FakeEnterpriseService())
+        sut.flow().test {
+            val initialState = awaitItem()
+            assertThat(initialState.url).isEqualTo(FakeEnterpriseService.A_FAKE_HOMESERVER)
+            sut.userSelection(AccountProvider(url = "https://example.com"))
+            val changedState = awaitItem()
+            assertThat(changedState).isEqualTo(
+                AccountProvider(
+                    url = "https://example.com",
+                    title = "example.com",
+                    subtitle = null,
+                    isPublic = false,
+                    isMatrixOrg = false,
+                    isValid = false,
+                )
+            )
+            sut.reset()
+            val resetState = awaitItem()
+            assertThat(resetState.url).isEqualTo(FakeEnterpriseService.A_FAKE_HOMESERVER)
+        }
+    }
+}