Remove need for context in Sentry.init for Android (#117)

* Deprecate context in Sentry.init in favor of using init without it

* Update comments

* Update AndroidManifest.xml

* Update comments

* Update changelog

* Update comments

* Improvements

* Format code

* Update comment

---------

Co-authored-by: Sentry Github Bot <[email protected]>

Author: buenaflor

CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## Unreleased
+
+- Remove need for context in Sentry.init for Android ([#117](https://github.com/getsentry/sentry-kotlin-multiplatform/pull/117))
+
 ## 0.2.1
 
 ### Fixes

buildSrc/src/main/java/Config.kt

@@ -53,6 +53,7 @@ object Config {
 
         val roboelectric = "org.robolectric:robolectric:4.9"
         val junitKtx = "androidx.test.ext:junit-ktx:1.1.5"
+        val mockitoCore = "org.mockito:mockito-core:5.4.0"
     }
 
     object Android {

sentry-kotlin-multiplatform/build.gradle.kts

@@ -67,6 +67,7 @@ kotlin {
             dependencies {
                 implementation(Config.TestLibs.roboelectric)
                 implementation(Config.TestLibs.junitKtx)
+                implementation(Config.TestLibs.mockitoCore)
             }
         }
         val jvmMain by getting

sentry-kotlin-multiplatform/src/androidMain/AndroidManifest.xml

@@ -8,7 +8,14 @@
             android:name="io.sentry.android.core.SentryInitProvider"
             android:authorities="${applicationId}.SentryInitProvider"
             android:exported="false"
-            tools:node="remove"/>
+            tools:node="remove">
+        </provider>
+        <provider
+            android:name="io.sentry.kotlin.multiplatform.SentryContextProvider"
+            android:authorities="${applicationId}.SentryContextProvider"
+            android:exported="false"
+            tools:node="merge">
+        </provider>
     </application>
 
 </manifest>

sentry-kotlin-multiplatform/src/androidMain/kotlin/io/sentry/kotlin/multiplatform/SentryInit.android.kt

@@ -1,15 +1,72 @@
 package io.sentry.kotlin.multiplatform
 
+import android.content.ContentProvider
+import android.content.ContentValues
 import android.content.Context
+import android.database.Cursor
+import android.net.Uri
 import io.sentry.android.core.SentryAndroid
 import io.sentry.kotlin.multiplatform.extensions.toAndroidSentryOptionsCallback
 
-internal actual fun initSentry(context: Context?, configuration: OptionsConfiguration) {
+internal actual fun initSentry(configuration: OptionsConfiguration) {
     val options = SentryOptions()
     configuration.invoke(options)
-    context?.let {
-        SentryAndroid.init(it, options.toAndroidSentryOptionsCallback())
-    }
+    SentryAndroid.init(applicationContext, options.toAndroidSentryOptionsCallback())
 }
 
+internal lateinit var applicationContext: Context
+    private set
+
 public actual typealias Context = Context
+
+/**
+ * A ContentProvider that does NOT store or provide any data for read or write operations.
+ *
+ * It's only purpose is to retrieve and store the application context in an internal top-level
+ * variable [applicationContext]. The context is used for [SentryAndroid.init].
+ *
+ * This does not allow for overriding the abstract query, insert, update, and delete operations
+ * of the [ContentProvider].
+ */
+internal class SentryContextProvider : ContentProvider() {
+    override fun onCreate(): Boolean {
+        val context = context
+        if (context != null) {
+            applicationContext = context.applicationContext
+        } else {
+            error("Context cannot be null")
+        }
+        return true
+    }
+
+    override fun query(
+        uri: Uri,
+        projection: Array<out String>?,
+        selection: String?,
+        selectionArgs: Array<out String>?,
+        sortOrder: String?
+    ): Cursor? {
+        error("Not allowed.")
+    }
+
+    override fun getType(uri: Uri): String? {
+        error("Not allowed.")
+    }
+
+    override fun insert(uri: Uri, values: ContentValues?): Uri? {
+        error("Not allowed.")
+    }
+
+    override fun delete(uri: Uri, selection: String?, selectionArgs: Array<out String>?): Int {
+        error("Not allowed.")
+    }
+
+    override fun update(
+        uri: Uri,
+        values: ContentValues?,
+        selection: String?,
+        selectionArgs: Array<out String>?
+    ): Int {
+        error("Not allowed.")
+    }
+}

sentry-kotlin-multiplatform/src/androidUnitTest/kotlin/io/sentry/kotlin/multiplatform/BaseSentryTest.kt

@@ -1,15 +1,22 @@
 package io.sentry.kotlin.multiplatform
 
 import androidx.test.ext.junit.runners.AndroidJUnit4
-import androidx.test.platform.app.InstrumentationRegistry
 import org.junit.runner.RunWith
+import org.robolectric.Robolectric
+import kotlin.test.BeforeTest
 
 @RunWith(AndroidJUnit4::class)
 actual abstract class BaseSentryTest {
     actual val platform: String = "Android"
     actual val authToken: String? = System.getenv("SENTRY_AUTH_TOKEN")
     actual fun sentryInit(optionsConfiguration: OptionsConfiguration) {
-        val context = InstrumentationRegistry.getInstrumentation().targetContext
-        Sentry.init(context, optionsConfiguration)
+        Sentry.init(optionsConfiguration)
+    }
+
+    @BeforeTest
+    open fun setUp() {
+        // Set up the provider needed for Sentry.init on Android
+        val provider = Robolectric.buildContentProvider(SentryContextProvider::class.java)
+        provider.create()
     }
 }

sentry-kotlin-multiplatform/src/androidUnitTest/kotlin/io/sentry/kotlin/multiplatform/SentryContextProviderTest.kt

@@ -0,0 +1,59 @@
+package io.sentry.kotlin.multiplatform
+
+import android.content.ContentValues
+import android.net.Uri
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.mockito.Mockito.mock
+
+@RunWith(AndroidJUnit4::class)
+class SentryContextProviderTest : BaseSentryTest() {
+    private lateinit var provider: SentryContextProvider
+
+    @Before
+    override fun setUp() {
+        provider = SentryContextProvider()
+    }
+
+    // We create a nested class so this test is executed with the BeforeEach method that initializes
+    // the actual content provider and not just a mock.
+    class SentryContextOnCreateTest : BaseSentryTest() {
+        @Test
+        fun `onCreate initializes applicationContext`() {
+            // Simple call to the lateinit applicationContext to make sure it's initialized
+            applicationContext
+        }
+    }
+
+    fun `create does not throw Exception`() {
+        provider.onCreate()
+    }
+
+    @Test(expected = IllegalStateException::class)
+    fun `insert throws Exception`() {
+        val uri = mock(Uri::class.java)
+        val values = ContentValues()
+        provider.insert(uri, values)
+    }
+
+    @Test(expected = IllegalStateException::class)
+    fun `update throws Exception`() {
+        val uri = mock(Uri::class.java)
+        val values = ContentValues()
+        provider.update(uri, values, null, null)
+    }
+
+    @Test(expected = IllegalStateException::class)
+    fun `delete throws Exception`() {
+        val uri = mock(Uri::class.java)
+        provider.delete(uri, null, null)
+    }
+
+    @Test(expected = IllegalStateException::class)
+    fun `getType throws Exception`() {
+        val uri = mock(Uri::class.java)
+        provider.getType(uri)
+    }
+}

sentry-kotlin-multiplatform/src/commonJvmMain/kotlin/io/sentry/kotlin/multiplatform/SentryBridge.jvm.kt

@@ -9,12 +9,12 @@ import io.sentry.kotlin.multiplatform.protocol.SentryId
 import io.sentry.kotlin.multiplatform.protocol.User
 import io.sentry.kotlin.multiplatform.protocol.UserFeedback
 
-internal expect fun initSentry(context: Context? = null, configuration: OptionsConfiguration)
+internal expect fun initSentry(configuration: OptionsConfiguration)
 
 internal actual object SentryBridge {
 
     actual fun init(context: Context, configuration: OptionsConfiguration) {
-        initSentry(context, configuration)
+        initSentry(configuration)
     }
 
     actual fun init(configuration: OptionsConfiguration) {

sentry-kotlin-multiplatform/src/commonMain/kotlin/io/sentry/kotlin/multiplatform/SentryKMP.kt

@@ -11,6 +11,7 @@ public typealias ScopeCallback = (Scope) -> Unit
 public typealias OptionsConfiguration = (SentryOptions) -> Unit
 
 /** The context used for Android initialization. */
+@Deprecated("No longer necessary to initialize Sentry on Android.")
 public expect abstract class Context
 
 /** Sentry Kotlin Multiplatform SDK API entry point. */
@@ -24,6 +25,10 @@ public object Sentry {
      */
     @OptIn(ExperimentalObjCRefinement::class)
     @HiddenFromObjC
+    @Deprecated(
+        "Use init(OptionsConfiguration) instead.",
+        ReplaceWith("Sentry.init(configuration)")
+    )
     public fun init(context: Context, configuration: OptionsConfiguration) {
         SentryBridge.init(context, configuration)
     }

sentry-kotlin-multiplatform/src/jvmMain/kotlin/io/sentry/kotlin/multiplatform/SentryInit.jvm.kt

@@ -3,7 +3,7 @@ package io.sentry.kotlin.multiplatform
 import io.sentry.Sentry
 import io.sentry.kotlin.multiplatform.extensions.toJvmSentryOptionsCallback
 
-internal actual fun initSentry(context: Context?, configuration: OptionsConfiguration) {
+internal actual fun initSentry(configuration: OptionsConfiguration) {
     val options = SentryOptions()
     configuration.invoke(options)
     Sentry.init(options.toJvmSentryOptionsCallback())