feat: add analytics user profile - Part 2 (WPB-8978)

logger/src/commonMain/kotlin/com/wire/kalium/logger/KaliumLogger.kt

@@ -258,7 +258,8 @@ class KaliumLogger(
         )
 
         enum class ApplicationFlow {
-            SYNC, EVENT_RECEIVER, CONVERSATIONS, CONNECTIONS, MESSAGES, SEARCH, SESSION, REGISTER, CLIENTS, CALLING, ASSETS, LOCAL_STORAGE
+            SYNC, EVENT_RECEIVER, CONVERSATIONS, CONNECTIONS, MESSAGES, SEARCH, SESSION, REGISTER,
+            CLIENTS, CALLING, ASSETS, LOCAL_STORAGE, ANALYTICS
         }
     }
 }

logic/src/commonMain/kotlin/com/wire/kalium/logic/configuration/UserConfigRepository.kt

@@ -137,6 +137,11 @@ interface UserConfigRepository {
     fun setShouldFetchE2EITrustAnchors(shouldFetch: Boolean)
     fun getShouldFetchE2EITrustAnchor(): Boolean
     suspend fun setTrackingIdentifier(identifier: String)
+    suspend fun getTrackingIdentifier(): String?
+    suspend fun observeTrackingIdentifier(): Flow<Either<StorageFailure, String>>
+    suspend fun setPreviousTrackingIdentifier(identifier: String)
+    suspend fun getPreviousTrackingIdentifier(): String?
+    suspend fun deletePreviousTrackingIdentifier()
 }
 
 @Suppress("TooManyFunctions")
@@ -502,4 +507,25 @@ internal class UserConfigDataSource internal constructor(
             userConfigDAO.setTrackingIdentifier(identifier = identifier)
         }
     }
+
+    override suspend fun getTrackingIdentifier(): String? =
+        userConfigDAO.getTrackingIdentifier()
+
+    override suspend fun observeTrackingIdentifier(): Flow<Either<StorageFailure, String>> =
+        userConfigDAO.observeTrackingIdentifier().wrapStorageRequest()
+
+    override suspend fun setPreviousTrackingIdentifier(identifier: String) {
+        wrapStorageRequest {
+            userConfigDAO.setPreviousTrackingIdentifier(identifier = identifier)
+        }
+    }
+
+    override suspend fun getPreviousTrackingIdentifier(): String? =
+        userConfigDAO.getPreviousTrackingIdentifier()
+
+    override suspend fun deletePreviousTrackingIdentifier() {
+        wrapStorageRequest {
+            userConfigDAO.deletePreviousTrackingIdentifier()
+        }
+    }
 }

logic/src/commonMain/kotlin/com/wire/kalium/logic/feature/UserSessionScope.kt

@@ -152,6 +152,7 @@ import com.wire.kalium.logic.di.MapperProvider
 import com.wire.kalium.logic.di.PlatformUserStorageProperties
 import com.wire.kalium.logic.di.RootPathsProvider
 import com.wire.kalium.logic.di.UserStorageProvider
+import com.wire.kalium.logic.feature.analytics.ObserveAnalyticsTrackingIdentifierStatusUseCase
 import com.wire.kalium.logic.feature.applock.AppLockTeamFeatureConfigObserver
 import com.wire.kalium.logic.feature.applock.AppLockTeamFeatureConfigObserverImpl
 import com.wire.kalium.logic.feature.applock.MarkTeamAppLockStatusAsNotifiedUseCase
@@ -1461,6 +1462,9 @@ class UserSessionScope internal constructor(
     val observeLegalHoldStateForUser: ObserveLegalHoldStateForUserUseCase
         get() = ObserveLegalHoldStateForUserUseCaseImpl(clientRepository)
 
+    val observeAnalyticsTrackingIdentifierStatus: ObserveAnalyticsTrackingIdentifierStatusUseCase
+        get() = ObserveAnalyticsTrackingIdentifierStatusUseCase(userConfigRepository)
+
     suspend fun observeIfE2EIRequiredDuringLogin(): Flow<Boolean?> = clientRepository.observeIsClientRegistrationBlockedByE2EI()
 
     val observeLegalHoldForSelfUser: ObserveLegalHoldStateForSelfUserUseCase

logic/src/commonMain/kotlin/com/wire/kalium/logic/feature/analytics/ObserveAnalyticsTrackingIdentifierStatusUseCase.kt

@@ -0,0 +1,98 @@
+/*
+ * Wire
+ * Copyright (C) 2024 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.kalium.logic.feature.analytics
+
+import com.benasher44.uuid.uuid4
+import com.wire.kalium.logger.KaliumLogger
+import com.wire.kalium.logic.configuration.UserConfigRepository
+import com.wire.kalium.logic.functional.Either
+import com.wire.kalium.logic.functional.flatMapRightWithEither
+import com.wire.kalium.logic.functional.mapToRightOr
+import com.wire.kalium.logic.kaliumLogger
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.distinctUntilChanged
+import kotlinx.coroutines.flow.flowOf
+
+/**
+ * Use case that allows observing if the analytics tracking identifier
+ * changes, due to receiving a new identifier from another client
+ * or when it's user's first interaction with analytics.
+ */
+interface ObserveAnalyticsTrackingIdentifierStatusUseCase {
+    /**
+     * Use case [ObserveAnalyticsTrackingIdentifierStatusUseCase] operation
+     *
+     * @return a [AnalyticsIdentifierResult]
+     */
+    suspend operator fun invoke(): Flow<AnalyticsIdentifierResult>
+}
+
+@Suppress("FunctionNaming")
+internal fun ObserveAnalyticsTrackingIdentifierStatusUseCase(
+    userConfigRepository: UserConfigRepository
+) = object : ObserveAnalyticsTrackingIdentifierStatusUseCase {
+
+    private val TAG = "ObserveAnalyticsTrackingIdentifierStatusUseCase"
+    private val logger by lazy { kaliumLogger.withTextTag(KaliumLogger.Companion.ApplicationFlow.ANALYTICS.name) }
+
+    override suspend fun invoke(): Flow<AnalyticsIdentifierResult> =
+        userConfigRepository
+            .observeTrackingIdentifier()
+            .distinctUntilChanged()
+            .flatMapRightWithEither { currentIdentifier: String ->
+                val result =
+                    userConfigRepository.getPreviousTrackingIdentifier()?.let {
+                        AnalyticsIdentifierResult.MigrationIdentifier(
+                            identifier = currentIdentifier
+                        ).also {
+                            logger.i("$TAG Updating Tracking Identifier with migration value.")
+                        }
+                    } ?: AnalyticsIdentifierResult.ExistingIdentifier(
+                        identifier = currentIdentifier
+                    ).also {
+                        logger.i("$TAG Updating Tracking Identifier with existing value.")
+                    }
+
+                flowOf(Either.Right(result))
+            }.mapToRightOr(
+                AnalyticsIdentifierResult.NonExistingIdentifier(
+                    identifier = uuid4().toString()
+                ).also {
+                    logger.i("$TAG Generating new Tracking Identifier value.")
+                }
+            )
+}
+
+sealed class AnalyticsIdentifierResult {
+    abstract val identifier: String
+
+    // TODO(Analytics): Send DataTransfer message if this
+    data class NonExistingIdentifier(
+        override val identifier: String
+    ) : AnalyticsIdentifierResult()
+
+    // TODO(Analytics): Just set identifier without migration
+    data class ExistingIdentifier(
+        override val identifier: String
+    ) : AnalyticsIdentifierResult()
+
+    // TODO(Analytics): Set identifier with migration
+    data class MigrationIdentifier(
+        override val identifier: String
+    ) : AnalyticsIdentifierResult()
+}

logic/src/commonMain/kotlin/com/wire/kalium/logic/sync/receiver/handler/DataTransferEventHandler.kt

@@ -17,6 +17,7 @@
  */
 package com.wire.kalium.logic.sync.receiver.handler
 
+import com.wire.kalium.logger.KaliumLogger
 import com.wire.kalium.logic.configuration.UserConfigRepository
 import com.wire.kalium.logic.data.message.Message
 import com.wire.kalium.logic.data.message.MessageContent
@@ -39,14 +40,34 @@ internal class DataTransferEventHandlerImpl(
         message: Message.Signaling,
         messageContent: MessageContent.DataTransfer
     ) {
-        kaliumLogger.d("MessageContent.DataTransfer | with Identifier : ${messageContent.trackingIdentifier?.identifier} |end|")
         // DataTransfer from another user or null tracking identifier shouldn't happen,
-        // If it happens, it's unnecessary
-        // and we can squish some performance by skipping it completely
+        // If it happens, it's unnecessary, and we can squish some performance by skipping it completely
         if (message.senderUserId != selfUserId || messageContent.trackingIdentifier == null) return
 
-        userConfigRepository.setTrackingIdentifier(
-            identifier = messageContent.trackingIdentifier!!.identifier
-        )
+        val currentTrackingIdentifier = userConfigRepository.getTrackingIdentifier()
+        val isCurrentDifferentThanReceived = currentTrackingIdentifier != messageContent
+            .trackingIdentifier!!
+            .identifier
+
+        if (isCurrentDifferentThanReceived) {
+            currentTrackingIdentifier?.let {
+                userConfigRepository.setPreviousTrackingIdentifier(identifier = currentTrackingIdentifier)
+                logger.d("$TAG Moved Current Tracking Identifier to Previous")
+            }
+
+            userConfigRepository.setTrackingIdentifier(
+                identifier = requireNotNull(
+                    messageContent
+                        .trackingIdentifier
+                        ?.identifier
+                )
+            )
+            logger.d("$TAG Tracking Identifier Updated")
+        }
+    }
+
+    private companion object {
+        const val TAG = "DataTransferEventHandler"
+        private val logger by lazy { kaliumLogger.withFeatureId(KaliumLogger.Companion.ApplicationFlow.ANALYTICS) }
     }
 }

logic/src/commonTest/kotlin/com/wire/kalium/logic/feature/analytics/ObserveAnalyticsTrackingIdentifierStatusUseCaseTest.kt

@@ -0,0 +1,101 @@
+/*
+ * Wire
+ * Copyright (C) 2024 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.kalium.logic.feature.analytics
+
+import app.cash.turbine.test
+import com.wire.kalium.logic.StorageFailure
+import com.wire.kalium.logic.functional.Either
+import com.wire.kalium.logic.util.arrangement.repository.UserConfigRepositoryArrangement
+import com.wire.kalium.logic.util.arrangement.repository.UserConfigRepositoryArrangementImpl
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.test.runTest
+import kotlin.test.Test
+import kotlin.test.assertIs
+
+class ObserveAnalyticsTrackingIdentifierStatusUseCaseTest {
+
+    @Test
+    fun givenTrackingIdentifierExists_whenObservingTrackingIdentifier_thenReturnExistingIdentifier() = runTest {
+        // given
+        val (_, useCase) = Arrangement().arrange {
+            withObserveTrackingIdentifier(Either.Right(CURRENT_IDENTIFIER))
+            withGetPreviousTrackingIdentifier(null)
+        }
+
+        // when
+        useCase().test {
+            // then
+            val item = awaitItem()
+            assertIs<AnalyticsIdentifierResult.ExistingIdentifier>(item)
+
+            cancelAndIgnoreRemainingEvents()
+        }
+    }
+
+    @Test
+    fun givenPreviousTrackingIdentifierExists_whenObservingTrackingIdentifier_thenReturnMigrationIdentifier() = runTest {
+        // given
+        val (_, useCase) = Arrangement().arrange {
+            withObserveTrackingIdentifier(Either.Right(CURRENT_IDENTIFIER))
+            withGetPreviousTrackingIdentifier(PREVIOUS_IDENTIFIER)
+        }
+
+        // when
+        useCase().test {
+            // then
+            val item = awaitItem()
+            assertIs<AnalyticsIdentifierResult.MigrationIdentifier>(item)
+
+            cancelAndIgnoreRemainingEvents()
+        }
+    }
+
+    @Test
+    fun givenThereIsNoIdentifier_whenObservingTrackingIdentifier_thenReturnNonExistingIdentifier() = runTest {
+        // given
+        val (_, useCase) = Arrangement().arrange {
+            withObserveTrackingIdentifier(Either.Left(StorageFailure.DataNotFound))
+        }
+
+        // when
+        useCase().test {
+            // then
+            val item = awaitItem()
+            assertIs<AnalyticsIdentifierResult.NonExistingIdentifier>(item)
+
+            cancelAndIgnoreRemainingEvents()
+        }
+    }
+
+    private companion object {
+        const val PREVIOUS_IDENTIFIER = "abcd-1234"
+        const val CURRENT_IDENTIFIER = "efgh-5678"
+    }
+
+    private class Arrangement : UserConfigRepositoryArrangement by UserConfigRepositoryArrangementImpl() {
+
+        private val useCase: ObserveAnalyticsTrackingIdentifierStatusUseCase = ObserveAnalyticsTrackingIdentifierStatusUseCase(
+            userConfigRepository = userConfigRepository
+        )
+
+        fun arrange(block: suspend Arrangement.() -> Unit): Pair<Arrangement, ObserveAnalyticsTrackingIdentifierStatusUseCase> {
+            runBlocking { block() }
+            return this to useCase
+        }
+    }
+}

logic/src/commonTest/kotlin/com/wire/kalium/logic/sync/receiver/handler/DataTransferEventHandlerTest.kt

@@ -38,6 +38,7 @@ class DataTransferEventHandlerTest {
     fun givenSelfUserDataTransferContent_whenHandlingEvent_thenSetTrackingIdentifier() = runTest {
         // given
         val (arrangement, handler) = Arrangement().arrange {
+            withGetTrackingIdentifier(null)
             withSetTrackingIdentifier()
         }
 
@@ -91,6 +92,58 @@ class DataTransferEventHandlerTest {
         }.wasNotInvoked()
     }
 
+    @Test
+    fun givenSelfUserHasTrackingIdentifier_whenReceivingNewTrackingIdentifier_thenMoveCurrentToPreviousAndUpdate() = runTest {
+        // given
+        val currentIdentifier = "abcd-1234"
+        val newIdentifier = "efgh-5678"
+        val (arrangement, handler) = Arrangement().arrange {
+            withGetTrackingIdentifier(currentIdentifier)
+        }
+
+        // when
+        handler.handle(
+            message = MESSAGE,
+            messageContent = MESSAGE_CONTENT.copy(
+                trackingIdentifier = MESSAGE_CONTENT.trackingIdentifier?.copy(
+                    identifier = newIdentifier
+                )
+            )
+        )
+
+        // then
+        coVerify {
+            arrangement.userConfigRepository.setPreviousTrackingIdentifier(currentIdentifier)
+        }.wasInvoked(exactly = once)
+
+        coVerify {
+            arrangement.userConfigRepository.setTrackingIdentifier(newIdentifier)
+        }.wasInvoked(exactly = once)
+    }
+
+    @Test
+    fun givenCurrentIdentifierIsTheSame_whenReceivingNewTrackingIdentifier_thenDoNotUpdateTrackingIdentifier() = runTest {
+        // given
+        val (arrangement, handler) = Arrangement().arrange {
+            withGetTrackingIdentifier(MESSAGE_CONTENT.trackingIdentifier?.identifier)
+        }
+
+        // when
+        handler.handle(
+            message = MESSAGE,
+            messageContent = MESSAGE_CONTENT
+        )
+
+        // then
+        coVerify {
+            arrangement.userConfigRepository.setPreviousTrackingIdentifier(any())
+        }.wasNotInvoked()
+
+        coVerify {
+            arrangement.userConfigRepository.setTrackingIdentifier(any())
+        }.wasNotInvoked()
+    }
+
     private companion object {
         val CONVERSATION_ID = ConversationId("conversationId", "domain")
         val SELF_USER_ID = UserId("selfUserId", "domain")