Merge pull request #4 from haroldadmin/auto-init

Add support for automatic initialization using a content provider

Author: haroldadmin

README.md

@@ -2,27 +2,29 @@
 
 WhatTheStack is a library to make your debugging experience on Android better.
 
-WhatTheStack shows you a pretty error screen when your Android App crashes, instead of a boring old dialog saying "Unfortunately, \<your-app\> has crashed".
+It shows you a pretty error screen when your Android App crashes, instead of a boring old dialog saying "Unfortunately, \<your-app\> has crashed".
 
 ## Setup
 
-All that is needed to initialize this library is to use the `init()` method in the `onCreate()` callback of your custom Application class.
+Follow the [Installation Instructions](#installation) to set it up.
 
-```kotlin
-class MyApp : Application() {
-    override fun onCreate() {
-        super.onCreate()
-        if (BuildConfig.DEBUG) {
-          WhatTheStack(this).init()
-        }
-    }
-}
-```
-
-And when an error is thrown in your application, you shall be greeted with a screen similar to this:
+Now when an uncaught exception is thrown in your application, you shall be greeted with a screen similar to this:
 
 <img src="media/screenshot.jpeg" width="360px" height="640px"/>
 
+### Disabling automatic initialization
+
+`WhatTheStack` initializes automatically when your application starts. It accomplishes this using a `ContentProvider`.
+
+If you want to disable automatic initialization, you should disable the initialization content provider of this library by adding the following lines to your application's `AndroidManifest.xml` file:
+
+```xml
+<provider
+  android:name="com.haroldadmin.whatthestack.WhatTheStackInitProvider"
+  android:authorities="${applicationId}.WhatTheStackInitProvider"
+  tools:node="remove" />
+```
+
 ## Under the hood
 
 This library works by setting a default `UncaughtExceptionHandler` on your app, and running a service to receive notifications about these exceptions.
@@ -38,20 +40,21 @@ Add Jitpack repository in your root `build.gradle` file:
 ```groovy
 allprojects {
   repositories {
-    ...
     maven { url 'https://jitpack.io' }
-    }
+  }
 }
 ```
 
 And then add the dependency to your app:
 
 ```groovy
 dependencies {
-  implementation 'com.github.haroldadmin:WhatTheStack:(latest-version)'
+  debugImplementation 'com.github.haroldadmin:WhatTheStack:(latest-version)'
 }
 ```
 
+It is not recommended to use WhatTheStack in anything other than debug builds of your app. Only use `debugImplementation` when adding this dependency.
+
 [![Release](https://jitpack.io/v/haroldadmin/WhatTheStack.svg)](https://jitpack.io/#haroldadmin/WhatTheStack)
 
 ## Contributions

app/build.gradle

@@ -45,7 +45,7 @@ android {
 dependencies {
     implementation fileTree(dir: 'libs', include: ['*.jar'])
 
-    implementation project(path: ":what-the-stack")
+    debugImplementation project(path: ":what-the-stack")
 
     implementation libs.kotlinStdLib
     implementation libs.appCompat

app/src/main/AndroidManifest.xml

@@ -3,7 +3,6 @@
     package="com.haroldadmin.crashyapp">
 
     <application
-        android:name=".CrashyApp"
         android:allowBackup="true"
         android:icon="@mipmap/ic_launcher"
         android:label="@string/app_name"

app/src/main/java/com/haroldadmin/crashyapp/CrashyApp.kt

@@ -16,4 +16,4 @@ class MainActivity : AppCompatActivity() {
     }
 }
 
-private class BecauseICanException : Exception("This exception is purely thrown because it can be thrown")
+private class BecauseICanException : Exception("This exception is thrown purely because it can be thrown")

app/src/main/java/com/haroldadmin/crashyapp/MainActivity.kt

@@ -1,6 +1,11 @@
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
     package="com.haroldadmin.whatthestack">
     <application>
+        <provider
+            android:name=".WhatTheStackInitProvider"
+            android:authorities="${applicationId}.WhatTheStackInitProvider"
+            android:exported="false"
+            android:enabled="true"/>
         <service
             android:name=".WhatTheStackService"
             android:process=":what_the_stack_process" />

what-the-stack/src/main/AndroidManifest.xml

@@ -5,12 +5,30 @@ import android.content.Intent
 import android.os.Messenger
 
 /**
+ * **DO NOT USE**
  * A class to allow initialization of WhatTheStack service.
  *
+ * WhatTheStack initializes automatically using a content provider. You do not need to initialize
+ * it explicitly using this class.
+ *
  * @param applicationContext The context used to start the service to catch uncaught exceptions
  */
+@Deprecated(
+    "WhatTheStack initializes automatically at application startup. Do not explicitly initialize it",
+    level = DeprecationLevel.ERROR
+)
 class WhatTheStack(private val applicationContext: Context) {
 
+    @Suppress("unused")
+    fun init() {
+        WhatTheStackInitializer.init(applicationContext)
+    }
+}
+
+internal object WhatTheStackInitializer {
+
+    private var isInitialized: Boolean = false
+
     private val connection = WhatTheStackConnection(
         onConnected = { binder ->
             val messenger = Messenger(binder)
@@ -19,7 +37,9 @@ class WhatTheStack(private val applicationContext: Context) {
         }
     )
 
-    fun init() {
+    fun init(applicationContext: Context) {
+        if (isInitialized) { return }
+        isInitialized = true
         val intent = Intent(applicationContext, WhatTheStackService::class.java)
         applicationContext.bindService(intent, connection, Context.BIND_AUTO_CREATE)
     }

what-the-stack/src/main/java/com/haroldadmin/whatthestack/WhatTheStack.kt

@@ -0,0 +1,77 @@
+package com.haroldadmin.whatthestack
+
+import android.content.ContentProvider
+import android.content.ContentValues
+import android.content.Context
+import android.content.pm.ProviderInfo
+import android.database.Cursor
+import android.net.Uri
+import android.util.Log
+
+private const val TAG = "WhatTheStackInitializer"
+
+/**
+ * A content provider to initialize WhatTheStack automatically at application startup. It does not
+ * provide the ability to query underlying data.
+ */
+class WhatTheStackInitProvider : ContentProvider() {
+
+    override fun onCreate(): Boolean {
+        val applicationContext = context ?: return false
+        WhatTheStackInitializer.init(applicationContext)
+        Log.d(TAG, "Initialized")
+        return true
+    }
+
+    override fun attachInfo(context: Context?, info: ProviderInfo?) {
+        super.attachInfo(context, info)
+        checkProperAuthority(info)
+    }
+
+    override fun insert(uri: Uri, values: ContentValues?): Uri? {
+        throw UnsupportedOperationException("This content provider can only be used for initializing WhatTheStack")
+    }
+
+    override fun query(
+        uri: Uri,
+        projection: Array<out String>?,
+        selection: String?,
+        selectionArgs: Array<out String>?,
+        sortOrder: String?
+    ): Cursor? {
+        throw UnsupportedOperationException("This content provider can only be used for initializing WhatTheStack")
+    }
+
+    override fun update(
+        uri: Uri,
+        values: ContentValues?,
+        selection: String?,
+        selectionArgs: Array<out String>?
+    ): Int {
+        throw UnsupportedOperationException("This content provider can only be used for initializing WhatTheStack")
+    }
+
+    override fun delete(uri: Uri, selection: String?, selectionArgs: Array<out String>?): Int {
+        throw UnsupportedOperationException("This content provider can only be used for initializing WhatTheStack")
+    }
+
+    override fun getType(uri: Uri): String? {
+        throw UnsupportedOperationException("This content provider can only be used for initializing WhatTheStack")
+    }
+
+    /**
+     * Checks to see if the application using this library has declared an applicationId in its
+     * build.gradle file. If not, it crashes the app with a proper error message.
+     *
+     * Performing this check at startup is important because if a user's device has multiple apps
+     * installed with WhatTheStack, and they do not declare their application IDs, then the content
+     * providers in those applications will fallback to the same name. Since the authority is used
+     * to identify the content provider, it **must** be unique.
+     */
+    private fun checkProperAuthority(info: ProviderInfo?) {
+        val contentProviderName = WhatTheStackInitProvider::class.java.name
+        require(info?.authority != contentProviderName) {
+            "Please provide an applicationId inside your application's build.gradle file"
+        }
+    }
+}