OPPIA-1369, OPPIA-1382: Migrate analytics package to kotlin

app/src/main/java/org/digitalcampus/oppia/analytics/Analytics.kt

@@ -0,0 +1,142 @@
+package org.digitalcampus.oppia.analytics
+
+import android.app.Activity
+import android.app.Application
+import android.content.Context
+import android.content.SharedPreferences
+import androidx.preference.PreferenceManager
+import org.digitalcampus.mobile.learning.BuildConfig
+import org.digitalcampus.oppia.activity.PrefsActivity
+import org.digitalcampus.oppia.application.SessionManager.getUsername
+
+object Analytics {
+    private const val ANALYTICS_LIBRARY_COUNTLY = "COUNTLY"
+
+    private var analyticsEngine: BaseAnalytics? = null
+
+    fun initializeAnalytics(appContext: Application) {
+        if (analyticsEngine == null) {
+            if (BuildConfig.ANALYTICS_LIBRARY == ANALYTICS_LIBRARY_COUNTLY) {
+                analyticsEngine = CountlyAnalytics(appContext)
+            } else {
+                analyticsEngine = DefaultNoOpAnalytics(appContext)
+            }
+        }
+    }
+
+    private fun getPrefs(ctx: Context): SharedPreferences {
+        return PreferenceManager.getDefaultSharedPreferences(ctx)
+    }
+
+    fun shouldShowOptOutRationale(ctx: Context): Boolean {
+        return !getPrefs(ctx).getBoolean(PrefsActivity.PREF_ANALYTICS_INITIAL_PROMPT, false)
+    }
+
+    @JvmStatic
+    fun optOutRationaleShown(ctx: Context) {
+        getPrefs(ctx).edit().putBoolean(PrefsActivity.PREF_ANALYTICS_INITIAL_PROMPT, true).apply()
+    }
+
+    @JvmStatic
+    fun startTrackingIfEnabled(ctx: Context) {
+        analyticsEngine?.run {
+            if (isBugReportEnabled(ctx) || isTrackingEnabled(ctx)) {
+                startTrackingSession()
+                val username = getUsername(ctx)
+                setUserId(username)
+            }
+        }
+    }
+
+    fun setUserId(username: String?) {
+        analyticsEngine?.run {
+            val username = if (username.isNullOrBlank()) "anon" else username
+            setUserIdentifier(username)
+        }
+    }
+
+    @JvmStatic
+    fun enableTracking(ctx: Context) {
+        analyticsEngine?.run {
+            getPrefs(ctx).edit().putBoolean(PrefsActivity.PREF_ANALYTICS_ENABLED, true).apply()
+            if (!isBugReportEnabled(ctx)) {
+                startTrackingSession()
+            } else {
+                trackingConfigChanged()
+            }
+        }
+    }
+
+    @JvmStatic
+    fun enableBugReport(ctx: Context) {
+        analyticsEngine?.run {
+            getPrefs(ctx).edit().putBoolean(PrefsActivity.PREF_BUG_REPORT_ENABLED, true).apply()
+            if (!isTrackingEnabled(ctx)) {
+                startTrackingSession()
+            } else {
+                trackingConfigChanged()
+            }
+        }
+    }
+
+    @JvmStatic
+    fun disableTracking(ctx: Context) {
+        analyticsEngine?.run {
+            getPrefs(ctx).edit().putBoolean(PrefsActivity.PREF_ANALYTICS_ENABLED, false).apply()
+            if (!isBugReportEnabled(ctx)) {
+                stopTrackingSession()
+            } else {
+                trackingConfigChanged()
+            }
+        }
+    }
+
+    @JvmStatic
+    fun disableBugReport(ctx: Context) {
+        analyticsEngine?.run {
+            getPrefs(ctx).edit().putBoolean(PrefsActivity.PREF_BUG_REPORT_ENABLED, false).apply()
+            if (!isTrackingEnabled(ctx)) {
+                stopTrackingSession()
+            } else {
+                trackingConfigChanged()
+            }
+        }
+    }
+
+    @JvmStatic
+    fun logException(e: Exception) {
+        analyticsEngine?.run {
+            if(isBugReportEnabled()) {
+                logHandledException(e)
+            }
+        }
+    }
+
+    @JvmStatic
+    fun isTrackingEnabled(ctx: Context): Boolean {
+        return getPrefs(ctx).getBoolean(PrefsActivity.PREF_ANALYTICS_ENABLED, false)
+    }
+
+    @JvmStatic
+    fun isBugReportEnabled(ctx: Context): Boolean {
+        return getPrefs(ctx).getBoolean(PrefsActivity.PREF_BUG_REPORT_ENABLED, false)
+    }
+
+    @JvmStatic
+    fun trackViewOnStart(a: Activity) {
+        analyticsEngine?.run {
+            if(isAnalyticsEnabled()) {
+                trackViewOnStart(a)
+            }
+        }
+    }
+
+    @JvmStatic
+    fun trackViewOnStop(a: Activity) {
+        analyticsEngine?.run {
+            if(isAnalyticsEnabled()) {
+                trackViewOnStop(a)
+            }
+        }
+    }
+}

app/src/main/java/org/digitalcampus/oppia/analytics/AnalyticsProvider.kt

@@ -0,0 +1,9 @@
+package org.digitalcampus.oppia.analytics
+
+import android.content.Context
+
+class AnalyticsProvider {
+    fun shouldShowOptOutRationale(ctx: Context): Boolean {
+        return Analytics.shouldShowOptOutRationale(ctx)
+    }
+}

app/src/main/java/org/digitalcampus/oppia/analytics/BaseAnalytics.kt

@@ -0,0 +1,27 @@
+package org.digitalcampus.oppia.analytics
+
+import android.app.Activity
+import android.app.Application
+import android.content.Context
+import androidx.preference.PreferenceManager
+import org.digitalcampus.oppia.activity.PrefsActivity
+
+abstract class BaseAnalytics (protected val appContext: Application) {
+    abstract fun startTrackingSession()
+    abstract fun stopTrackingSession()
+    abstract fun trackingConfigChanged()
+    abstract fun logHandledException(e: Exception)
+    abstract fun setUserIdentifier(username: String)
+    abstract fun trackViewOnStart(activity: Activity)
+    abstract fun trackViewOnStop(activity: Activity)
+
+    fun isBugReportEnabled(): Boolean {
+        val prefs = PreferenceManager.getDefaultSharedPreferences(appContext)
+        return prefs.getBoolean(PrefsActivity.PREF_BUG_REPORT_ENABLED, false)
+    }
+
+    fun isAnalyticsEnabled(): Boolean {
+        val prefs = PreferenceManager.getDefaultSharedPreferences(appContext)
+        return prefs.getBoolean(PrefsActivity.PREF_ANALYTICS_ENABLED, false)
+    }
+}