feat(new-registration): add flows anonymous usage data (WPB-17529)

app/src/main/kotlin/com/wire/android/WireApplication.kt

@@ -230,6 +230,7 @@ class WireApplication : BaseApp() {
                 coreLogic.get().getSessionScope(userId).analyticsIdentifierManager
             },
             userDataStoreProvider = userDataStoreProvider.get(),
+            globalDataStore = globalDataStore.get(),
             currentBackend = { userId ->
                 coreLogic.get().getSessionScope(userId).users.serverLinks()
             }

app/src/main/kotlin/com/wire/android/analytics/FinalizeRegistrationAnalyticsMetadataUseCase.kt

@@ -0,0 +1,47 @@
+/*
+ * Wire
+ * Copyright (C) 2025 Wire Swiss GmbH
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see http://www.gnu.org/licenses/.
+ */
+package com.wire.android.analytics
+
+import com.wire.android.datastore.GlobalDataStore
+import com.wire.android.di.CurrentAccount
+import com.wire.android.di.KaliumCoreLogic
+import com.wire.kalium.logic.CoreLogic
+import com.wire.kalium.logic.data.user.UserId
+import kotlinx.coroutines.flow.firstOrNull
+import javax.inject.Inject
+
+/**
+ * Finalize the registration process and analytics metadata in case there was enabled in the process.
+ * Transfers the identifier to the logged in user and clean up the registration process.
+ */
+class FinalizeRegistrationAnalyticsMetadataUseCase @Inject constructor(
+    private val globalDataStore: GlobalDataStore,
+    @CurrentAccount private val currentAccount: UserId,
+    @KaliumCoreLogic private val coreLogic: CoreLogic
+) {
+    suspend operator fun invoke() {
+        if (globalDataStore.isAnonymousRegistrationEnabled().firstOrNull() == false) return
+
+        val trackId = globalDataStore.getAnonymousRegistrationTrackId()
+        if (!trackId.isNullOrBlank()) {
+            coreLogic.getSessionScope(currentAccount).setNewUserTrackingIdentifier(trackId)
+            globalDataStore.clearAnonymousRegistrationTrackId()
+            globalDataStore.setAnonymousRegistrationEnabled(false)
+        }
+    }
+}

app/src/main/kotlin/com/wire/android/analytics/ObserveCurrentSessionAnalyticsUseCase.kt

@@ -17,10 +17,11 @@
  */
 package com.wire.android.analytics
 
+import com.wire.android.datastore.GlobalDataStore
 import com.wire.android.datastore.UserDataStoreProvider
 import com.wire.android.feature.analytics.model.AnalyticsProfileProperties
 import com.wire.android.feature.analytics.model.AnalyticsResult
-import com.wire.kalium.logic.configuration.server.ServerConfig
+import com.wire.android.util.isHostValidForAnalytics
 import com.wire.kalium.logic.data.analytics.AnalyticsIdentifierResult
 import com.wire.kalium.logic.data.user.UserId
 import com.wire.kalium.logic.feature.analytics.AnalyticsContactsData
@@ -53,18 +54,42 @@ fun ObserveCurrentSessionAnalyticsUseCase(
     observeAnalyticsTrackingIdentifierStatusFlow: suspend (UserId) -> Flow<AnalyticsIdentifierResult>,
     analyticsIdentifierManagerProvider: (UserId) -> AnalyticsIdentifierManager,
     userDataStoreProvider: UserDataStoreProvider,
+    globalDataStore: GlobalDataStore,
     currentBackend: suspend (UserId) -> SelfServerConfigUseCase.Result
 ) = object : ObserveCurrentSessionAnalyticsUseCase {
 
     private var previousAnalyticsResult: AnalyticsIdentifierResult? = null
 
     @Suppress("LongMethod")
-    override fun invoke(): Flow<AnalyticsResult<AnalyticsIdentifierManager>> = currentSessionFlow
-        .flatMapLatest {
-            if (it is CurrentSessionResult.Success && it.accountInfo.isValid()) {
-                val userId = it.accountInfo.userId
-                val analyticsIdentifierManager = analyticsIdentifierManagerProvider(userId)
+    override fun invoke(): Flow<AnalyticsResult<AnalyticsIdentifierManager>> {
+        return combine(
+            currentSessionFlow,
+            globalDataStore.isAnonymousRegistrationEnabled()
+        ) { currentSession, isAnonymousRegistrationEnabled ->
+            currentSession to isAnonymousRegistrationEnabled
+        }.flatMapLatest { (currentSession, isAnonymousRegistrationEnabled) ->
+            if (isAnonymousRegistrationEnabled) {
+                val anonymousRegistrationTrackId = globalDataStore.getOrCreateAnonymousRegistrationTrackId()
+                return@flatMapLatest flowOf(
+                    AnalyticsResult<AnalyticsIdentifierManager>(
+                        identifierResult = AnalyticsIdentifierResult.RegistrationIdentifier(anonymousRegistrationTrackId),
+                        profileProperties = {
+                            AnalyticsProfileProperties(
+                                isTeamMember = false,
+                                teamId = null,
+                                contactsAmount = null,
+                                teamMembersAmount = null,
+                                isEnterprise = null
+                            )
+                        },
+                        manager = null
+                    )
+                )
+            }
 
+            if (currentSession is CurrentSessionResult.Success && currentSession.accountInfo.isValid()) {
+                val userId = currentSession.accountInfo.userId
+                val analyticsIdentifierManager = analyticsIdentifierManagerProvider(userId)
                 combine(
                     observeAnalyticsTrackingIdentifierStatusFlow(userId)
                         .filter { currentIdentifierResult ->
@@ -74,15 +99,12 @@ fun ObserveCurrentSessionAnalyticsUseCase(
                             currentIdentifierResult != previousAnalyticsResult &&
                                     currentResult?.identifier != previousResult?.identifier
                         },
-                    userDataStoreProvider.getOrCreate(userId).isAnonymousUsageDataEnabled()
+                    userDataStoreProvider.getOrCreate(userId).isAnonymousUsageDataEnabled(),
                 ) { analyticsIdentifierResult, enabled ->
                     previousAnalyticsResult = analyticsIdentifierResult
 
                     val isProdBackend = when (val serverConfig = currentBackend(userId)) {
-                        is SelfServerConfigUseCase.Result.Success ->
-                            serverConfig.serverLinks.links.api == ServerConfig.PRODUCTION.api
-                                    || serverConfig.serverLinks.links.api == ServerConfig.STAGING.api
-
+                        is SelfServerConfigUseCase.Result.Success -> serverConfig.serverLinks.isHostValidForAnalytics()
                         is SelfServerConfigUseCase.Result.Failure -> false
                     }
 
@@ -125,6 +147,6 @@ fun ObserveCurrentSessionAnalyticsUseCase(
                     )
                 )
             }
-        }
-        .distinctUntilChanged()
+        }.distinctUntilChanged()
+    }
 }

app/src/main/kotlin/com/wire/android/datastore/GlobalDataStore.kt

@@ -36,6 +36,7 @@ import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.flow.firstOrNull
 import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.runBlocking
+import java.util.UUID
 import javax.inject.Inject
 import javax.inject.Singleton
 
@@ -55,6 +56,8 @@ class GlobalDataStore @Inject constructor(@ApplicationContext private val contex
         private val APP_LOCK_SOURCE = intPreferencesKey("app_lock_source")
         private val ENTER_TO_SENT = booleanPreferencesKey("enter_to_sent")
         private val WIRE_CELLS = booleanPreferencesKey("wire_cells")
+        private val ANONYMOUS_REGISTRATION_TRACK_ID = stringPreferencesKey("anonymous_registration_track_id")
+        private val IS_ANONYMOUS_REGISTRATION_ENABLED = booleanPreferencesKey("is_anonymous_registration_enabled")
 
         val APP_THEME_OPTION = stringPreferencesKey("app_theme_option")
         val RECORD_AUDIO_EFFECTS_CHECKBOX = booleanPreferencesKey("record_audio_effects_checkbox")
@@ -99,6 +102,39 @@ class GlobalDataStore @Inject constructor(@ApplicationContext private val contex
         context.dataStore.edit { it[userDoubleTapToastStatusKey(userId)] = shouldShow }
     }
 
+    fun isAnonymousRegistrationEnabled(): Flow<Boolean> =
+        getBooleanPreference(IS_ANONYMOUS_REGISTRATION_ENABLED, false)
+
+    suspend fun setAnonymousRegistrationEnabled(enabled: Boolean) {
+        context.dataStore.edit { it[IS_ANONYMOUS_REGISTRATION_ENABLED] = enabled }
+    }
+
+    suspend fun clearAnonymousRegistrationTrackId() {
+        context.dataStore.edit {
+            it.remove(ANONYMOUS_REGISTRATION_TRACK_ID)
+        }
+    }
+
+    private suspend fun setAnonymousRegistrationTrackId(trackId: String) {
+        context.dataStore.edit {
+            it[ANONYMOUS_REGISTRATION_TRACK_ID] = trackId
+        }
+    }
+
+    suspend fun getAnonymousRegistrationTrackId(): String? {
+        return context.dataStore.data.firstOrNull()?.get(ANONYMOUS_REGISTRATION_TRACK_ID)
+    }
+
+    suspend fun getOrCreateAnonymousRegistrationTrackId(): String {
+        val trackId = context.dataStore.data.first()[ANONYMOUS_REGISTRATION_TRACK_ID]
+        if (trackId.isNullOrBlank()) {
+            val newTrackId = UUID.randomUUID().toString()
+            setAnonymousRegistrationTrackId(newTrackId)
+            return newTrackId
+        }
+        return trackId
+    }
+
     suspend fun getShouldShowDoubleTapToast(userId: String): Boolean =
         getBooleanPreference(userDoubleTapToastStatusKey(userId), true).first()
 

app/src/main/kotlin/com/wire/android/ui/authentication/create/username/CreateAccountUsernameViewModel.kt

@@ -24,6 +24,9 @@ import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.setValue
 import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
+import com.wire.android.analytics.FinalizeRegistrationAnalyticsMetadataUseCase
+import com.wire.android.feature.analytics.AnonymousAnalyticsManager
+import com.wire.android.feature.analytics.model.AnalyticsEvent
 import com.wire.android.ui.authentication.create.common.handle.HandleUpdateErrorState
 import com.wire.android.ui.common.textfield.textAsFlow
 import com.wire.kalium.logic.feature.auth.ValidateUserHandleResult
@@ -39,7 +42,9 @@ import javax.inject.Inject
 @HiltViewModel
 class CreateAccountUsernameViewModel @Inject constructor(
     private val validateUserHandleUseCase: ValidateUserHandleUseCase,
-    private val setUserHandleUseCase: SetUserHandleUseCase
+    private val setUserHandleUseCase: SetUserHandleUseCase,
+    private val anonymousAnalyticsManager: AnonymousAnalyticsManager,
+    private val finalizeRegistrationAnalyticsMetadata: FinalizeRegistrationAnalyticsMetadataUseCase
 ) : ViewModel() {
 
     val textState: TextFieldState = TextFieldState()
@@ -48,6 +53,7 @@ class CreateAccountUsernameViewModel @Inject constructor(
 
     init {
         viewModelScope.launch {
+            anonymousAnalyticsManager.sendEvent(AnalyticsEvent.RegistrationPersonalAccount.Username)
             textState.textAsFlow()
                 .dropWhile { it.isEmpty() } // ignore first empty value to not show the error before the user typed anything
                 .collectLatest { newHandle ->
@@ -79,7 +85,11 @@ class CreateAccountUsernameViewModel @Inject constructor(
                 is SetUserHandleResult.Failure.Generic -> HandleUpdateErrorState.DialogError.GenericError(result.error)
                 SetUserHandleResult.Failure.HandleExists -> HandleUpdateErrorState.TextFieldError.UsernameTakenError
                 SetUserHandleResult.Failure.InvalidHandle -> HandleUpdateErrorState.TextFieldError.UsernameInvalidError
-                SetUserHandleResult.Success -> HandleUpdateErrorState.None
+                SetUserHandleResult.Success -> {
+                    anonymousAnalyticsManager.sendEvent(AnalyticsEvent.RegistrationPersonalAccount.CreationCompleted)
+                    finalizeRegistrationAnalyticsMetadata()
+                    HandleUpdateErrorState.None
+                }
             }
             state = state.copy(
                 loading = false,

app/src/main/kotlin/com/wire/android/ui/registration/code/CreateAccountVerificationCodeViewModel.kt

@@ -29,6 +29,8 @@ import com.wire.android.BuildConfig
 import com.wire.android.config.orDefault
 import com.wire.android.di.ClientScopeProvider
 import com.wire.android.di.KaliumCoreLogic
+import com.wire.android.feature.analytics.AnonymousAnalyticsManager
+import com.wire.android.feature.analytics.model.AnalyticsEvent
 import com.wire.android.ui.authentication.create.common.CreateAccountDataNavArgs
 import com.wire.android.ui.common.textfield.textAsFlow
 import com.wire.android.ui.navArgs
@@ -53,6 +55,7 @@ class CreateAccountVerificationCodeViewModel @Inject constructor(
     savedStateHandle: SavedStateHandle,
     @KaliumCoreLogic private val coreLogic: CoreLogic,
     private val addAuthenticatedUser: AddAuthenticatedUserUseCase,
+    private val anonymousAnalyticsManager: AnonymousAnalyticsManager,
     private val clientScopeProviderFactory: ClientScopeProvider.Factory,
 ) : ViewModel() {
 
@@ -67,6 +70,7 @@ class CreateAccountVerificationCodeViewModel @Inject constructor(
 
     init {
         viewModelScope.launch {
+            anonymousAnalyticsManager.sendEvent(AnalyticsEvent.RegistrationPersonalAccount.CodeVerification)
             codeTextState.textAsFlow().collectLatest {
                 if (it.length == codeState.codeLength) onCodeContinue()
             }
@@ -147,6 +151,7 @@ class CreateAccountVerificationCodeViewModel @Inject constructor(
             val registerResult = authScope.registerScope.register(registerParam).let {
                 when (it) {
                     is RegisterResult.Failure -> {
+                        anonymousAnalyticsManager.sendEvent(AnalyticsEvent.RegistrationPersonalAccount.CodeVerificationFailed)
                         updateCodeErrorState(it.toCodeError())
                         return@launch
                     }

app/src/main/kotlin/com/wire/android/ui/registration/details/CreateAccountDataDetailScreen.kt

@@ -85,6 +85,7 @@ import com.wire.android.ui.theme.wireDimensions
 import com.wire.android.ui.theme.wireTypography
 import com.wire.android.util.CustomTabsHelper
 import com.wire.android.util.EMPTY
+import com.wire.android.util.isHostValidForAnalytics
 import com.wire.android.util.ui.PreviewMultipleThemes
 import com.wire.kalium.logic.configuration.server.ServerConfig
 
@@ -275,12 +276,14 @@ private fun AccountDetailsContent(
                     autoFill = false,
                 )
 
-                Row(modifier = Modifier.padding(end = MaterialTheme.wireDimensions.spacing16x)) {
-                    WireCheckbox(
-                        checked = state.privacyPolicyAccepted,
-                        onCheckedChange = onPrivacyPolicyAccepted,
-                    )
-                    WirePrivacyPolicyLink()
+                if (serverConfig.isHostValidForAnalytics()) {
+                    Row(modifier = Modifier.padding(end = MaterialTheme.wireDimensions.spacing16x)) {
+                        WireCheckbox(
+                            checked = state.privacyPolicyAccepted,
+                            onCheckedChange = onPrivacyPolicyAccepted,
+                        )
+                        WirePrivacyPolicyLink()
+                    }
                 }
             }