fix: decouple app lifecycle from sessions autocapture

android/src/main/java/com/amplitude/android/plugins/AndroidLifecyclePlugin.kt

@@ -7,6 +7,10 @@ import android.content.pm.PackageManager
 import android.os.Bundle
 import androidx.annotation.VisibleForTesting
 import com.amplitude.android.AutocaptureOption
+import com.amplitude.android.AutocaptureOption.APP_LIFECYCLES
+import com.amplitude.android.AutocaptureOption.DEEP_LINKS
+import com.amplitude.android.AutocaptureOption.ELEMENT_INTERACTIONS
+import com.amplitude.android.AutocaptureOption.SCREEN_VIEWS
 import com.amplitude.android.Configuration
 import com.amplitude.android.ExperimentalAmplitudeFeature
 import com.amplitude.android.utilities.ActivityCallbackType
@@ -26,7 +30,7 @@ class AndroidLifecyclePlugin(
     override lateinit var amplitude: Amplitude
     private lateinit var packageInfo: PackageInfo
     private lateinit var androidAmplitude: AndroidAmplitude
-    private lateinit var androidConfiguration: Configuration
+    private lateinit var autocapture: Set<AutocaptureOption>
 
     private val created: MutableSet<Int> = mutableSetOf()
     private val started: MutableSet<Int> = mutableSetOf()
@@ -39,11 +43,12 @@ class AndroidLifecyclePlugin(
     override fun setup(amplitude: Amplitude) {
         super.setup(amplitude)
         androidAmplitude = amplitude as AndroidAmplitude
-        androidConfiguration = amplitude.configuration as Configuration
+        val androidConfiguration = amplitude.configuration as Configuration
+        autocapture = androidConfiguration.autocapture
 
         val application = androidConfiguration.context as Application
 
-        if (AutocaptureOption.APP_LIFECYCLES in androidConfiguration.autocapture) {
+        if (APP_LIFECYCLES in autocapture) {
             packageInfo = try {
                 application.packageManager.getPackageInfo(application.packageName, 0)
             } catch (e: PackageManager.NameNotFoundException) {
@@ -53,21 +58,21 @@ class AndroidLifecyclePlugin(
             }
 
             DefaultEventUtils(androidAmplitude).trackAppUpdatedInstalledEvent(packageInfo)
+        }
 
-            eventJob = amplitude.amplitudeScope.launch(Dispatchers.Main) {
-                for (event in activityLifecycleObserver.eventChannel) {
-                    event.activity.get()?.let { activity ->
-                        when (event.type) {
-                            ActivityCallbackType.Created -> onActivityCreated(
-                                activity,
-                                activity.intent?.extras
-                            )
-                            ActivityCallbackType.Started -> onActivityStarted(activity)
-                            ActivityCallbackType.Resumed -> onActivityResumed(activity)
-                            ActivityCallbackType.Paused -> onActivityPaused(activity)
-                            ActivityCallbackType.Stopped -> onActivityStopped(activity)
-                            ActivityCallbackType.Destroyed -> onActivityDestroyed(activity)
-                        }
+        eventJob = amplitude.amplitudeScope.launch(Dispatchers.Main) {
+            for (event in activityLifecycleObserver.eventChannel) {
+                event.activity.get()?.let { activity ->
+                    when (event.type) {
+                        ActivityCallbackType.Created -> onActivityCreated(
+                            activity,
+                            activity.intent?.extras
+                        )
+                        ActivityCallbackType.Started -> onActivityStarted(activity)
+                        ActivityCallbackType.Resumed -> onActivityResumed(activity)
+                        ActivityCallbackType.Paused -> onActivityPaused(activity)
+                        ActivityCallbackType.Stopped -> onActivityStopped(activity)
+                        ActivityCallbackType.Destroyed -> onActivityDestroyed(activity)
                     }
                 }
             }
@@ -77,7 +82,7 @@ class AndroidLifecyclePlugin(
     override fun onActivityCreated(activity: Activity, bundle: Bundle?) {
         created.add(activity.hashCode())
 
-        if (AutocaptureOption.SCREEN_VIEWS in androidConfiguration.autocapture) {
+        if (SCREEN_VIEWS in autocapture) {
             DefaultEventUtils(androidAmplitude).startFragmentViewedEventTracking(activity)
         }
     }
@@ -89,19 +94,19 @@ class AndroidLifecyclePlugin(
         }
         started.add(activity.hashCode())
 
-        if (AutocaptureOption.APP_LIFECYCLES in androidConfiguration.autocapture && started.size == 1) {
+        if (APP_LIFECYCLES in autocapture && started.size == 1) {
             DefaultEventUtils(androidAmplitude).trackAppOpenedEvent(
                 packageInfo = packageInfo,
                 isFromBackground = appInBackground
             )
             appInBackground = false
         }
 
-        if (AutocaptureOption.DEEP_LINKS in androidConfiguration.autocapture) {
+        if (DEEP_LINKS in autocapture) {
             DefaultEventUtils(androidAmplitude).trackDeepLinkOpenedEvent(activity)
         }
 
-        if (AutocaptureOption.SCREEN_VIEWS in androidConfiguration.autocapture) {
+        if (SCREEN_VIEWS in autocapture) {
             DefaultEventUtils(androidAmplitude).trackScreenViewedEvent(activity)
         }
     }
@@ -110,7 +115,7 @@ class AndroidLifecyclePlugin(
         androidAmplitude.onEnterForeground(getCurrentTimeMillis())
 
         @OptIn(ExperimentalAmplitudeFeature::class)
-        if (AutocaptureOption.ELEMENT_INTERACTIONS in androidConfiguration.autocapture) {
+        if (ELEMENT_INTERACTIONS in autocapture) {
             DefaultEventUtils(androidAmplitude).startUserInteractionEventTracking(activity)
         }
     }
@@ -119,15 +124,15 @@ class AndroidLifecyclePlugin(
         androidAmplitude.onExitForeground(getCurrentTimeMillis())
 
         @OptIn(ExperimentalAmplitudeFeature::class)
-        if (AutocaptureOption.ELEMENT_INTERACTIONS in androidConfiguration.autocapture) {
+        if (ELEMENT_INTERACTIONS in autocapture) {
             DefaultEventUtils(androidAmplitude).stopUserInteractionEventTracking(activity)
         }
     }
 
     override fun onActivityStopped(activity: Activity) {
         started.remove(activity.hashCode())
 
-        if (AutocaptureOption.APP_LIFECYCLES in androidConfiguration.autocapture && started.isEmpty()) {
+        if (APP_LIFECYCLES in autocapture && started.isEmpty()) {
             DefaultEventUtils(androidAmplitude).trackAppBackgroundedEvent()
             appInBackground = true
         }
@@ -139,7 +144,7 @@ class AndroidLifecyclePlugin(
     override fun onActivityDestroyed(activity: Activity) {
         created.remove(activity.hashCode())
 
-        if (AutocaptureOption.SCREEN_VIEWS in androidConfiguration.autocapture) {
+        if (SCREEN_VIEWS in autocapture) {
             DefaultEventUtils(androidAmplitude).stopFragmentViewedEventTracking(activity)
         }
     }

android/src/test/kotlin/com/amplitude/android/AmplitudeSessionTest.kt

@@ -17,10 +17,14 @@ import io.mockk.mockk
 import io.mockk.slot
 import io.mockk.spyk
 import io.mockk.verify
+import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.test.StandardTestDispatcher
 import kotlinx.coroutines.test.advanceUntilIdle
 import kotlinx.coroutines.test.runTest
+import kotlinx.coroutines.test.setMain
 import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.BeforeEach
 import org.junit.jupiter.api.Test
 import java.io.File
 
@@ -57,6 +61,11 @@ class AmplitudeSessionTest {
         )
     }
 
+    @BeforeEach
+    fun setUp() {
+        Dispatchers.setMain(StandardTestDispatcher())
+    }
+
     @Test
     fun amplitude_closeBackgroundEventsShouldNotStartNewSession() = runTest {
         val amplitude = createFakeAmplitude(

android/src/test/kotlin/com/amplitude/android/AmplitudeTest.kt

@@ -20,14 +20,19 @@ import io.mockk.mockkObject
 import io.mockk.slot
 import io.mockk.unmockkObject
 import kotlin.concurrent.thread
+import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.test.StandardTestDispatcher
+import kotlinx.coroutines.test.TestCoroutineDispatcher
 import kotlinx.coroutines.test.advanceUntilIdle
 import kotlinx.coroutines.test.runTest
+import kotlinx.coroutines.test.setMain
 import org.junit.jupiter.api.Assertions.assertEquals
 import org.junit.jupiter.api.Assertions.assertNotEquals
 import org.junit.jupiter.api.Assertions.assertNotNull
 import org.junit.jupiter.api.Assertions.assertNull
 import org.junit.jupiter.api.Assertions.assertTrue
+import org.junit.jupiter.api.BeforeEach
 import org.junit.jupiter.api.Test
 import java.io.File
 
@@ -44,6 +49,7 @@ internal class FakeEventPlugin : EventPlugin {
 
 @ExperimentalCoroutinesApi
 class AmplitudeTest {
+
     private fun createConfiguration(
         minTimeBetweenSessionsMillis: Long? = null,
         storageProvider: StorageProvider = InMemoryStorageProvider(),
@@ -88,6 +94,11 @@ class AmplitudeTest {
         return configuration
     }
 
+    @BeforeEach
+    fun setUp() {
+        Dispatchers.setMain(StandardTestDispatcher())
+    }
+
     @Test
     fun amplitude_reset_wipesUserIdDeviceId() = runTest {
         val amplitude = createFakeAmplitude(

android/src/test/kotlin/com/amplitude/android/plugins/AndroidLifecyclePluginTest.kt

@@ -76,6 +76,22 @@ class AndroidLifecyclePluginTest {
         mockkObject(FragmentActivityHandler)
     }
 
+    @Test
+    fun `test eventJob is created even if APP_LIFECYCLES is not enabled`() = runTest {
+        every { mockedConfig.autocapture } returns emptySet()
+        every { mockedAmplitude.amplitudeScope } returns this
+
+        plugin.setup(mockedAmplitude)
+
+        advanceUntilIdle()
+
+        assert(
+            plugin.eventJob != null
+        ) { "eventJob should be created even if APP_LIFECYCLES is not enabled" }
+
+        close()
+    }
+
     @Test
     fun `test application installed event is tracked`() = runTest {
         every { mockedConfig.autocapture } returns setOf(AutocaptureOption.APP_LIFECYCLES)