Apply to Android BasePlugin

Fix #5

Author: yujincheng08

README.md

@@ -17,7 +17,7 @@ buildscript {
     }
 
     dependencies {
-        classpath("org.lsposed.lsparanoid:gradle-plugin:0.4.4")
+        classpath("org.lsposed.lsparanoid:gradle-plugin:0.4.5")
         // classpath("com.android.tools.build:gradle")
     }
 }
@@ -48,6 +48,7 @@ The extension object contains the following properties:
 - `seed` - `Integer`. A seed that can be used to make obfuscation stable across builds. Default value is `null`, which means that the seed
   is computed from input files on each build.
 - `global` - `boolean`. If `true`, the obfuscation will be applied to all classes, not only annotated ones. Default value is `false`.
+- `includeDependencies` - `boolean`. If `true`, the obfuscation will be applied to all dependencies. Default value is `false`.
 - `variantFilter` - `(Variant) -> boolean`. Allows to filter out variants that should be obfuscated. Default value always returns `true`.
 
 How it works

build.gradle.kts

@@ -1,6 +1,6 @@
 allprojects {
     group = "org.lsposed.lsparanoid"
-    version = "0.4.4"
+    version = "0.4.5"
 
     val javaVersion by extra(JavaVersion.VERSION_11)
     val kotlinVersion by extra("1.8.0")

gradle-plugin/src/main/java/org/lsposed/lsparanoid/plugin/ParanoidExtension.kt

@@ -23,5 +23,6 @@ open class ParanoidExtension {
   var enabled: Boolean = true
   var seed: Int? = null
   var global: Boolean = false
+  var includeDependencies: Boolean = false
   var variantFilter: (Variant) -> Boolean = { true }
 }

gradle-plugin/src/main/java/org/lsposed/lsparanoid/plugin/ParanoidPlugin.kt

@@ -20,18 +20,18 @@ package org.lsposed.lsparanoid.plugin
 import com.android.build.api.artifact.ScopedArtifact
 import com.android.build.api.variant.AndroidComponentsExtension
 import com.android.build.api.variant.ScopedArtifacts
-import com.android.build.gradle.AppPlugin
 import com.android.build.gradle.BaseExtension
 import org.gradle.api.Plugin
 import org.gradle.api.Project
+import org.gradle.api.plugins.BasePlugin
 import org.gradle.api.plugins.JavaPlugin
 
 class ParanoidPlugin : Plugin<Project> {
     private lateinit var extension: ParanoidExtension
 
     override fun apply(project: Project) {
         extension = project.extensions.create("lsparanoid", ParanoidExtension::class.java)
-        project.plugins.withType(AppPlugin::class.java) { _ ->
+        project.plugins.withType(BasePlugin::class.java) { _ ->
             project.extensions.configure("androidComponents") { it: AndroidComponentsExtension<*, *, *> ->
                 it.onVariants { variant ->
                     if (!extension.enabled) return@onVariants
@@ -44,7 +44,7 @@ class ParanoidPlugin : Plugin<Project> {
                         it.seed.set(extension.seed)
                         it.global.set(extension.global)
                     }
-                    variant.artifacts.forScope(ScopedArtifacts.Scope.ALL)
+                    variant.artifacts.forScope(if (extension.includeDependencies) ScopedArtifacts.Scope.ALL else ScopedArtifacts.Scope.PROJECT)
                         .use(task).toTransform(
                             ScopedArtifact.CLASSES,
                             ParanoidTask::jars,

processor/src/main/kotlin/org/lsposed/lsparanoid/processor/StandaloneClassWriter.kt

@@ -53,37 +53,33 @@ class StandaloneClassWriter : ClassWriter {
 
     override fun getCommonSuperClass(type1: String, type2: String): String {
         val hierarchy = HashSet<Type>()
-        if (fileRegistry.findFileForType(getObjectTypeByInternalName(type1)) != null) {
-            for (mirror in classRegistry.findClassHierarchy(getObjectTypeByInternalName(type1))) {
-                hierarchy.add(mirror.type)
-            }
-        } else {
-            // compile only classes always assume java.lang.Object its superclass
-            hierarchy.add(OBJECT_TYPE)
+        for (mirror in classRegistry.findClassHierarchy(getObjectTypeByInternalName(type1))) {
+            hierarchy.add(mirror.type)
         }
 
-        if (fileRegistry.findFileForType(getObjectTypeByInternalName(type2)) != null) {
-            for (mirror in classRegistry.findClassHierarchy(getObjectTypeByInternalName(type2))) {
-                if (mirror.type in hierarchy) {
-                    logger.debug("[getCommonSuperClass]: {} & {} = {}", type1, type2, mirror.access)
-                    return mirror.type.internalName
-                }
+        for (mirror in classRegistry.findClassHierarchy(getObjectTypeByInternalName(type2))) {
+            if (mirror.type in hierarchy) {
+                logger.debug("[getCommonSuperClass]: {} & {} = {}", type1, type2, mirror.access)
+                return mirror.type.internalName
             }
-        } else {
-            // compile only classes always assume java.lang.Object as the common superclass
-            return OBJECT_INTERNAL_NAME
         }
 
         logger.warn("[getCommonSuperClass]: {} & {} = NOT FOUND ", type1, type2)
         return OBJECT_INTERNAL_NAME
     }
 
     private fun ClassRegistry.findClassHierarchy(type: Type.Object): Sequence<ClassMirror> {
-        return generateSequence(getClassMirror(type)) {
-            it.superType?.let { getClassMirror(it) }
+        return generateSequence(getClassMirrorOrObject(type)) {
+            it.superType?.let { superType -> getClassMirrorOrObject(superType) }
         }
     }
 
+    private fun ClassRegistry.getClassMirrorOrObject(type: Type.Object): ClassMirror? {
+        return fileRegistry.findFileForType(type)?.let { _ ->
+            getClassMirror(type)
+        } ?: getClassMirror(OBJECT_TYPE)
+    }
+
     companion object {
         private val OBJECT_INTERNAL_NAME = getObjectType<Any>().internalName
     }