Merge pull request #66 from AppDevNext/Countly

Countly

Author: hannesa2

LogcatCountlyLib/build.gradle

@@ -0,0 +1,27 @@
+apply plugin: 'com.android.library'
+apply plugin: 'kotlin-android'
+apply plugin: 'kotlin-android-extensions'
+
+android {
+    compileSdkVersion propCompileSdkVersion
+
+    defaultConfig {
+        versionName getTag()
+        versionCode getGitCommitCount()
+
+        minSdkVersion 16
+        project.archivesBaseName = "LogcatCountly"
+    }
+
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_1_8
+        targetCompatibility JavaVersion.VERSION_1_8
+    }
+}
+
+dependencies {
+    api project(':LogcatCoreLib')
+    implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:$kotlin_version"
+
+    api "ly.count.android:sdk:20.04.4"
+}

LogcatCountlyLib/src/main/AndroidManifest.xml

@@ -0,0 +1,8 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="info.hannes.logcat.countly">
+
+    <application>
+
+    </application>
+
+</manifest>

LogcatCountlyLib/src/main/java/info/hannes/countly/Analytics.kt

@@ -0,0 +1,87 @@
+package info.hannes.countly
+
+import android.annotation.SuppressLint
+import android.app.Activity
+import android.content.Context
+import android.content.pm.PackageManager
+import android.provider.Settings
+import info.hannes.logcat.BuildConfig
+import ly.count.android.sdk.Countly
+import ly.count.android.sdk.CountlyConfig
+import ly.count.android.sdk.DeviceId
+
+
+@Suppress("PrivatePropertyName")
+class Analytics : IAnalytics {
+
+    var countlyInstance: Countly = Countly.sharedInstance()
+        private set
+
+    override fun isInitialized(): Boolean {
+        return countlyInstance.isInitialized
+    }
+
+    override fun recordEvent(event: String) {
+        if (isInitialized()) {
+            countlyInstance.events().recordEvent(event, segmentation, 1)
+        }
+    }
+
+    override fun recordError(message: String) {
+        if (isInitialized()) {
+            countlyInstance.crashes().recordHandledException(RuntimeException(message))
+        }
+    }
+
+    override fun recordError(throwable: Throwable) {
+        if (isInitialized()) {
+            countlyInstance.crashes().recordHandledException(throwable)
+        }
+    }
+
+    override fun recordWarning(message: String) {
+        if (isInitialized()) {
+            countlyInstance.crashes().recordHandledException(RuntimeException(message))
+        }
+    }
+
+    override fun onStart(activity: Activity?) {
+        if (isInitialized()) {
+            countlyInstance.onStart(activity)
+        }
+    }
+
+    override fun onStop() {
+        if (isInitialized()) {
+            countlyInstance.onStop()
+        }
+    }
+
+    companion object {
+        val segmentation = mutableMapOf<String, Any>()
+
+        @SuppressLint("HardwareIds")
+        fun initAnalytics(context: Context, loggingEnabled: Boolean = false, countlyKey: String, countlyHost: String) {
+            var version = ""
+            try {
+                val pInfo = context.packageManager.getPackageInfo(context.packageName, 0)
+                version = pInfo.versionName
+            } catch (ignore: PackageManager.NameNotFoundException) {
+            }
+            segmentation["app_version"] = version
+            segmentation["logging_version"] = BuildConfig.VERSION_NAME
+
+            val config = CountlyConfig()
+                    .setAppKey(countlyKey)
+                    .setContext(context)
+                    .setDeviceId(Settings.Secure.getString(context.contentResolver, Settings.Secure.ANDROID_ID))
+                    .setIdMode(DeviceId.Type.DEVELOPER_SUPPLIED)
+                    .setServerURL(countlyHost)
+                    .setLoggingEnabled(loggingEnabled)
+                    .setViewTracking(true)
+                    .setHttpPostForced(true)
+                    .enableCrashReporting()
+            Countly.sharedInstance().init(config)
+        }
+    }
+}

LogcatCountlyLib/src/main/java/info/hannes/countly/CountlyTree.kt

@@ -0,0 +1,39 @@
+package info.hannes.countly
+
+import android.util.Log
+import info.hannes.timber.DebugTree
+
+class CountlyTree(private val analytics: Analytics, private val serverIgnoreToken: String? = null) : DebugTree() {
+
+    // some regex explanation :
+    // $t sign to search
+    // . any char
+    // + minimum once
+    // ? null or once
+    // | or
+    // # beginning with #
+    // [^#] any char except #
+    // *$ till end of line
+
+    // short variable to avoid lint warning "Duplicate char n inside Character class" in following line
+    private val t = serverIgnoreToken
+    private val regex: Regex = "$t.+?$t|$t[^$t]*$".toRegex()
+
+    override fun log(priority: Int, tag: String?, message: String, throwable: Throwable?) {
+        // we ignore INFO, DEBUG and VERBOSE
+        if (priority <= Log.INFO) {
+            return
+        }
+        var localMessage = message
+        serverIgnoreToken?.let {
+            localMessage = regex.replace(message, "")
+        }
+
+        when {
+            throwable != null -> analytics.recordError(throwable)
+            priority == Log.WARN -> analytics.recordEvent(localMessage)
+            else -> analytics.recordError(localMessage)
+        }
+    }
+
+}

LogcatCountlyLib/src/main/java/info/hannes/countly/IAnalytics.kt

@@ -0,0 +1,20 @@
+package info.hannes.countly
+
+import android.app.Activity
+
+interface IAnalytics {
+
+    fun isInitialized(): Boolean
+
+    fun recordEvent(event: String)
+
+    fun recordWarning(message: String)
+
+    fun recordError(message: String)
+
+    fun recordError(throwable: Throwable)
+
+    fun onStart(activity: Activity?)
+
+    fun onStop()
+}

LogcatCountlyLib/src/main/java/info/hannes/logging/LoggingApplication.kt

@@ -0,0 +1,38 @@
+package info.hannes.logging
+
+import android.app.Application
+import info.hannes.countly.Analytics
+import info.hannes.countly.CountlyTree
+import info.hannes.timber.DebugTree
+import timber.log.Timber
+
+abstract class LoggingApplication(
+    private val countlyHost: String,
+    private val countlyKey: String,
+    private val debugBuildType: Boolean,
+    private val serverIgnoreToken: String? = null
+) : Application() {
+
+    override fun onCreate() {
+        super.onCreate()
+        val oldHandler = Thread.getDefaultUncaughtExceptionHandler()
+
+        Thread.setDefaultUncaughtExceptionHandler { t, e ->
+            @Suppress("ControlFlowWithEmptyBody")
+            Timber.e(e.cause?.also { } ?: run { e })
+            oldHandler?.uncaughtException(t, e)
+        }
+
+        setupLogging(!debugBuildType)
+    }
+
+    @Suppress("MemberVisibilityCanBePrivate")
+    protected fun setupLogging(countlyLogging: Boolean) {
+        Timber.plant(DebugTree())
+        if (countlyLogging) {
+            Analytics.initAnalytics(this, countlyLogging, countlyKey, countlyHost)
+            Timber.plant(CountlyTree(Analytics(), serverIgnoreToken))
+        }
+    }
+
+}

sample/build.gradle

@@ -39,6 +39,7 @@ android {
 dependencies {
     implementation project(':LogcatCoreLib')
     implementation project(':LogcatCrashlyticLib')
+    implementation project(':LogcatCountlyLib')
     implementation 'androidx.legacy:legacy-support-v4:1.0.0'
     implementation "androidx.appcompat:appcompat:1.1.0"
     implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:$kotlin_version"

settings.gradle

@@ -1,3 +1,4 @@
 include ':LogcatCoreLib'
 include ':LogcatCrashlyticLib'
+include ':LogcatCountlyLib'
 include ':sample'