Implement SessionInitiator and hook it up to lifecycle events

firebase-sessions/src/main/kotlin/com/google/firebase/sessions/FirebaseSessions.kt

@@ -14,16 +14,35 @@
 
 package com.google.firebase.sessions
 
+import android.app.Application
+import android.util.Log
 import androidx.annotation.Discouraged
 import com.google.firebase.FirebaseApp
 import com.google.firebase.ktx.Firebase
 import com.google.firebase.ktx.app
 
-class FirebaseSessions internal constructor() {
+class FirebaseSessions internal constructor(firebaseApp: FirebaseApp) {
+  init {
+    val sessionInitiator = SessionInitiator(System::currentTimeMillis, this::initiateSessionStart)
+    val context = firebaseApp.applicationContext.applicationContext
+    if (context is Application) {
+      context.registerActivityLifecycleCallbacks(sessionInitiator.activityLifecycleCallbacks)
+    } else {
+      Log.w(TAG, "Failed to register lifecycle callbacks, unexpected context ${context.javaClass}.")
+    }
+  }
+
   @Discouraged(message = "This will be replaced with a real API.")
   fun greeting(): String = "Matt says hi!"
 
+  private fun initiateSessionStart() {
+    // TODO(mrober): Generate a session
+    Log.i(TAG, "Initiate session start")
+  }
+
   companion object {
+    private const val TAG = "FirebaseSessions"
+
     @JvmStatic
     val instance: FirebaseSessions
       get() = getInstance(Firebase.app)

firebase-sessions/src/main/kotlin/com/google/firebase/sessions/FirebaseSessionsRegistrar.kt

@@ -15,8 +15,10 @@
 package com.google.firebase.sessions
 
 import androidx.annotation.Keep
+import com.google.firebase.FirebaseApp
 import com.google.firebase.components.Component
 import com.google.firebase.components.ComponentRegistrar
+import com.google.firebase.components.Dependency
 import com.google.firebase.platforminfo.LibraryVersionComponent
 
 /**
@@ -30,12 +32,14 @@ internal class FirebaseSessionsRegistrar : ComponentRegistrar {
     listOf(
       Component.builder(FirebaseSessions::class.java)
         .name(LIBRARY_NAME)
-        .factory { FirebaseSessions() }
+        .add(Dependency.required(FirebaseApp::class.java))
+        .factory { container -> FirebaseSessions(container.get(FirebaseApp::class.java)) }
+        .eagerInDefaultApp()
         .build(),
       LibraryVersionComponent.create(LIBRARY_NAME, BuildConfig.VERSION_NAME)
     )
 
   companion object {
-    private const val LIBRARY_NAME = "fire-ses"
+    private const val LIBRARY_NAME = "fire-sessions"
   }
 }

firebase-sessions/src/main/kotlin/com/google/firebase/sessions/SessionInitiator.kt

@@ -0,0 +1,68 @@
+/*
+ * Copyright 2023 Google LLC
+ *
+ * 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 com.google.firebase.sessions
+
+import android.app.Activity
+import android.app.Application.ActivityLifecycleCallbacks
+import android.os.Bundle
+
+/**
+ * The [SessionInitiator] is responsible for calling the [initiateSessionStart] callback whenever a
+ * session starts. This will happen at a cold start of the app, and when the app has been in the
+ * background for a period of time (default 30 min) and then comes back to the foreground.
+ *
+ * @hide
+ */
+internal class SessionInitiator(
+  private val currentTimeMs: () -> Long,
+  private val initiateSessionStart: () -> Unit
+) {
+  private var backgroundTimeMs = currentTimeMs()
+  private val sessionTimeoutMs = 30 * 60 * 1000L // TODO(mrober): Get session timeout from settings
+
+  init {
+    initiateSessionStart()
+  }
+
+  fun appBackgrounded() {
+    backgroundTimeMs = currentTimeMs()
+  }
+
+  fun appForegrounded() {
+    val intervalMs = currentTimeMs() - backgroundTimeMs
+    if (intervalMs > sessionTimeoutMs) {
+      initiateSessionStart()
+    }
+  }
+
+  internal val activityLifecycleCallbacks =
+    object : ActivityLifecycleCallbacks {
+      override fun onActivityResumed(activity: Activity) = appForegrounded()
+
+      override fun onActivityPaused(activity: Activity) = appBackgrounded()
+
+      override fun onActivityCreated(activity: Activity, savedInstanceState: Bundle?) = Unit
+
+      override fun onActivityStarted(activity: Activity) = Unit
+
+      override fun onActivityStopped(activity: Activity) = Unit
+
+      override fun onActivityDestroyed(activity: Activity) = Unit
+
+      override fun onActivitySaveInstanceState(activity: Activity, outState: Bundle) = Unit
+    }
+}

firebase-sessions/src/test/kotlin/com/google/firebase/sessions/SessionInitiatorTest.kt

@@ -0,0 +1,140 @@
+/*
+ * Copyright 2023 Google LLC
+ *
+ * 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 com.google.firebase.sessions
+
+import com.google.common.truth.Truth.assertThat
+import org.junit.Test
+
+class SessionInitiatorTest {
+  class FakeTime {
+    var currentTimeMs = 0L
+      private set
+
+    fun addTimeMs(intervalMs: Long) {
+      currentTimeMs += intervalMs
+    }
+  }
+
+  class SessionStartCounter {
+    var count = 0
+      private set
+
+    fun initiateSessionStart() {
+      count++
+    }
+  }
+
+  @Test
+  fun coldStart_initiatesSession() {
+    val sessionStartCounter = SessionStartCounter()
+
+    // Simulate a cold start by simply constructing the SessionInitiator object
+    SessionInitiator({ 0 }, sessionStartCounter::initiateSessionStart)
+
+    assertThat(sessionStartCounter.count).isEqualTo(1)
+  }
+
+  @Test
+  fun appForegrounded_largeInterval_initiatesSession() {
+    val fakeTime = FakeTime()
+    val sessionStartCounter = SessionStartCounter()
+
+    val sessionInitiator =
+      SessionInitiator(fakeTime::currentTimeMs, sessionStartCounter::initiateSessionStart)
+
+    // First session on cold start
+    assertThat(sessionStartCounter.count).isEqualTo(1)
+
+    // Enough tome to initiate a new session, and then foreground
+    fakeTime.addTimeMs(LARGE_INTERVAL_MS)
+    sessionInitiator.appForegrounded()
+
+    // Another session initiated
+    assertThat(sessionStartCounter.count).isEqualTo(2)
+  }
+
+  @Test
+  fun appForegrounded_smallInterval_doesNotInitiatesSession() {
+    val fakeTime = FakeTime()
+    val sessionStartCounter = SessionStartCounter()
+
+    val sessionInitiator =
+      SessionInitiator(fakeTime::currentTimeMs, sessionStartCounter::initiateSessionStart)
+
+    // First session on cold start
+    assertThat(sessionStartCounter.count).isEqualTo(1)
+
+    // Not enough time to initiate a new session, and then foreground
+    fakeTime.addTimeMs(SMALL_INTERVAL_MS)
+    sessionInitiator.appForegrounded()
+
+    // No new session
+    assertThat(sessionStartCounter.count).isEqualTo(1)
+  }
+
+  @Test
+  fun appForegrounded_background_foreground_largeIntervals_initiatesSessions() {
+    val fakeTime = FakeTime()
+    val sessionStartCounter = SessionStartCounter()
+
+    val sessionInitiator =
+      SessionInitiator(fakeTime::currentTimeMs, sessionStartCounter::initiateSessionStart)
+
+    assertThat(sessionStartCounter.count).isEqualTo(1)
+
+    fakeTime.addTimeMs(LARGE_INTERVAL_MS)
+    sessionInitiator.appForegrounded()
+
+    assertThat(sessionStartCounter.count).isEqualTo(2)
+
+    sessionInitiator.appBackgrounded()
+    fakeTime.addTimeMs(LARGE_INTERVAL_MS)
+    sessionInitiator.appForegrounded()
+
+    assertThat(sessionStartCounter.count).isEqualTo(3)
+  }
+
+  @Test
+  fun appForegrounded_background_foreground_smallIntervals_doesNotInitiateNewSessions() {
+    val fakeTime = FakeTime()
+    val sessionStartCounter = SessionStartCounter()
+
+    val sessionInitiator =
+      SessionInitiator(fakeTime::currentTimeMs, sessionStartCounter::initiateSessionStart)
+
+    // First session on cold start
+    assertThat(sessionStartCounter.count).isEqualTo(1)
+
+    fakeTime.addTimeMs(SMALL_INTERVAL_MS)
+    sessionInitiator.appForegrounded()
+
+    assertThat(sessionStartCounter.count).isEqualTo(1)
+
+    sessionInitiator.appBackgrounded()
+    fakeTime.addTimeMs(SMALL_INTERVAL_MS)
+    sessionInitiator.appForegrounded()
+
+    assertThat(sessionStartCounter.count).isEqualTo(1)
+
+    assertThat(sessionStartCounter.count).isEqualTo(1)
+  }
+
+  companion object {
+    private const val SMALL_INTERVAL_MS = 3 * 1000L // not enough time to initiate a new session
+    private const val LARGE_INTERVAL_MS = 90 * 60 * 1000L // enough to initiate another session
+  }
+}