see 11/14 log

Author: Blankj

build.gradle

@@ -2,14 +2,23 @@
 buildscript {
     apply from: 'config.gradle'
     repositories {
+        if (localDebugPlugin) {
+            maven() {
+                url uri(new File(project.rootDir, "maven"))
+            }
+        }
         google()
         jcenter()
     }
 
     dependencies {
         classpath dep.gradle
-//        classpath 'com.blankj:bus-gradle-plugin:1.3'
         classpath dep.kotlin_gradle_plugin
+
+        classpath dep.android_maven_gradle_plugin
+        classpath dep.gradle_bintray_plugin
+
+//      classpath dep.bus_gradle_plugin
     }
 }
 

bus-gradle-plugin/.gitignore

@@ -0,0 +1,2 @@
+/build
+local.properties

bus-gradle-plugin/build.gradle

@@ -0,0 +1,39 @@
+plugins {
+    id 'groovy'
+    id 'java-gradle-plugin' // for gradlePlugin DSL
+    id 'com.gradle.plugin-publish' version "0.10.0" //for pluginPublish.gradle
+}
+
+apply {
+    from "../gradle/pluginPublish.gradle"
+    if (rootProject.localDebugPlugin) {
+        plugin 'maven'
+        from "../gradle/localMavenUpload.gradle"
+    } else {
+        plugin 'com.github.dcendents.android-maven'
+        plugin 'com.jfrog.bintray'
+        from "../gradle/bintrayUploadJava.gradle"
+    }
+}
+
+gradlePlugin {
+    plugins {
+        busPlugin {
+            id = 'com.blankj.bus'
+            implementationClass = 'com.blankj.bus.BusPlugin'
+        }
+    }
+}
+
+dependencies {
+    implementation dep.gradle
+    implementation dep.javassist
+    implementation dep.commons_io
+    implementation dep.junit
+}
+
+group = rootProject.group
+version = rootProject.versionName
+
+//./gradlew bus-gradle-plugin:bintrayUpload
+//./gradlew publishPlugins

bus-gradle-plugin/project.properties

@@ -0,0 +1,6 @@
+project.name=StaticBusPlugin
+project.siteUrl=https://github.com/Blankj/StaticBus
+project.gitUrl=https://github.com/Blankj/StaticBus.git
+
+#javadoc
+javadoc.name=StaticBus

bus-gradle-plugin/src/main/groovy/com/blankj/bus/BusExtension.groovy

@@ -0,0 +1,5 @@
+package com.blankj.bus
+
+class BusExtension {
+
+}

bus-gradle-plugin/src/main/groovy/com/blankj/bus/BusInject.groovy

@@ -0,0 +1,77 @@
+package com.blankj.bus
+
+import com.blankj.util.ZipUtils
+import javassist.CtClass
+import javassist.CtMethod
+import org.apache.commons.io.FileUtils
+
+class BusInject {
+
+    static void start(HashMap<String, String> bus, File busJar) {
+        String jarPath = busJar.getAbsolutePath()
+        String decompressedJarPath = jarPath.substring(0, jarPath.length() - 4);
+        File decompressedJar = new File(decompressedJarPath)
+        ZipUtils.unzipFile(busJar, decompressedJar)
+
+        CtClass busUtils = Config.mPool.get(Config.CLASS_BUS_UTILS)
+        CtMethod callMethod = busUtils.getDeclaredMethod("post");
+        callMethod.insertAfter(getInsertContent(bus));
+        busUtils.writeFile(decompressedJarPath)
+        busUtils.defrost();
+        FileUtils.forceDelete(busJar)
+        ZipUtils.zipFile(decompressedJar, busJar)
+        FileUtils.forceDelete(decompressedJar)
+    }
+
+    private static String getInsertContent(HashMap<String, String> bus) {
+        StringBuilder sb = new StringBuilder();
+        bus.each { String key, String val ->
+            String name = key
+            String[] method = val.split(' ')
+            String returnType = method[0]
+            String methodName = method[1]
+
+            sb.append('if ("').append(name).append('".equals($1)) {\n')
+
+            int st = methodName.indexOf('(')
+            int end = methodName.length()
+            String params = methodName.substring(st + 1, end - 1);
+            if (params != '') {
+                String[] paramArr = params.split(",")
+
+                StringBuilder args = new StringBuilder()
+                for (int i = 0; i < paramArr.length; i++) {
+                    if (paramArr[i] == 'char') {
+                        args.append(',$2[').append(i).append('].toString().charAt(0)')
+                    } else if (paramArr[i] == 'boolean') {
+                        args.append(',Boolean.parseBoolean($2[').append(i).append('].toString())')
+                    } else if (paramArr[i] == 'byte') {
+                        args.append(',Byte.parseByte($2[').append(i).append('].toString())')
+                    } else if (paramArr[i] == 'short') {
+                        args.append(',Short.parseShort($2[').append(i).append('].toString())')
+                    } else if (paramArr[i] == 'int') {
+                        args.append(',Integer.parseInt($2[').append(i).append('].toString())')
+                    } else if (paramArr[i] == 'long') {
+                        args.append(',Long.parseLong($2[').append(i).append('].toString())')
+                    } else if (paramArr[i] == 'float') {
+                        args.append(',Float.parseFloat($2[').append(i).append('].toString())')
+                    } else if (paramArr[i] == 'double') {
+                        args.append(',Double.parseDouble($2[').append(i).append('].toString())')
+                    } else {
+                        args.append(',(').append(paramArr[i]).append(')$2[').append(i).append(']')
+                    }
+                }
+                methodName = methodName.substring(0, st + 1) + args.substring(1) + ")"
+            }
+
+            if (returnType.equals('void')) {
+                sb.append(methodName).append(';\n').append('return null;\n')
+            } else {
+                sb.append('return ($w)').append(methodName).append(';\n')
+            }
+            sb.append("}")
+        }
+        sb.append('android.util.Log.e("BusUtils", "bus of <" + $1 + "> didn\'t exist.");')
+        return sb.toString()
+    }
+}

bus-gradle-plugin/src/main/groovy/com/blankj/bus/BusPlugin.groovy

@@ -0,0 +1,29 @@
+package com.blankj.bus
+
+import com.android.build.gradle.AppExtension
+import com.android.build.gradle.AppPlugin
+import com.blankj.util.LogUtils
+import com.blankj.util.Utils
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+
+class BusPlugin implements Plugin<Project> {
+
+    @Override
+    void apply(Project project) {
+        if (project.plugins.hasPlugin(AppPlugin)) {
+            Utils.init(project)
+
+            LogUtils.l('project(' + project.name + ') apply bus gradle plugin!')
+
+            project.extensions.create(Config.EXT_NAME, BusExtension)
+
+            def android = project.extensions.getByType(AppExtension)
+
+            android.registerTransform(new BusTransform())
+            project.afterEvaluate {
+                def ext = project[Config.EXT_NAME] as BusExtension
+            }
+        }
+    }
+}

bus-gradle-plugin/src/main/groovy/com/blankj/bus/BusScan.groovy

@@ -0,0 +1,63 @@
+package com.blankj.bus
+
+import com.blankj.util.ZipUtils
+import com.blankj.utilcode.util.BusUtils
+import groovy.io.FileType
+import javassist.CtClass
+import javassist.CtMethod
+import org.apache.commons.io.FileUtils
+
+class BusScan {
+
+    HashMap<String, String> busMap
+    List<File> scans
+    File busJar
+
+    BusScan() {
+        busMap = [:]
+        scans = []
+    }
+
+    void scanJar(File jar) {
+        File tmp = new File(jar.getParent(), "temp_" + jar.getName())
+        ZipUtils.unzipFile(jar, tmp)
+        scanDir(tmp)
+        FileUtils.forceDelete(tmp)
+    }
+
+    void scanDir(File root) {
+        String rootPath = root.getAbsolutePath()
+        if (!rootPath.endsWith(Config.FILE_SEP)) {
+            rootPath += Config.FILE_SEP
+        }
+
+        if (root.isDirectory()) {
+            root.eachFileRecurse(FileType.FILES) { File file ->
+                def fileName = file.name
+                if (!fileName.endsWith('.class')
+                        || fileName.startsWith('R$')
+                        || fileName == 'R.class'
+                        || fileName == 'BuildConfig.class') {
+                    return
+                }
+
+                def filePath = file.absolutePath
+                def packagePath = filePath.replace(rootPath, '')
+                def className = packagePath.replace(Config.FILE_SEP, ".")
+                // delete .class
+                className = className.substring(0, className.length() - 6)
+
+                CtClass ctClass = Config.mPool.get(className)
+
+                CtMethod[] methods = ctClass.getDeclaredMethods();
+                for (CtMethod method : methods) {
+                    if (method.hasAnnotation(BusUtils.Subscribe)) {
+                        String name = method.getAnnotation(BusUtils.Subscribe).name()
+                        String sign = method.getReturnType().getName() + ' ' + method.getLongName()
+                        busMap.put(name, sign)
+                    }
+                }
+            }
+        }
+    }
+}

bus-gradle-plugin/src/main/groovy/com/blankj/bus/BusTransform.groovy

@@ -0,0 +1,119 @@
+package com.blankj.bus
+
+import com.android.build.api.transform.*
+import com.android.build.gradle.internal.pipeline.TransformManager
+import com.blankj.util.JsonUtils
+import com.blankj.util.LogUtils
+import com.blankj.util.Utils
+import org.apache.commons.io.FileUtils
+
+class BusTransform extends Transform {
+
+    @Override
+    String getName() {
+        return "busTransform"
+    }
+
+    @Override
+    Set<QualifiedContent.ContentType> getInputTypes() {
+        return TransformManager.CONTENT_CLASS
+    }
+
+    @Override
+    Set<? super QualifiedContent.Scope> getScopes() {
+        return TransformManager.SCOPE_FULL_PROJECT
+    }
+
+    @Override
+    boolean isIncremental() {
+        return false
+    }
+
+    @Override
+    void transform(TransformInvocation transformInvocation)
+            throws TransformException, InterruptedException, IOException {
+        super.transform(transformInvocation)
+        LogUtils.l(getName() + " started")
+
+        long stTime = System.currentTimeMillis();
+
+        def inputs = transformInvocation.getInputs()
+        def referencedInputs = transformInvocation.getReferencedInputs()
+        def outputProvider = transformInvocation.getOutputProvider()
+        def isIncremental = transformInvocation.isIncremental()
+
+        outputProvider.deleteAll()
+
+        Config.initClassPool()
+        BusScan busScan = new BusScan()
+
+        inputs.each { TransformInput input ->
+            input.directoryInputs.each { DirectoryInput dirInput ->// 遍历文件夹
+                File dir = dirInput.file
+                Config.mPool.appendClassPath(dir.absolutePath)
+
+                def dest = outputProvider.getContentLocation(
+                        dirInput.name,
+                        dirInput.contentTypes,
+                        dirInput.scopes,
+                        Format.DIRECTORY
+                )
+                FileUtils.copyDirectory(dir, dest)
+
+                LogUtils.l("scan " + dirInput.name)
+                busScan.scanDir(dir)
+            }
+
+            input.jarInputs.each { JarInput jarInput ->// 遍历 jar 文件
+                File jar = jarInput.file
+                Config.mPool.appendClassPath(jarInput.file.absolutePath)
+
+                def jarName = jarInput.name
+                def dest = outputProvider.getContentLocation(
+                        jarName,
+                        jarInput.contentTypes,
+                        jarInput.scopes,
+                        Format.JAR
+                )
+                FileUtils.copyFile(jar, dest)
+
+                if (jumpScan(jarName)) {
+                    LogUtils.l("jump " + jarName)
+                    return
+                }
+
+                if (jarName.startsWith("com.blankj:bus:")) {
+                    busScan.busJar = dest
+                    return
+                }
+
+                LogUtils.l("scan " + jarName)
+                busScan.scanJar(jar)
+            }
+        }
+
+        if (busScan.busJar != null) {
+            File jsonFile = new File(Utils.project.projectDir.getAbsolutePath(), "__bus__.json")
+            String busJson = JsonUtils.getFormatJson(busScan.busMap)
+            FileUtils.write(jsonFile, busJson)
+            LogUtils.l(busJson)
+            BusInject.start(busScan.busMap, busScan.busJar)
+        } else {
+            LogUtils.l('u should <implementation "com.blankj:utilcode:1.30.+"> ' +
+                    'or <implementation "com.blankj:bus:1.0+">')
+        }
+
+        LogUtils.l(getName() + " finished: " + (System.currentTimeMillis() - stTime) + "ms")
+    }
+
+    private static boolean jumpScan(String jarName) {
+        boolean isExcept = false
+        for (String except : Config.EXCEPTS) {
+            if (jarName.startsWith(except)) {
+                isExcept = true
+                break
+            }
+        }
+        isExcept
+    }
+}