Merge pull request #329 from embrace-io/rename-services

Combine & rename background activity + session services

embrace-android-sdk/src/main/java/io/embrace/android/embracesdk/injection/SessionModule.kt

@@ -3,11 +3,9 @@ package io.embrace.android.embracesdk.injection
 import io.embrace.android.embracesdk.ndk.NativeModule
 import io.embrace.android.embracesdk.session.caching.PeriodicBackgroundActivityCacher
 import io.embrace.android.embracesdk.session.caching.PeriodicSessionCacher
-import io.embrace.android.embracesdk.session.message.BackgroundActivityService
-import io.embrace.android.embracesdk.session.message.EmbraceBackgroundActivityService
-import io.embrace.android.embracesdk.session.message.EmbraceSessionService
+import io.embrace.android.embracesdk.session.message.PayloadFactory
+import io.embrace.android.embracesdk.session.message.PayloadFactoryImpl
 import io.embrace.android.embracesdk.session.message.PayloadMessageCollator
-import io.embrace.android.embracesdk.session.message.SessionService
 import io.embrace.android.embracesdk.session.orchestrator.OrchestratorBoundaryDelegate
 import io.embrace.android.embracesdk.session.orchestrator.SessionOrchestrator
 import io.embrace.android.embracesdk.session.orchestrator.SessionOrchestratorImpl
@@ -18,8 +16,7 @@ import io.embrace.android.embracesdk.worker.WorkerName
 import io.embrace.android.embracesdk.worker.WorkerThreadModule
 
 internal interface SessionModule {
- val sessionService: SessionService
- val backgroundActivityService: BackgroundActivityService?
+ val payloadFactory: PayloadFactory
  val payloadMessageCollator: PayloadMessageCollator
  val sessionPropertiesService: SessionPropertiesService
  val sessionOrchestrator: SessionOrchestrator
@@ -90,15 +87,8 @@ internal class SessionModuleImpl(
  )
  }
 
- override val sessionService: SessionService by singleton {
- EmbraceSessionService(
- deliveryModule.deliveryService,
- payloadMessageCollator
- )
- }
-
- override val backgroundActivityService: BackgroundActivityService? by singleton {
- EmbraceBackgroundActivityService(
+ override val payloadFactory: PayloadFactory by singleton {
+ PayloadFactoryImpl(
  deliveryModule.deliveryService,
  payloadMessageCollator
  )
@@ -119,8 +109,7 @@ internal class SessionModuleImpl(
  override val sessionOrchestrator: SessionOrchestrator by singleton(LoadType.EAGER) {
  SessionOrchestratorImpl(
  essentialServiceModule.processStateService,
- sessionService,
- backgroundActivityService,
+ payloadFactory,
  initModule.clock,
  essentialServiceModule.configService,
  essentialServiceModule.sessionIdTracker,

embrace-android-sdk/src/main/java/io/embrace/android/embracesdk/session/lifecycle/ActivityLifecycleTracker.kt

@@ -7,7 +7,6 @@ import io.embrace.android.embracesdk.annotation.StartupActivity
 import io.embrace.android.embracesdk.capture.orientation.OrientationService
 import io.embrace.android.embracesdk.logging.InternalEmbraceLogger
 import io.embrace.android.embracesdk.logging.InternalStaticEmbraceLogger
-import io.embrace.android.embracesdk.session.message.SessionService
 import io.embrace.android.embracesdk.utils.stream
 import java.lang.ref.WeakReference
 import java.util.concurrent.CopyOnWriteArrayList
@@ -170,16 +169,8 @@ internal class ActivityLifecycleTracker(
  }
 
  override fun addListener(listener: ActivityLifecycleListener) {
- // assumption: we always need to run the Session service first, then everything else,
- // because otherwise the session envelope will not be created. The ActivityListener
- // could use separating from session handling, but that's a bigger change.
- val priority = listener is SessionService
  if (!listeners.contains(listener)) {
- if (priority) {
- listeners.add(0, listener)
- } else {
- listeners.addIfAbsent(listener)
- }
+ listeners.addIfAbsent(listener)
  }
  }
 

embrace-android-sdk/src/main/java/io/embrace/android/embracesdk/session/message/SessionService.kt → embrace-android-sdk/src/main/java/io/embrace/android/embracesdk/session/message/PayloadFactory.kt

@@ -3,7 +3,30 @@ package io.embrace.android.embracesdk.session.message
 import io.embrace.android.embracesdk.payload.Session
 import io.embrace.android.embracesdk.payload.SessionMessage
 
-internal interface SessionService {
+/**
+ * Factory that creates session + background activity payloads.
+ */
+internal interface PayloadFactory {
+
+ /**
+ * Ends a background activity in response to a state event.
+ */
+ fun startBackgroundActivityWithState(timestamp: Long, coldStart: Boolean): Session
+
+ /**
+ * Handles an uncaught exception, ending the session and saving the activity to disk.
+ */
+ fun endBackgroundActivityWithCrash(initial: Session, timestamp: Long, crashId: String)
+
+ /**
+ * Starts a background activity in response to a state event.
+ */
+ fun endBackgroundActivityWithState(initial: Session, timestamp: Long)
+
+ /**
+ * Provides a snapshot of the active background activity
+ */
+ fun snapshotBackgroundActivity(initial: Session, timestamp: Long): SessionMessage
 
  /**
  * Starts a session in response to a state event.

embrace-android-sdk/src/main/java/io/embrace/android/embracesdk/session/message/EmbraceSessionService.kt → embrace-android-sdk/src/main/java/io/embrace/android/embracesdk/session/message/PayloadFactoryImpl.kt

@@ -6,10 +6,68 @@ import io.embrace.android.embracesdk.payload.Session.LifeEventType
 import io.embrace.android.embracesdk.payload.SessionMessage
 import io.embrace.android.embracesdk.session.orchestrator.SessionSnapshotType
 
-internal class EmbraceSessionService(
+internal class PayloadFactoryImpl(
  private val deliveryService: DeliveryService,
  private val payloadMessageCollator: PayloadMessageCollator
-) : SessionService {
+) : PayloadFactory {
+
+ override fun startBackgroundActivityWithState(timestamp: Long, coldStart: Boolean): Session {
+ // kept for backwards compat. the backend expects the start time to be 1 ms greater
+ // than the adjacent session, and manually adjusts.
+ val time = when {
+ coldStart -> timestamp
+ else -> timestamp + 1
+ }
+ return payloadMessageCollator.buildInitialSession(
+ InitialEnvelopeParams.BackgroundActivityParams(
+ coldStart = coldStart,
+ startType = LifeEventType.BKGND_STATE,
+ startTime = time
+ )
+ )
+ }
+
+ override fun endBackgroundActivityWithState(initial: Session, timestamp: Long) {
+ // kept for backwards compat. the backend expects the start time to be 1 ms greater
+ // than the adjacent session, and manually adjusts.
+ val message = payloadMessageCollator.buildFinalBackgroundActivityMessage(
+ FinalEnvelopeParams.BackgroundActivityParams(
+ initial = initial,
+ endTime = timestamp - 1,
+ lifeEventType = LifeEventType.BKGND_STATE
+ )
+ )
+ deliveryService.saveBackgroundActivity(message)
+ deliveryService.sendBackgroundActivities()
+ }
+
+ override fun endBackgroundActivityWithCrash(
+ initial: Session,
+ timestamp: Long,
+ crashId: String
+ ) {
+ val message = payloadMessageCollator.buildFinalBackgroundActivityMessage(
+ FinalEnvelopeParams.BackgroundActivityParams(
+ initial = initial,
+ endTime = timestamp,
+ lifeEventType = LifeEventType.BKGND_STATE,
+ crashId = crashId
+ )
+ )
+ deliveryService.saveBackgroundActivity(message)
+ }
+
+ override fun snapshotBackgroundActivity(initial: Session, timestamp: Long): SessionMessage {
+ val message = payloadMessageCollator.buildFinalBackgroundActivityMessage(
+ FinalEnvelopeParams.BackgroundActivityParams(
+ initial = initial,
+ endTime = timestamp,
+ lifeEventType = null
+ )
+ )
+ deliveryService.saveBackgroundActivity(message)
+ return message
+ }
 
  override fun startSessionWithState(timestamp: Long, coldStart: Boolean): Session {
  return payloadMessageCollator.buildInitialSession(

embrace-android-sdk/src/main/java/io/embrace/android/embracesdk/session/orchestrator/SessionOrchestratorImpl.kt

@@ -11,13 +11,11 @@ import io.embrace.android.embracesdk.session.caching.PeriodicSessionCacher
 import io.embrace.android.embracesdk.session.id.SessionIdTracker
 import io.embrace.android.embracesdk.session.lifecycle.ProcessState
 import io.embrace.android.embracesdk.session.lifecycle.ProcessStateService
-import io.embrace.android.embracesdk.session.message.BackgroundActivityService
-import io.embrace.android.embracesdk.session.message.SessionService
+import io.embrace.android.embracesdk.session.message.PayloadFactory
 
 internal class SessionOrchestratorImpl(
  private val processStateService: ProcessStateService,
- private val sessionService: SessionService,
- backgroundActivityServiceImpl: BackgroundActivityService?,
+ private val payloadFactory: PayloadFactory,
  private val clock: Clock,
  private val configService: ConfigService,
  private val sessionIdTracker: SessionIdTracker,
@@ -38,10 +36,10 @@ internal class SessionOrchestratorImpl(
  else -> ProcessState.FOREGROUND
  }
 
- private val backgroundActivityGate = ConfigGate(backgroundActivityServiceImpl) {
+ private val backgroundActivityGate = ConfigGate(payloadFactory) {
  configService.isBackgroundActivityCaptureEnabled()
  }
- private val backgroundActivityService: BackgroundActivityService?
+ private val backgroundActivityFactory: PayloadFactory?
  get() = backgroundActivityGate.getService()
 
  init {
@@ -57,9 +55,9 @@ internal class SessionOrchestratorImpl(
  timestamp = timestamp,
  newSessionAction = {
  if (state == ProcessState.BACKGROUND) {
- backgroundActivityService?.startBackgroundActivityWithState(timestamp, true)
+ backgroundActivityFactory?.startBackgroundActivityWithState(timestamp, true)
  } else {
- sessionService.startSessionWithState(timestamp, true)
+ payloadFactory.startSessionWithState(timestamp, true)
  }
  }
  )
@@ -70,10 +68,10 @@ internal class SessionOrchestratorImpl(
  transitionType = TransitionType.ON_FOREGROUND,
  timestamp = timestamp,
  oldSessionAction = { initial: Session ->
- backgroundActivityService?.endBackgroundActivityWithState(initial, timestamp)
+ backgroundActivityFactory?.endBackgroundActivityWithState(initial, timestamp)
  },
  newSessionAction = {
- sessionService.startSessionWithState(timestamp, coldStart)
+ payloadFactory.startSessionWithState(timestamp, coldStart)
  },
  earlyTerminationCondition = {
  return@transitionState shouldRunOnForeground(state)
@@ -86,10 +84,10 @@ internal class SessionOrchestratorImpl(
  transitionType = TransitionType.ON_BACKGROUND,
  timestamp = timestamp,
  oldSessionAction = { initial: Session ->
- sessionService.endSessionWithState(initial, timestamp)
+ payloadFactory.endSessionWithState(initial, timestamp)
  },
  newSessionAction = {
- backgroundActivityService?.startBackgroundActivityWithState(timestamp, false)
+ backgroundActivityFactory?.startBackgroundActivityWithState(timestamp, false)
  },
  earlyTerminationCondition = {
  return@transitionState shouldRunOnBackground(state)
@@ -104,10 +102,10 @@ internal class SessionOrchestratorImpl(
  timestamp = timestamp,
  clearUserInfo = clearUserInfo,
  oldSessionAction = { initial: Session ->
- sessionService.endSessionWithManual(initial, timestamp)
+ payloadFactory.endSessionWithManual(initial, timestamp)
  },
  newSessionAction = {
- sessionService.startSessionWithManual(timestamp)
+ payloadFactory.startSessionWithManual(timestamp)
  },
  earlyTerminationCondition = {
  return@transitionState shouldEndManualSession(
@@ -127,13 +125,13 @@ internal class SessionOrchestratorImpl(
  timestamp = timestamp,
  oldSessionAction = { initial: Session ->
  if (processStateService.isInBackground) {
- backgroundActivityService?.endBackgroundActivityWithCrash(
+ backgroundActivityFactory?.endBackgroundActivityWithCrash(
  initial,
  timestamp,
  crashId
  )
  } else {
- sessionService.endSessionWithCrash(initial, timestamp, crashId)
+ payloadFactory.endSessionWithCrash(initial, timestamp, crashId)
  }
  }
  )
@@ -229,7 +227,7 @@ internal class SessionOrchestratorImpl(
  ProcessState.FOREGROUND -> {
  periodicSessionCacher.start {
  synchronized(lock) {
- sessionService.snapshotSession(newState, clock.now())
+ payloadFactory.snapshotSession(newState, clock.now())
  }
  }
  }
@@ -240,7 +238,7 @@ internal class SessionOrchestratorImpl(
  private fun scheduleBackgroundActivitySave(initial: Session) {
  periodicBackgroundActivityCacher.scheduleSave {
  synchronized(lock) {
- backgroundActivityService?.snapshotBackgroundActivity(initial, clock.now())
+ backgroundActivityFactory?.snapshotBackgroundActivity(initial, clock.now())
  }
  }
  }