add public log listener methods

Adds the following new public methods:
* OneSignal.Debug.addLogListener
* OneSignal.Debug.removeLogListener

These new methods provide a way to capture all SDK log entires at
runtime, allowing the app developer to store these and/or send them to
their server.

The log listener is independent of logLevel, all message are always
sent to listeners.

Author: jkasten2

OneSignalSDK/onesignal/core/src/main/java/com/onesignal/debug/IDebugManager.kt

@@ -3,17 +3,29 @@ package com.onesignal.debug
 /**
  * Access to debug the SDK in the event additional information is required to diagnose any
  * SDK-related issues.
- *
- * WARNING: This should not be used in a production setting.
  */
 interface IDebugManager {
     /**
      * The log level the OneSignal SDK should be writing to the Android log. Defaults to [LogLevel.WARN].
+     * WARNING: This should not be set higher than LogLevel.WARN in a production setting.
      */
     var logLevel: LogLevel
 
     /**
      * The log level the OneSignal SDK should be showing as a modal. Defaults to [LogLevel.NONE].
+     * WARNING: This should not be used in a production setting.
      */
     var alertLevel: LogLevel
+
+    /**
+     * Add a listener to receive all logging messages the SDK produces.
+     * Useful to capture and send logs to your server.
+     * NOTE: All log messages are always passed, logLevel has no effect on this.
+     */
+    fun addLogListener(listener: ILogListener)
+
+    /**
+     * Removes a listener added by addLogListener
+     */
+    fun removeLogListener(listener: ILogListener)
 }

OneSignalSDK/onesignal/core/src/main/java/com/onesignal/debug/ILogListener.kt

@@ -0,0 +1,5 @@
+package com.onesignal.debug
+
+fun interface ILogListener {
+    fun onLogEvent(event: OneSignalLogEvent)
+}

OneSignalSDK/onesignal/core/src/main/java/com/onesignal/debug/OneSignalLogEvent.kt

@@ -0,0 +1,6 @@
+package com.onesignal.debug
+
+data class OneSignalLogEvent(
+    val level: LogLevel,
+    val entry: String,
+)

OneSignalSDK/onesignal/core/src/main/java/com/onesignal/debug/internal/DebugManager.kt

@@ -1,6 +1,7 @@
 package com.onesignal.debug.internal
 
 import com.onesignal.debug.IDebugManager
+import com.onesignal.debug.ILogListener
 import com.onesignal.debug.LogLevel
 import com.onesignal.debug.internal.logging.Logging
 
@@ -21,4 +22,12 @@ internal class DebugManager() : IDebugManager {
         logLevel = LogLevel.WARN
         alertLevel = LogLevel.NONE
     }
+
+    override fun addLogListener(listener: ILogListener) {
+        Logging.addListener(listener)
+    }
+
+    override fun removeLogListener(listener: ILogListener) {
+        Logging.removeListener(listener)
+    }
 }

OneSignalSDK/onesignal/core/src/main/java/com/onesignal/debug/internal/logging/Logging.kt

@@ -3,25 +3,28 @@ package com.onesignal.debug.internal.logging
 import android.app.AlertDialog
 import com.onesignal.common.threading.suspendifyOnMain
 import com.onesignal.core.internal.application.IApplicationService
+import com.onesignal.debug.ILogListener
 import com.onesignal.debug.LogLevel
+import com.onesignal.debug.OneSignalLogEvent
 import java.io.PrintWriter
 import java.io.StringWriter
+import java.util.concurrent.CopyOnWriteArraySet
 
 object Logging {
     private const val TAG = "OneSignal"
 
     var applicationService: IApplicationService? = null
 
+    private val logListeners = CopyOnWriteArraySet<ILogListener>()
+
     @JvmStatic
     var logLevel = LogLevel.WARN
 
     @JvmStatic
     var visualLogLevel = LogLevel.NONE
 
     @JvmStatic
-    fun atLogLevel(level: LogLevel): Boolean {
-        return level.compareTo(visualLogLevel) < 1 || level.compareTo(logLevel) < 1
-    }
+    fun atLogLevel(level: LogLevel): Boolean = level.compareTo(visualLogLevel) < 1 || level.compareTo(logLevel) < 1
 
     @JvmStatic
     fun verbose(
@@ -112,7 +115,8 @@ object Logging {
                 suspendifyOnMain {
                     val currentActivity = applicationService?.current
                     if (currentActivity != null) {
-                        AlertDialog.Builder(currentActivity)
+                        AlertDialog
+                            .Builder(currentActivity)
                             .setTitle(level.toString())
                             .setMessage(finalFullMessage)
                             .show()
@@ -122,5 +126,31 @@ object Logging {
                 android.util.Log.e(TAG, "Error showing logging message.", t)
             }
         }
+
+        callLogListeners(level, message, throwable)
+    }
+
+    private fun callLogListeners(
+        level: LogLevel,
+        message: String,
+        throwable: Throwable?,
+    ) {
+        if (logListeners.isEmpty()) return
+
+        var logEntry = message
+        if (throwable != null) {
+            logEntry += "\n" + android.util.Log.getStackTraceString(throwable)
+        }
+        for (listener in logListeners) {
+            listener.onLogEvent(OneSignalLogEvent(level, logEntry))
+        }
+    }
+
+    fun addListener(listener: ILogListener) {
+        logListeners.add(listener)
+    }
+
+    fun removeListener(listener: ILogListener) {
+        logListeners.remove(listener)
     }
 }

OneSignalSDK/onesignal/core/src/test/java/com/onesignal/debug/internal/LoggingTests.kt

@@ -0,0 +1,107 @@
+package com.onesignal.debug.internal
+
+import com.onesignal.debug.ILogListener
+import com.onesignal.debug.LogLevel
+import com.onesignal.debug.OneSignalLogEvent
+import com.onesignal.debug.internal.logging.Logging
+import io.kotest.core.spec.style.FunSpec
+import io.kotest.matchers.shouldBe
+
+class TestLogLister : ILogListener {
+    val calls = ArrayList<String>()
+
+    override fun onLogEvent(event: OneSignalLogEvent) {
+        calls += event.entry
+    }
+}
+
+class LoggingTests : FunSpec({
+    beforeAny {
+        Logging.logLevel = LogLevel.NONE
+    }
+
+    test("addListener") {
+        // Given
+        val listener = TestLogLister()
+        Logging.addListener(listener)
+
+        // When
+        Logging.debug("test")
+
+        // Then
+        listener.calls shouldBe arrayOf("test")
+    }
+
+    test("addListener twice") {
+        // Given
+        val listener = TestLogLister()
+        Logging.addListener(listener)
+        Logging.addListener(listener)
+
+        // When
+        Logging.debug("test")
+
+        // Then
+        listener.calls shouldBe arrayOf("test")
+    }
+
+    test("removeListener") {
+        // Given
+        val listener = TestLogLister()
+        Logging.addListener(listener)
+        Logging.removeListener(listener)
+
+        // When
+        Logging.debug("test")
+
+        // Then
+        listener.calls shouldBe arrayOf<String>()
+    }
+
+    test("removeListener twice") {
+        // Given
+        val listener = TestLogLister()
+        Logging.addListener(listener)
+        Logging.removeListener(listener)
+        Logging.removeListener(listener)
+
+        // When
+        Logging.debug("test")
+
+        // Then
+        listener.calls shouldBe arrayOf<String>()
+    }
+
+    test("addListener nested") {
+        // Given
+        val nestedListener = TestLogLister()
+        Logging.addListener { Logging.addListener(nestedListener) }
+
+        // When
+        Logging.debug("test")
+        Logging.debug("test2")
+        Logging.debug("test3")
+
+        // Then
+        nestedListener.calls shouldBe arrayOf("test2", "test3")
+    }
+
+    test("removeListener nested") {
+        // Given
+        val calls = ArrayList<String>()
+        var listener: ILogListener? = null
+        listener =
+            ILogListener {
+                calls += it.entry
+                Logging.removeListener(listener!!)
+            }
+        Logging.addListener(listener!!)
+
+        // When
+        Logging.debug("test")
+        Logging.debug("test2")
+
+        // Then
+        calls shouldBe arrayOf("test")
+    }
+})