Add custom init logic

Author: agg23

README.md

@@ -1,3 +1,19 @@
-# Android Mock Context
+# Android Mocks for `app_process`
 
-A custom `Context` implementation that allows for easy customization of common `Context` properties. This allows experimenting with "app level" interactions while using `app_process` instead.
+A custom `Context` implementation and other core features that allows for easy customization of common core Android classes. This allows experimenting with "app level" interactions while using `app_process` instead.
+
+## Usage
+
+Set up your process by calling:
+
+```kotlin
+Common.initialize(classLoader)
+```
+
+This will set up your thread and initialize some core systems set up by `ActivityThread` during a normal app launch.
+
+You can create a custom mocked `Context` using:
+
+```kotlin
+MockContext.createWithAppContext(classLoader, mainThread, "com.android.settings")
+```

src/main/java/com/penumbraos/appprocessmocks/Common.kt

@@ -0,0 +1,26 @@
+package com.penumbraos.appprocessmocks
+
+import android.app.ActivityThread
+import android.os.Looper
+
+@Suppress("DEPRECATION")
+class Common {
+    companion object {
+        /**
+         * Set up the `app_process` environment to mirror that of a native app. You should call `MockContext.createWithAppContext` first
+         */
+        fun initialize(classLoader: ClassLoader): ActivityThread {
+            Looper.prepareMainLooper()
+
+            // The android.jar plugin currently isn't letting us use these classes directly
+            val activityThreadClass = classLoader.loadClass("android.app.ActivityThread")
+            val activityThreadConstructor = activityThreadClass.getDeclaredConstructor()
+            activityThreadConstructor.isAccessible = true
+            val mainActivityThread = activityThreadConstructor.newInstance() as ActivityThread
+
+            ActivityThread.initializeMainlineModules()
+
+            return mainActivityThread
+        }
+    }
+}

src/main/java/com/penumbraos/appprocessmocks/MockContext.kt

@@ -1,6 +1,5 @@
 import android.annotation.SuppressLint
 import android.app.ActivityThread
-import android.app.IApplicationThread
 import android.app.LoadedApk
 import android.content.AttributionSource
 import android.content.BroadcastReceiver
@@ -10,24 +9,25 @@ import android.content.Context
 import android.content.ContextWrapper
 import android.content.Intent
 import android.content.IntentFilter
+import android.content.pm.ApplicationInfo
 import android.content.res.AssetManager
 import android.content.res.Resources
 import android.os.Looper
 import java.io.File
 
 @SuppressLint("DiscouragedPrivateApi", "UnspecifiedRegisterReceiverFlag")
-class MockContext(base: Context) : ContextWrapper(base) {
+class MockContext(base: Context, basePackageName: String? = null) : ContextWrapper(base) {
 
     var mockAttributionTag: String? = null
 
     /**
      * Defaults to com.android.settings and uid 1000
      */
-    var mockAttributionSource: AttributionSource? = AttributionSource.Builder(1000).setPackageName("com.android.settings").setAttributionTag("*tag*").build()
+    var mockAttributionSource: AttributionSource? = AttributionSource.Builder(1000).setPackageName(basePackageName ?: "com.android.settings").setAttributionTag("*tag*").build()
     private val services = mutableMapOf<String, Any>()
     var mockApplicationContext: Context? = null
     var mockResources: Resources? = null
-    var mockPackageName: String? = null
+    var mockPackageName: String? = basePackageName
     var mockPackageResourcePath: String? = null
     var mockPackageCodePath: String? = null
     var mockAssets: AssetManager? = null
@@ -49,15 +49,34 @@ class MockContext(base: Context) : ContextWrapper(base) {
     var mockUnregisterReceiver: ((BroadcastReceiver?) -> Unit)? = null
 
     companion object {
-        fun createWithAppContext(classLoader: ClassLoader, mainThread: IApplicationThread, loadedApk: LoadedApk): Context {
+        fun createWithAppContext(classLoader: ClassLoader, mainThread: ActivityThread, packageName: String): Context {
+            // The android.jar plugin currently isn't letting us use these classes directly
+            val loadedApkClass = classLoader.loadClass("android.app.LoadedApk")
+            val loadedApkConstructor = loadedApkClass.getDeclaredConstructor(ActivityThread::class.java)
+            loadedApkConstructor.isAccessible = true
+            val loadedApk = loadedApkConstructor.newInstance(mainThread) as LoadedApk
+
+            val loadedApkPackageNameField = loadedApkClass.getDeclaredField("mPackageName")
+            loadedApkPackageNameField.isAccessible = true
+            loadedApkPackageNameField.set(loadedApk, packageName)
+
+            val loadedApkApplicationInfoField = loadedApkClass.getDeclaredField("mApplicationInfo")
+            loadedApkApplicationInfoField.isAccessible = true
+            val applicationInfo = loadedApkApplicationInfoField.get(loadedApk) as ApplicationInfo
+            applicationInfo.packageName = packageName
+
+            return createWithAppContext(classLoader, mainThread, loadedApk, packageName)
+        }
+
+        fun createWithAppContext(classLoader: ClassLoader, mainThread: ActivityThread, loadedApk: LoadedApk, packageName: String? = null): Context {
             // The android.jar plugin currently isn't letting us use these classes directly
             val contextImplClass = classLoader.loadClass("android.app.ContextImpl")
             val contextImplConstructor = contextImplClass.getDeclaredMethod("createAppContext",
                 ActivityThread::class.java, LoadedApk::class.java)
             contextImplConstructor.isAccessible = true
 
             val context = contextImplConstructor.invoke(null, mainThread, loadedApk) as Context
-            return MockContext(context)
+            return MockContext(context, packageName)
         }
     }