TODO: Learner analytics impl

app/BUILD.bazel

@@ -751,6 +751,7 @@ kt_android_library(
         "//domain/src/main/java/org/oppia/android/domain/oppialogger/loguploader:worker_module",
         "//domain/src/main/java/org/oppia/android/domain/profile:profile_management_controller",
         "//model:arguments_java_proto_lite",
+        "//domain/src/main/java/org/oppia/android/domain/oppialogger/analytics:prod_module",
         "//app/src/main/java/org/oppia/android/app/testing/activity:test_activity",
         "//third_party:androidx_databinding_databinding-adapters",
         "//third_party:androidx_databinding_databinding-common",

app/src/main/java/org/oppia/android/app/application/ApplicationComponent.kt

@@ -30,6 +30,8 @@ import org.oppia.android.domain.hintsandsolution.HintsAndSolutionDebugModule
 import org.oppia.android.domain.onboarding.ExpirationMetaDataRetrieverModule
 import org.oppia.android.domain.oppialogger.ApplicationStartupListener
 import org.oppia.android.domain.oppialogger.LogStorageModule
+import org.oppia.android.domain.oppialogger.LoggingIdentifierModule
+import org.oppia.android.domain.oppialogger.analytics.ApplicationLifecycleModule
 import org.oppia.android.domain.oppialogger.exceptions.UncaughtExceptionLoggerModule
 import org.oppia.android.domain.oppialogger.loguploader.LogUploadWorkerModule
 import org.oppia.android.domain.platformparameter.PlatformParameterModule
@@ -44,6 +46,7 @@ import org.oppia.android.util.caching.CachingModule
 import org.oppia.android.util.gcsresource.GcsResourceModule
 import org.oppia.android.util.locale.LocaleProdModule
 import org.oppia.android.util.logging.LoggerModule
+import org.oppia.android.util.logging.SyncStatusModule
 import org.oppia.android.util.logging.firebase.DebugLogReportingModule
 import org.oppia.android.util.logging.firebase.FirebaseLogUploaderModule
 import org.oppia.android.util.networking.NetworkConnectionDebugUtilModule
@@ -52,6 +55,7 @@ import org.oppia.android.util.parser.html.HtmlParserEntityTypeModule
 import org.oppia.android.util.parser.image.GlideImageLoaderModule
 import org.oppia.android.util.parser.image.ImageParsingModule
 import org.oppia.android.util.system.OppiaClockModule
+import org.oppia.android.util.system.UserIdProdModule
 import org.oppia.android.util.threading.DispatcherModule
 import javax.inject.Provider
 import javax.inject.Singleton
@@ -93,9 +97,10 @@ import javax.inject.Singleton
     DeveloperOptionsModule::class, PlatformParameterSyncUpWorkerModule::class,
     NetworkConnectionUtilDebugModule::class, NetworkConfigProdModule::class, AssetModule::class,
     LocaleProdModule::class, ActivityRecreatorProdModule::class,
+    UserIdProdModule::class, ApplicationLifecycleModule::class,
     // TODO(#59): Remove this module once we completely migrate to Bazel from Gradle as we can then
     //  directly exclude debug files from the build and thus won't be requiring this module.
-    NetworkConnectionDebugUtilModule::class
+    NetworkConnectionDebugUtilModule::class, LoggingIdentifierModule::class, SyncStatusModule::class
   ]
 )
 interface ApplicationComponent : ApplicationInjector {

domain/BUILD.bazel

@@ -107,6 +107,7 @@ kt_android_library(
         "//domain/src/main/java/org/oppia/android/domain/oppialogger:startup_listener",
         "//domain/src/main/java/org/oppia/android/domain/oppialogger/exceptions:controller",
         "//domain/src/main/java/org/oppia/android/domain/oppialogger/loguploader:worker_factory",
+        "//domain/src/main/java/org/oppia/android/domain/profile:profile_management_controller",
         "//domain/src/main/java/org/oppia/android/domain/state:state_deck",
         "//domain/src/main/java/org/oppia/android/domain/state:state_graph",
         "//domain/src/main/java/org/oppia/android/domain/state:state_list",
@@ -191,6 +192,8 @@ TEST_DEPS = [
     "//domain/src/main/java/org/oppia/android/domain/testing/oppialogger/loguploader:fake_log_uploader",
     "//testing",
     "//testing/src/main/java/org/oppia/android/testing/data:data_provider_test_monitor",
+    "//testing/src/main/java/org/oppia/android/testing/logging:fake_user_id_generator",
+    "//testing/src/main/java/org/oppia/android/testing/logging:user_id_test_module",
     "//testing/src/main/java/org/oppia/android/testing/network:network",
     "//testing/src/main/java/org/oppia/android/testing/network:test_module",
     "//testing/src/main/java/org/oppia/android/testing/platformparameter:test_module",

domain/build.gradle

@@ -88,6 +88,8 @@ dependencies {
       'androidx.appcompat:appcompat:1.0.2',
       'androidx.exifinterface:exifinterface:1.0.0-rc01',
       'androidx.lifecycle:lifecycle-livedata-ktx:2.2.0-alpha03',
+      'androidx.lifecycle:lifecycle-extensions:2.0.0',
+      'androidx.lifecycle:lifecycle-runtime-ktx:2.2.0-alpha03',
       'androidx.work:work-runtime-ktx:2.4.0',
       'com.google.dagger:dagger:2.24',
       'com.google.firebase:firebase-analytics-ktx:17.5.0',

domain/src/main/java/org/oppia/android/domain/exploration/ExplorationProgressController.kt

@@ -2,24 +2,29 @@ package org.oppia.android.domain.exploration
 
 import androidx.lifecycle.LiveData
 import androidx.lifecycle.MutableLiveData
+import androidx.lifecycle.Transformations
 import org.oppia.android.app.model.AnswerOutcome
 import org.oppia.android.app.model.CheckpointState
 import org.oppia.android.app.model.EphemeralState
 import org.oppia.android.app.model.Exploration
 import org.oppia.android.app.model.ExplorationCheckpoint
 import org.oppia.android.app.model.HelpIndex
+import org.oppia.android.app.model.Profile
 import org.oppia.android.app.model.ProfileId
 import org.oppia.android.app.model.UserAnswer
 import org.oppia.android.domain.classify.AnswerClassificationController
 import org.oppia.android.domain.exploration.lightweightcheckpointing.ExplorationCheckpointController
 import org.oppia.android.domain.hintsandsolution.HintHandler
+import org.oppia.android.domain.oppialogger.LoggingIdentifierController
 import org.oppia.android.domain.oppialogger.OppiaLogger
 import org.oppia.android.domain.oppialogger.exceptions.ExceptionsController
+import org.oppia.android.domain.profile.ProfileManagementController
 import org.oppia.android.domain.topic.StoryProgressController
 import org.oppia.android.domain.translation.TranslationController
 import org.oppia.android.util.data.AsyncDataSubscriptionManager
 import org.oppia.android.util.data.AsyncResult
 import org.oppia.android.util.data.DataProvider
+import org.oppia.android.util.data.DataProviders.Companion.toLiveData
 import org.oppia.android.util.data.DataProviders.Companion.transformAsync
 import org.oppia.android.util.locale.OppiaLocale
 import org.oppia.android.util.system.OppiaClock
@@ -50,7 +55,9 @@ class ExplorationProgressController @Inject constructor(
   private val oppiaClock: OppiaClock,
   private val oppiaLogger: OppiaLogger,
   private val hintHandlerFactory: HintHandler.Factory,
-  private val translationController: TranslationController
+  private val translationController: TranslationController,
+  private val loggingIdentifierController: LoggingIdentifierController,
+  private val profileManagementController: ProfileManagementController
 ) : HintHandler.HintMonitor {
   // TODO(#179): Add support for parameters.
   // TODO(#3622): Update the internal locking of this controller to use something like an in-memory
@@ -100,6 +107,15 @@ class ExplorationProgressController @Inject constructor(
 
   /** Indicates that the current exploration being played is now completed. */
   internal fun finishExplorationAsync() {
+    oppiaLogger.createFinishExplorationContext(
+      oppiaLogger.createExplorationDetailsContext(
+        getSessionId() ?: "",
+        explorationProgress.currentExplorationId,
+        explorationProgress.currentExploration.version.toString(),
+        explorationProgress.stateDeck.getCurrentState().name,
+        oppiaLogger.createLearnerDetailsContext(getLearnerId() ?: "")
+      )
+    )
     explorationProgressLock.withLock {
       check(explorationProgress.playStage != ExplorationProgress.PlayStage.NOT_PLAYING) {
         "Cannot finish playing an exploration that hasn't yet been started"
@@ -688,4 +704,41 @@ class ExplorationProgressController @Inject constructor(
       lastPlayedTimestamp
     )
   }
+
+  private fun getSessionId(): String? {
+    return Transformations.map(
+      loggingIdentifierController.getSessionId().toLiveData(),
+      ::processGetSessionIdResult
+    ).value
+  }
+
+  private fun processGetSessionIdResult(sessionIdResult: AsyncResult<String>): String {
+    if (sessionIdResult.isFailure()) {
+      oppiaLogger.e(
+        "ExplorationProgressController",
+        "Failed to retrieve session id",
+        sessionIdResult.getErrorOrNull()!!
+      )
+    }
+    return sessionIdResult.getOrDefault("")
+  }
+
+  private fun getLearnerId(): String? {
+    // TODO: This isn't going to work since the live data won't be processed.
+    return Transformations.map(
+      profileManagementController.getProfile(explorationProgress.currentProfileId).toLiveData(),
+      ::processGetProfileResult
+    ).value?.learnerId
+  }
+
+  private fun processGetProfileResult(profileResult: AsyncResult<Profile>): Profile {
+    if (profileResult.isFailure()) {
+      oppiaLogger.e(
+        "ExplorationProgressController",
+        "Failed to retrieve profile",
+        profileResult.getErrorOrNull()!!
+      )
+    }
+    return profileResult.getOrDefault(Profile.getDefaultInstance())
+  }
 }

domain/src/main/java/org/oppia/android/domain/oppialogger/ApplicationIdSeed.kt

@@ -0,0 +1,13 @@
+package org.oppia.android.domain.oppialogger
+
+import javax.inject.Qualifier
+
+/**
+ * Corresponds to an injectable application-level [Long] that provides a static seed that may be
+ * used for generating seeds that must be consistent for the lifetime of the application (but not
+ * necessarily across application instances).
+ *
+ * Tests may override the value corresponding to this qualifier in the Dagger graph to ensure
+ * deterministic behavior for corresponding random functions that depend on it.
+ */
+@Qualifier annotation class ApplicationIdSeed

domain/src/main/java/org/oppia/android/domain/oppialogger/BUILD.bazel

@@ -5,13 +5,25 @@ Package for providing logging support.
 load("@dagger//:workspace_defs.bzl", "dagger_rules")
 load("@io_bazel_rules_kotlin//kotlin:kotlin.bzl", "kt_android_library")
 
+kt_android_library(
+    name = "application_id_seed",
+    srcs = [
+        "ApplicationIdSeed.kt",
+    ],
+    visibility = ["//domain:__subpackages__"],
+    deps = [
+        "//third_party:javax_inject_javax_inject",
+    ],
+)
+
 kt_android_library(
     name = "oppia_logger",
     srcs = [
         "OppiaLogger.kt",
     ],
     visibility = ["//domain:__subpackages__"],
     deps = [
+        ":logging_identifier_controller",
         "//domain/src/main/java/org/oppia/android/domain/oppialogger/analytics:controller",
         "//model:event_logger_java_proto_lite",
         "//utility/src/main/java/org/oppia/android/util/logging:console_logger",
@@ -27,13 +39,36 @@ kt_android_library(
 )
 
 kt_android_library(
-    name = "storage_module",
+    name = "logging_identifier_controller",
+    srcs = [
+        "LoggingIdentifierController.kt",
+    ],
+    visibility = ["//:oppia_api_visibility"],
+    deps = [
+        ":application_id_seed",
+        "//domain/src/main/java/org/oppia/android/domain/util:extensions",
+        "//third_party:com_google_firebase_firebase-installations",
+        "//utility/src/main/java/org/oppia/android/util/data:async_data_subscription_manager",
+        "//utility/src/main/java/org/oppia/android/util/data:data_providers",
+        "//utility/src/main/java/org/oppia/android/util/locale:oppia_locale",
+        "//utility/src/main/java/org/oppia/android/util/system:user_id_generator",
+    ],
+)
+
+kt_android_library(
+    name = "prod_module",
     srcs = [
         "LogStorageModule.kt",
+        "LoggingIdentifierModule.kt",
+    ],
+    visibility = [
+        "//:oppia_prod_module_visibility",
+        "//domain/src/main/java/org/oppia/android/domain/oppialogger:__subpackages__",
     ],
-    visibility = ["//domain/src/main/java/org/oppia/android/domain/oppialogger:__subpackages__"],
     deps = [
+        ":application_id_seed",
         ":dagger",
+        "//utility/src/main/java/org/oppia/android/util/system:oppia_clock",
     ],
 )
 

domain/src/main/java/org/oppia/android/domain/oppialogger/LoggingIdentifierController.kt

@@ -0,0 +1,116 @@
+package org.oppia.android.domain.oppialogger
+
+import android.content.Context
+import android.provider.Settings
+import com.google.firebase.installations.FirebaseInstallations
+import org.oppia.android.domain.util.getSecureString
+import org.oppia.android.util.data.AsyncDataSubscriptionManager
+import org.oppia.android.util.data.AsyncResult
+import org.oppia.android.util.data.DataProvider
+import org.oppia.android.util.data.DataProviders
+import org.oppia.android.util.locale.OppiaLocale
+import org.oppia.android.util.system.UserIdGenerator
+import java.io.File
+import java.security.MessageDigest
+import java.util.Random
+import java.util.concurrent.atomic.AtomicReference
+import javax.inject.Inject
+import javax.inject.Singleton
+
+private const val SESSION_ID_DATA_PROVIDER_ID = "LoggingIdentifierController.session_id"
+private const val FIREBASE_ID_DATA_PROVIDER_ID = "LoggingIdentifierController.firebase_id"
+
+/** Controller that handles logging identifiers related operations. */
+@Singleton
+class LoggingIdentifierController @Inject constructor(
+  private val context: Context,
+  private val dataProviders: DataProviders,
+  private val asyncDataSubscriptionManager: AsyncDataSubscriptionManager,
+  @ApplicationIdSeed private val applicationIdSeed: Long,
+  private val userIdGenerator: UserIdGenerator,
+  private val machineLocale: OppiaLocale.MachineLocale
+) {
+  private val learnerIdRandom by lazy { Random(applicationIdSeed) }
+
+  // TODO(#4249): Replace this with a StateFlow & the DataProvider with a StateFlow-converted one.
+  private var sessionId = AtomicReference(computeSessionId())
+
+  /**
+   * Creates and returns a unique identifier which will be used to identify the current learner.
+   *
+   * Each call to this function will return a unique learner ID, so it's up to the caller to ensure
+   * long-lived IDs are properly persisted.
+   */
+  fun createLearnerId(): String = machineLocale.run {
+    "%08x".formatForMachines(learnerIdRandom.nextInt())
+  }
+
+  /**
+   * Returns a data provider that provides a one-time string which acts as a unique device ID for
+   * the current installation environment.
+   *
+   * Note that the returned ID is *not* guaranteed to be unique across devices, or even across app
+   * installations. It's an approximation for a hardware-based unique ID which is expected to be
+   * suitable for short-term user studies.
+   */
+  fun getDeviceId(): DataProvider<String> = retrieveApproximatedUniqueDeviceId()
+
+  /**
+   * Returns an in-memory data provider pointing to a class variable of [sessionId].
+   *
+   * This ID is unique to each session. A session starts when an exploration begins.
+   */
+  fun getSessionId(): DataProvider<String> {
+    return dataProviders.createInMemoryDataProvider(SESSION_ID_DATA_PROVIDER_ID) {
+      return@createInMemoryDataProvider sessionId.get()
+    }
+  }
+
+  /**
+   * Regenerates [sessionId] and notifies the data provider.
+   *
+   * The [sessionId] is generally updated when:
+   *  1. An exploration is started/resumed/started-over.
+   *  2. Inactivity duration exceeds 30 mins.
+   */
+  fun updateSessionId() {
+    sessionId.set(computeSessionId())
+    asyncDataSubscriptionManager.notifyChangeAsync(SESSION_ID_DATA_PROVIDER_ID)
+  }
+
+  private fun computeSessionId(): String = userIdGenerator.generateRandomUserId()
+
+  private fun retrieveApproximatedUniqueDeviceId(): DataProvider<String> {
+    // TODO(#4249): Replace this with a StateFlow, too, for simplicity.
+    // Per https://developer.android.com/training/articles/user-data-ids and
+    // https://stackoverflow.com/a/2785493/3689782 there's no reliable way to compute a device ID.
+    // The following is an unreliable approximation that's more or less tied to the installation of
+    // the app, though *an* ID is at least guaranteed to be returned.
+    val fidResult = AtomicReference(AsyncResult.pending<String>())
+    FirebaseInstallations.getInstance().id.addOnCompleteListener { task ->
+      val fid = if (task.isSuccessful) task.result else null
+      val deviceId = fid ?: retrieveSecureAndroidId() ?: computeInstallTimeBasedId()
+      val hashedId = machineLocale.run {
+        MessageDigest.getInstance("SHA-1")
+          .digest(deviceId.toByteArray())
+          .joinToString("") { "%02x".formatForMachines(it) }
+          .substring(startIndex = 0, endIndex = 12)
+      }
+      fidResult.set(AsyncResult.success(hashedId))
+      asyncDataSubscriptionManager.notifyChangeAsync(FIREBASE_ID_DATA_PROVIDER_ID)
+    }
+    return dataProviders.createInMemoryDataProviderAsync(FIREBASE_ID_DATA_PROVIDER_ID) {
+      fidResult.get()
+    }
+  }
+
+  private fun retrieveSecureAndroidId(): String? =
+    context.getSecureString(Settings.Secure.ANDROID_ID)
+
+  private fun computeInstallTimeBasedId(): String {
+    // Use the package's install time as a (poor) proxy for a device ID since it's at least
+    // guaranteed to be present.
+    val appInfo = context.packageManager.getApplicationInfo("org.oppia.android", /* flags= */ 0)
+    return machineLocale.run { "%02x".formatForMachines(File(appInfo.sourceDir).lastModified()) }
+  }
+}

domain/src/main/java/org/oppia/android/domain/oppialogger/LoggingIdentifierModule.kt

@@ -0,0 +1,13 @@
+package org.oppia.android.domain.oppialogger
+
+import dagger.Module
+import dagger.Provides
+import org.oppia.android.util.system.OppiaClock
+
+/** Provider to return any constants required during operations on logging identifiers. */
+@Module
+class LoggingIdentifierModule {
+  @Provides
+  @ApplicationIdSeed
+  fun provideApplicationIdSeed(oppiaClock: OppiaClock): Long = oppiaClock.getCurrentTimeMs()
+}