Add support for Verification state analytics

services/analyticsproviders/posthog/build.gradle.kts

@@ -34,4 +34,10 @@ dependencies {
     implementation(projects.libraries.core)
     implementation(projects.libraries.di)
     implementation(projects.services.analyticsproviders.api)
+
+    testImplementation(libs.coroutines.test)
+    testImplementation(libs.test.truth)
+    testImplementation(libs.test.junit)
+    testImplementation(projects.tests.testutils)
+    testImplementation(libs.test.mockk)
 }

services/analyticsproviders/posthog/src/main/kotlin/io/element/android/services/analyticsproviders/posthog/PosthogAnalyticsProvider.kt

@@ -40,6 +40,10 @@ class PosthogAnalyticsProvider @Inject constructor(
     private var posthog: PostHogInterface? = null
     private var analyticsId: String? = null
 
+    private var pendingUserProperties: MutableMap<String, Any>? = null
+
+    private val userPropertiesLock = Any()
+
     override fun init() {
         posthog = createPosthog()
         posthog?.optIn()
@@ -57,10 +61,14 @@ class PosthogAnalyticsProvider @Inject constructor(
     }
 
     override fun capture(event: VectorAnalyticsEvent) {
-        posthog?.capture(
-            event = event.getName(),
-            properties = event.getProperties()?.keepOnlyNonNullValues().withExtraProperties(),
-        )
+        synchronized(userPropertiesLock) {
+            posthog?.capture(
+                event = event.getName(),
+                properties = event.getProperties()?.keepOnlyNonNullValues().withExtraProperties(),
+                userProperties = pendingUserProperties,
+            )
+            pendingUserProperties = null
+        }
     }
 
     override fun screen(screen: VectorAnalyticsScreen) {
@@ -71,10 +79,19 @@ class PosthogAnalyticsProvider @Inject constructor(
     }
 
     override fun updateUserProperties(userProperties: UserProperties) {
-//        posthog?.identify(
-//            REUSE_EXISTING_ID, userProperties.getProperties()?.toPostHogUserProperties(),
-//            IGNORED_OPTIONS
-//        )
+        synchronized(userPropertiesLock) {
+            // The pending properties will be sent with the following capture call
+            if (pendingUserProperties == null) {
+                pendingUserProperties = HashMap()
+            }
+            userProperties.getProperties()?.let {
+                pendingUserProperties?.putAll(it)
+            }
+            // We are not currently using `identify` in EIX, if it was the case
+            // we could have called identify to update the user properties.
+            // For now, we have to store them, and they will be updated when the next call
+            // to capture will happen.
+        }
     }
 
     override fun trackError(throwable: Throwable) {

services/analyticsproviders/posthog/src/test/kotlin/io/element/android/services/analyticsproviders/posthog/PosthogAnalyticsProviderTest.kt

@@ -0,0 +1,116 @@
+/*
+ * Copyright (c) 2024 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.services.analyticsproviders.posthog
+
+import com.google.common.truth.Truth.assertThat
+import com.posthog.PostHogInterface
+import im.vector.app.features.analytics.itf.VectorAnalyticsEvent
+import im.vector.app.features.analytics.plan.UserProperties
+import io.element.android.tests.testutils.WarmUpRule
+import io.mockk.every
+import io.mockk.just
+import io.mockk.mockk
+import io.mockk.runs
+import io.mockk.slot
+import io.mockk.verify
+import kotlinx.coroutines.test.runTest
+import org.junit.Rule
+import org.junit.Test
+
+class PosthogAnalyticsProviderTest {
+    @get:Rule
+    val warmUpRule = WarmUpRule()
+
+    @Test
+    fun `Posthog - Test user properties`() = runTest {
+        val mockPosthog = mockk<PostHogInterface>().also {
+            every { it.optIn() } just runs
+            every { it.capture(any(), any(), any(), any(), any(), any()) } just runs
+        }
+        val mockPosthogFactory = mockk<PostHogFactory>()
+        every { mockPosthogFactory.createPosthog() } returns mockPosthog
+
+        val analyticsProvider = PosthogAnalyticsProvider(mockPosthogFactory)
+        analyticsProvider.init()
+
+        val testUserProperties = UserProperties(
+            verificationState = UserProperties.VerificationState.Verified,
+            recoveryState = UserProperties.RecoveryState.Incomplete,
+        )
+        analyticsProvider.updateUserProperties(testUserProperties)
+
+        // report mock event
+        val mockEvent = mockk<VectorAnalyticsEvent>().also {
+            every {
+                it.getProperties()
+            } returns emptyMap()
+            every { it.getName() } returns "MockEventName"
+        }
+        analyticsProvider.capture(mockEvent)
+        val userPropertiesSlot = slot<Map<String, Any>>()
+
+        verify { mockPosthog.capture(event = "MockEventName", any(), any(), userProperties = capture(userPropertiesSlot)) }
+
+        assertThat(userPropertiesSlot.captured).isNotNull()
+        assertThat(userPropertiesSlot.captured["verificationState"] as String).isEqualTo(testUserProperties.verificationState?.name)
+        assertThat(userPropertiesSlot.captured["recoveryState"] as String).isEqualTo(testUserProperties.recoveryState?.name)
+
+        // Should only be reported once when the next event is sent
+        // Try another capture to check
+        analyticsProvider.capture(mockEvent)
+        verify { mockPosthog.capture(any(), any(), any(), userProperties = null) }
+    }
+
+    @Test
+    fun `Posthog - Test accumulate user properties until next capture call`() = runTest {
+        val mockPosthog = mockk<PostHogInterface>().also {
+            every { it.optIn() } just runs
+            every { it.capture(any(), any(), any(), any(), any(), any()) } just runs
+        }
+        val mockPosthogFactory = mockk<PostHogFactory>()
+        every { mockPosthogFactory.createPosthog() } returns mockPosthog
+
+        val analyticsProvider = PosthogAnalyticsProvider(mockPosthogFactory)
+        analyticsProvider.init()
+
+        val testUserProperties = UserProperties(
+            verificationState = UserProperties.VerificationState.NotVerified,
+        )
+        analyticsProvider.updateUserProperties(testUserProperties)
+
+        // Update again
+        val testUserPropertiesUpdate = UserProperties(
+            verificationState = UserProperties.VerificationState.Verified,
+        )
+        analyticsProvider.updateUserProperties(testUserPropertiesUpdate)
+
+        // report mock event
+        val mockEvent = mockk<VectorAnalyticsEvent>().also {
+            every {
+                it.getProperties()
+            } returns emptyMap()
+            every { it.getName() } returns "MockEventName"
+        }
+        analyticsProvider.capture(mockEvent)
+        val userPropertiesSlot = slot<Map<String, Any>>()
+
+        verify { mockPosthog.capture(event = "MockEventName", any(), any(), userProperties = capture(userPropertiesSlot)) }
+
+        assertThat(userPropertiesSlot.captured).isNotNull()
+        assertThat(userPropertiesSlot.captured["verificationState"] as String).isEqualTo(testUserPropertiesUpdate.verificationState?.name)
+    }
+}