Use kotlin.time.Duration instead of Long for time intervals (#4733)

* Use kotlin.time.Duration instead of Long for time intervals

* Adjust test constants

* Simplify elapsedRealtime to always be millis precision

Author: mrober

firebase-sessions/firebase-sessions.gradle.kts

@@ -1,16 +1,18 @@
-// 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.
+/*
+ * 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.
+ */
 
 plugins {
   id("firebase-library")

firebase-sessions/src/androidTest/kotlin/com/google/firebase/sessions/FirebaseSessionsTests.kt

@@ -1,16 +1,18 @@
-// 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.
+/*
+ * 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
 

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

@@ -1,16 +1,18 @@
-// 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.
+/*
+ * 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
 
@@ -23,7 +25,7 @@ import com.google.firebase.ktx.app
 
 class FirebaseSessions internal constructor(firebaseApp: FirebaseApp) {
   init {
-    val sessionInitiator = SessionInitiator(System::currentTimeMillis, this::initiateSessionStart)
+    val sessionInitiator = SessionInitiator(WallClock::elapsedRealtime, this::initiateSessionStart)
     val context = firebaseApp.applicationContext.applicationContext
     if (context is Application) {
       context.registerActivityLifecycleCallbacks(sessionInitiator.activityLifecycleCallbacks)

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

@@ -19,6 +19,8 @@ package com.google.firebase.sessions
 import android.app.Activity
 import android.app.Application.ActivityLifecycleCallbacks
 import android.os.Bundle
+import kotlin.time.Duration
+import kotlin.time.Duration.Companion.minutes
 
 /**
  * The [SessionInitiator] is responsible for calling the [initiateSessionStart] callback whenever a
@@ -28,23 +30,23 @@ import android.os.Bundle
  * @hide
  */
 internal class SessionInitiator(
-  private val currentTimeMs: () -> Long,
+  private val elapsedRealtime: () -> Duration,
   private val initiateSessionStart: () -> Unit
 ) {
-  private var backgroundTimeMs = currentTimeMs()
-  private val sessionTimeoutMs = 30 * 60 * 1000L // TODO(mrober): Get session timeout from settings
+  private var backgroundTime = elapsedRealtime()
+  private val sessionTimeout = 30.minutes // TODO(mrober): Get session timeout from settings
 
   init {
     initiateSessionStart()
   }
 
   fun appBackgrounded() {
-    backgroundTimeMs = currentTimeMs()
+    backgroundTime = elapsedRealtime()
   }
 
   fun appForegrounded() {
-    val intervalMs = currentTimeMs() - backgroundTimeMs
-    if (intervalMs > sessionTimeoutMs) {
+    val interval = elapsedRealtime() - backgroundTime
+    if (interval > sessionTimeout) {
       initiateSessionStart()
     }
   }

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

@@ -0,0 +1,27 @@
+/*
+ * 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.os.SystemClock
+import kotlin.time.Duration
+import kotlin.time.Duration.Companion.milliseconds
+
+/** Util object for "wall clock" time functions. */
+internal object WallClock {
+  /** Gets the [Duration] elapsed in "wall clock" time since device boot. */
+  fun elapsedRealtime(): Duration = SystemClock.elapsedRealtime().milliseconds
+}

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

@@ -17,15 +17,17 @@
 package com.google.firebase.sessions
 
 import com.google.common.truth.Truth.assertThat
+import kotlin.time.Duration
+import kotlin.time.Duration.Companion.minutes
 import org.junit.Test
 
 class SessionInitiatorTest {
-  class FakeTime {
-    var currentTimeMs = 0L
+  class FakeClock {
+    var elapsed = Duration.ZERO
       private set
 
-    fun addTimeMs(intervalMs: Long) {
-      currentTimeMs += intervalMs
+    fun addInterval(interval: Duration) {
+      elapsed += interval
     }
   }
 
@@ -43,24 +45,24 @@ class SessionInitiatorTest {
     val sessionStartCounter = SessionStartCounter()
 
     // Simulate a cold start by simply constructing the SessionInitiator object
-    SessionInitiator({ 0 }, sessionStartCounter::initiateSessionStart)
+    SessionInitiator(Duration::ZERO, sessionStartCounter::initiateSessionStart)
 
     assertThat(sessionStartCounter.count).isEqualTo(1)
   }
 
   @Test
   fun appForegrounded_largeInterval_initiatesSession() {
-    val fakeTime = FakeTime()
+    val fakeClock = FakeClock()
     val sessionStartCounter = SessionStartCounter()
 
     val sessionInitiator =
-      SessionInitiator(fakeTime::currentTimeMs, sessionStartCounter::initiateSessionStart)
+      SessionInitiator(fakeClock::elapsed, 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)
+    fakeClock.addInterval(LARGE_INTERVAL)
     sessionInitiator.appForegrounded()
 
     // Another session initiated
@@ -69,17 +71,17 @@ class SessionInitiatorTest {
 
   @Test
   fun appForegrounded_smallInterval_doesNotInitiatesSession() {
-    val fakeTime = FakeTime()
+    val fakeClock = FakeClock()
     val sessionStartCounter = SessionStartCounter()
 
     val sessionInitiator =
-      SessionInitiator(fakeTime::currentTimeMs, sessionStartCounter::initiateSessionStart)
+      SessionInitiator(fakeClock::elapsed, 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)
+    fakeClock.addInterval(SMALL_INTERVAL)
     sessionInitiator.appForegrounded()
 
     // No new session
@@ -88,44 +90,44 @@ class SessionInitiatorTest {
 
   @Test
   fun appForegrounded_background_foreground_largeIntervals_initiatesSessions() {
-    val fakeTime = FakeTime()
+    val fakeClock = FakeClock()
     val sessionStartCounter = SessionStartCounter()
 
     val sessionInitiator =
-      SessionInitiator(fakeTime::currentTimeMs, sessionStartCounter::initiateSessionStart)
+      SessionInitiator(fakeClock::elapsed, sessionStartCounter::initiateSessionStart)
 
     assertThat(sessionStartCounter.count).isEqualTo(1)
 
-    fakeTime.addTimeMs(LARGE_INTERVAL_MS)
+    fakeClock.addInterval(LARGE_INTERVAL)
     sessionInitiator.appForegrounded()
 
     assertThat(sessionStartCounter.count).isEqualTo(2)
 
     sessionInitiator.appBackgrounded()
-    fakeTime.addTimeMs(LARGE_INTERVAL_MS)
+    fakeClock.addInterval(LARGE_INTERVAL)
     sessionInitiator.appForegrounded()
 
     assertThat(sessionStartCounter.count).isEqualTo(3)
   }
 
   @Test
   fun appForegrounded_background_foreground_smallIntervals_doesNotInitiateNewSessions() {
-    val fakeTime = FakeTime()
+    val fakeClock = FakeClock()
     val sessionStartCounter = SessionStartCounter()
 
     val sessionInitiator =
-      SessionInitiator(fakeTime::currentTimeMs, sessionStartCounter::initiateSessionStart)
+      SessionInitiator(fakeClock::elapsed, sessionStartCounter::initiateSessionStart)
 
     // First session on cold start
     assertThat(sessionStartCounter.count).isEqualTo(1)
 
-    fakeTime.addTimeMs(SMALL_INTERVAL_MS)
+    fakeClock.addInterval(SMALL_INTERVAL)
     sessionInitiator.appForegrounded()
 
     assertThat(sessionStartCounter.count).isEqualTo(1)
 
     sessionInitiator.appBackgrounded()
-    fakeTime.addTimeMs(SMALL_INTERVAL_MS)
+    fakeClock.addInterval(SMALL_INTERVAL)
     sessionInitiator.appForegrounded()
 
     assertThat(sessionStartCounter.count).isEqualTo(1)
@@ -134,7 +136,7 @@ class SessionInitiatorTest {
   }
 
   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
+    private val SMALL_INTERVAL = 29.minutes // not enough time to initiate a new session
+    private val LARGE_INTERVAL = 31.minutes // enough to initiate another session
   }
 }