Rename SessionState to SessionDetails

Author: mrober

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

@@ -17,7 +17,7 @@
 package com.google.firebase.sessions
 
 /**
- * Contains the relevant information around an App Quality Session.
+ * Contains the relevant information around a session event.
  *
  * See go/app-quality-unified-session-definition for more details. Keep in sync with
  * https://github.com/firebase/firebase-ios-sdk/blob/master/FirebaseSessions/ProtoSupport/Protos/sessions.proto
@@ -31,14 +31,14 @@ internal data class SessionEvent(
   val sessionData: SessionInfo,
 ) {
   companion object {
-    fun sessionStart(sessionState: SessionState) =
+    fun sessionStart(sessionDetails: SessionDetails) =
       SessionEvent(
         eventType = EventType.SESSION_START,
         sessionData =
           SessionInfo(
-            sessionState.sessionId,
-            sessionState.firstSessionId,
-            sessionState.sessionIndex,
+            sessionDetails.sessionId,
+            sessionDetails.firstSessionId,
+            sessionDetails.sessionIndex,
           ),
       )
   }

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

@@ -19,11 +19,11 @@ package com.google.firebase.sessions
 import java.util.UUID
 
 /**
- * [SessionState] is a data class responsible for storing information about the current Session.
+ * [SessionDetails] is a data class responsible for storing information about the current Session.
  *
  * @hide
  */
-internal data class SessionState(
+internal data class SessionDetails(
   val sessionId: String,
   val firstSessionId: String,
   val collectEvents: Boolean,
@@ -32,16 +32,16 @@ internal data class SessionState(
 
 /**
  * The [SessionGenerator] is responsible for generating the Session ID, and keeping the
- * [SessionState] up to date with the latest values.
+ * [SessionDetails] up to date with the latest values.
  *
  * @hide
  */
 internal class SessionGenerator(private var collectEvents: Boolean) {
   private var firstSessionId = ""
   private var sessionIndex: Int = -1
 
-  private var thisSession: SessionState =
-    SessionState(
+  private var thisSession: SessionDetails =
+    SessionDetails(
       sessionId = "",
       firstSessionId = "",
       collectEvents,
@@ -50,7 +50,7 @@ internal class SessionGenerator(private var collectEvents: Boolean) {
 
   // Generates a new Session ID. If there was already a generated Session ID
   // from the last session during the app's lifecycle, it will also set the last Session ID
-  fun generateNewSession(): SessionState {
+  fun generateNewSession(): SessionDetails {
     val newSessionId = UUID.randomUUID().toString().replace("-", "").lowercase()
 
     // If firstSessionId is set, use it. Otherwise set it to the
@@ -60,11 +60,11 @@ internal class SessionGenerator(private var collectEvents: Boolean) {
     sessionIndex += 1
 
     thisSession =
-      SessionState(sessionId = newSessionId, firstSessionId, collectEvents, sessionIndex)
+      SessionDetails(sessionId = newSessionId, firstSessionId, collectEvents, sessionIndex)
 
     return thisSession
   }
 
-  val currentSession: SessionState
+  val currentSession: SessionDetails
     get() = thisSession
 }

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

@@ -21,16 +21,16 @@ import org.junit.Test
 
 class SessionEventTest {
   @Test
-  fun sessionStart_populatesSessionStateCorrectly() {
-    val sessionState =
-      SessionState(
+  fun sessionStart_populatesSessionDetailsCorrectly() {
+    val sessionDetails =
+      SessionDetails(
         sessionId = "a1b2c3",
         firstSessionId = "a1a1a1",
         collectEvents = true,
         sessionIndex = 3,
       )
 
-    val sessionEvent = SessionEvent.sessionStart(sessionState)
+    val sessionEvent = SessionEvent.sessionStart(sessionDetails)
 
     assertThat(sessionEvent)
       .isEqualTo(

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

@@ -47,7 +47,7 @@ class SessionGeneratorTest {
   }
 
   @Test
-  fun generateNewSessionID_generatesValidSessionState() {
+  fun generateNewSessionID_generatesValidSessionDetails() {
     val sessionGenerator = SessionGenerator(collectEvents = true)
 
     sessionGenerator.generateNewSession()
@@ -68,32 +68,32 @@ class SessionGeneratorTest {
 
     sessionGenerator.generateNewSession()
 
-    val firstSessionState = sessionGenerator.currentSession
+    val firstSessionDetails = sessionGenerator.currentSession
 
-    assertThat(isValidSessionId(firstSessionState.sessionId)).isTrue()
-    assertThat(isValidSessionId(firstSessionState.firstSessionId)).isTrue()
-    assertThat(firstSessionState.firstSessionId).isEqualTo(firstSessionState.sessionId)
-    assertThat(firstSessionState.sessionIndex).isEqualTo(0)
+    assertThat(isValidSessionId(firstSessionDetails.sessionId)).isTrue()
+    assertThat(isValidSessionId(firstSessionDetails.firstSessionId)).isTrue()
+    assertThat(firstSessionDetails.firstSessionId).isEqualTo(firstSessionDetails.sessionId)
+    assertThat(firstSessionDetails.sessionIndex).isEqualTo(0)
 
     sessionGenerator.generateNewSession()
-    val secondSessionState = sessionGenerator.currentSession
+    val secondSessionDetails = sessionGenerator.currentSession
 
-    assertThat(isValidSessionId(secondSessionState.sessionId)).isTrue()
-    assertThat(isValidSessionId(secondSessionState.firstSessionId)).isTrue()
+    assertThat(isValidSessionId(secondSessionDetails.sessionId)).isTrue()
+    assertThat(isValidSessionId(secondSessionDetails.firstSessionId)).isTrue()
     // Ensure the new firstSessionId is equal to the first Session ID from earlier
-    assertThat(secondSessionState.firstSessionId).isEqualTo(firstSessionState.sessionId)
+    assertThat(secondSessionDetails.firstSessionId).isEqualTo(firstSessionDetails.sessionId)
     // Session Index should increase
-    assertThat(secondSessionState.sessionIndex).isEqualTo(1)
+    assertThat(secondSessionDetails.sessionIndex).isEqualTo(1)
 
     // Do a third round just in case
     sessionGenerator.generateNewSession()
-    val thirdSessionState = sessionGenerator.currentSession
+    val thirdSessionDetails = sessionGenerator.currentSession
 
-    assertThat(isValidSessionId(thirdSessionState.sessionId)).isTrue()
-    assertThat(isValidSessionId(thirdSessionState.firstSessionId)).isTrue()
+    assertThat(isValidSessionId(thirdSessionDetails.sessionId)).isTrue()
+    assertThat(isValidSessionId(thirdSessionDetails.firstSessionId)).isTrue()
     // Ensure the new firstSessionId is equal to the first Session ID from earlier
-    assertThat(thirdSessionState.firstSessionId).isEqualTo(firstSessionState.sessionId)
+    assertThat(thirdSessionDetails.firstSessionId).isEqualTo(firstSessionDetails.sessionId)
     // Session Index should increase
-    assertThat(thirdSessionState.sessionIndex).isEqualTo(2)
+    assertThat(thirdSessionDetails.sessionIndex).isEqualTo(2)
   }
 }