class DemoTransform extends Transform {
    /**
     * Transform 任务名，编译时会在日志中显示执行的任务。
     */
    @Override
    String getName() {
        return "DemoTransform"
    }

    /**
     * 指定该 Transform 处理的内容类型为 class 文件。
     */
    @Override
    Set<QualifiedContent.ContentType> getInputTypes() {
        return TransformManager.CONTENT_CLASS
    }

    /**
     * 指定该 Transform 扫描的范围，与 #getInputTypes 搭配用于过滤输入的文件内容。
     * SCOPE_FULL_PROJECT 表示扫描所有项目。
     */
    @Override
    Set<? super QualifiedContent.Scope> getScopes() {
        return TransformManager.SCOPE_FULL_PROJECT
    }

    /**
     * 是否支持增量处理，如果支持，则 #transform 传入的文件需要根据俄文件状态判断是否需要处理。
     */
    @Override
    boolean isIncremental() {
        return false
    }

    /**
     * Transform 执行时将通过 transformInvocation 传入过滤后需要处理的内容。
     */
    @Override
    void transform(TransformInvocation transformInvocation) throws TransformException, InterruptedException, IOException {
        // 判断文件状态：
        // checkFileState(...)

        // 处理输入的文件：
        // handleTransform(...)
    }
}

class DemoPlugin implements Plugin<Project> {
    @Override
    void apply(Project project) {
        // 实例化并注册至 Plugin 中：
        DemoTransform demoTransform = new DemoTransform()
        project.android.registerTransform(demoTransform)
    }
}

@Override
void transform(TransformInvocation transformInvocation) throws TransformException, InterruptedException, IOException {
    super.transform(transformInvocation)

    // 如果不是增量模式，需要先删除所有之前生成的产物再重新生成。
    if (!transformInvocation.isIncremental()) {
        transformInvocation.outputProvider.deleteAll()
    }

    transformInvocation.inputs.each { ->
        // 解析 Jar 中的 Class：
        it.jarInputs.each { JarInput eachJarInput ->
            // 也可以单独判断 Jar 中 Class 的文件状态：
            Status jarClassStatus = eachJarInput.getStatus();
            ......
        }

        // 解析 ClassDir 中的 Class：
        it.directoryInputs.each { DirectoryInput eachDirectoryInput ->
            // 也可以单独判断 ClassDir 中 Class 的文件状态：
            Map<File, Status> classStatusMap = eachDirectoryInput.getChangedFiles();
        }
    }
}

public enum Status {
    /**
     * The file was not changed since the last build.
     */
    NOTCHANGED,
    /**
     * The file was added since the last build.
     */
    ADDED,
    /**
     * The file was modified since the last build.
     */
    CHANGED,
    /**
     * The file was removed since the last build.
     */
    REMOVED;
}

@Override
void transform(TransformInvocation transformInvocation) {
    super.transform(transformInvocation)

    transformInvocation.inputs.each { ->

        // 解析 Jar 中的 Class：
        it.jarInputs.each { JarInput eachJarInput ->
            // 1. 从 JarInput 转为原始 Jar 文件：
            File srcJarFile = eachJarInput.file
            // 2. 计算 Transform 执行后即将被转换的新 Jar 文件：
            File targetJarFile = getTargetJarFile(transformInvocation, eachJarInput)
            // 3. 排除 Android 原生包下的文件：
            if (isJarInvalid(eachJarInput)) {
                continue;
            }
            // 4. 筛选 Jar 包内解析的 Class：
            enumerateJarEntryFromJarFile(srcJarFile)
            // 5. 拷贝 Jar 文件：
            //   由于 Transform 的输入和输出是「流式」的，每一个 Transform 的输出都将作为下一个 Transform 的输入，
            //   因此为了确保下一个 Transform 仍然有机会处理每个 Jar（不论当前 Transform 是否已经处理过），
            //   都需要把 Jar 重新拷贝一份到当前 Transform 的输出目录下，
            //   targetJarFile 就是就是根据原始 Jar 计算出的当前 Transform 处理后「将要」生成的输出文件。
            FileUtils.copyFile(jarSrcFile, jarTargetFile)
        }

        // 解析 ClassDir 中的 Class：
        it.directoryInputs.each { DirectoryInput eachDirectoryInput ->
            ......
        }
    }
}

/**
 * 获取原始 Jar 文件对应的 Transform 执行后的文件。
 *
 * 该方法实际上并不会创建一个新的文件，
 * 而是通过 TransformOutputProvider 提前获取到了某个 Jar 文件被 Transform 处理后「将要」生成的文件信息。
 */
private static File getTargetJarFile(TransformInvocation transformInvocation, JarInput jarInput) {
    // 截取原始 Jar 文件的 ShortName：
    String srcJarFileName = jarInput.name
    if (srcJarFileName.toLowerCase().endsWith(".jar")) {
        srcJarFileName = srcJarFileName.substring(0, srcJarFileName.length() - 4)
    }
    // 计算原始 Jar 文件的 MD5 拼接成一个新的唯一文件名，仅仅是为了作为唯一区分，直接用原始文件名一般也可行：
    String srcJarFileMd5 = DigestUtils.md5Hex(jarInput.file.absolutePath)
    String targetJarFileName = srcJarFileName + '_' + srcJarFileMd5
    // 可以粗略地理解为，每一个 Jar 文件如果被 Transform 处理则会对应产生一个新的文件，这一步就是提前拿到将要产生的新文件信息（但不会提前创建）。
    return transformInvocation
            .outputProvider
            .getContentLocation(targetJarFileName, jarInput.contentTypes, jarInput.scopes, Format.JAR)
}

/**
 * 跳过 Android 原生包下的 Jar。
 */
private static boolean isJarInvalid(JarInput jarInput) {
    return (pathName.contains("com.android.support")
            || pathName.contains("/android/m2repository")
            || pathName.contains("androidx."))
}

/**
 * 遍历 Jar 文件内的每个元素，找出包名符合规则的 Class。
 */
private static void enumerateJarEntryFromJarFile(File srcJarFile) {
    def jarFile = new JarFile(jarSrcFile)
    Enumeration allElementsInJar = jarFile.entries()
    while (allElementsInJar != null && allElementsInJar.hasMoreElements()) {
        JarEntry eachJarEntry = (JarEntry) allElementsInJar.nextElement()
        // 判断 Jar 中的元素是否满足条件：
        if (eachJarEntry.getName().startsWith("priv/demo")
                && eachJarEntry.getName().toLowerCase().endsWith(".class")) {
            // 找到包名满足条件的 Class 后，还要判断其类信息（例如接口、注解等）是否也满足条件：
            // scanClassFromJarEntry(...)
        }
    }
    jarFile.close()
}

@Override
void transform(TransformInvocation transformInvocation) {
    super.transform(transformInvocation)

    transformInvocation.inputs.each { ->

        // 解析 Jar 中的 Class：
        it.jarInputs.each { JarInput eachJarInput ->
            ......
        }

        // 解析 ClassDir 中的 Class：
        it.directoryInputs.each { DirectoryInput eachDirectoryInput ->
            // 1. 从 DictionaryInput 转换为原始目录文件：
            File srcClassDir = directoryInput.file
            // 2. 计算 Transform 执行后即将被转换的新目录文件：
            File targetClassDir = getTargetClassDirectoryFile(transformInvocation, eachDirectoryInput)
            // 3. 筛选 Class 目录内的 Class：
            enumerateClassFromClassDir(srcClassDir)
            // 4. 拷贝 Class 目录：
            //   同理，为了确保下一个 Transform 仍然有机会处理每个 ClassDir（不论当前 Transform 是否已经处理过），
            //   都需要把 ClassDir 重新拷贝一份到当前 Transform 的输出目录下，
            //   targetClassDir 就是就是根据原始 ClassDir 计算出的当前 Transform 处理后「将要」生成的目录文件。
            FileUtils.copyDirectory(srcClassDir, targetClassDir)
        }
    }
}

/**
 * 获取原始 Class 目录对应的 Transform 处理后的目录。
 *
 * 该方法实际上并不会创建一个新的目录，
 * 而是通过 TransformOutputProvider 提前获取到了某个 Class 目录被 Transform 处理后「将要」生成的目录信息。
 */
private static File getTargetClassDirectoryFile(TransformInvocation transformInvocation, DirectoryInput directoryInput) {
    return transformInvocation
            .outputProvider
            .getContentLocation(directoryInput.name, directoryInput.contentTypes, directoryInput.scopes, Format.DIRECTORY)
}

/**
 * 遍历 Class 目录内的每个文件，找出包名符合规则的 Class。
 */
private static void enumerateClassFromClassDir(File srcClassDir) {
    srcClassDir.eachFileRecurse { File eachClassFile ->
        if (!eachClassFile.isFile()) {
            continue;
        }
        // 根据每个 Class 文件的路径反推 Class 的包名：
        String eachClassShortPath = getClassShortPathFromFile(srcClassDir, eachClassFile)
        // 判断每个 Class 是否满足条件：
        if (eachClassShortPath.startsWith("priv/demo")
                && eachClassShortPath.endsWith(".class")) {
            // 找到包名满足条件的 Class 后，还要判断其类信息（例如接口、注解等）是否也满足条件：
            // scanClassFromClassFile(...)
        }
    }
}

/**
 * 根据 Class 文件以及所在目录反推 Class 的文件短路径。
 *
 * 因为每个 Java 类会根据包名创建对应的目录结构，但在不同构建设备上绝对路径并不一定相同，
 *   例如：priv.demo.DemoClass.java 绝对路径可能为 XXX/Project/src/main/java/priv/demo/DemoClass.java
 * 只有包名对应的短路径一定相同：priv/demo/DemoClass.Java，所以只能通过短路径反推包名是否符合条件。
 */
private static String getClassShortPathFromFile(File srcClassDir, File srcClassFile) {
    // 先拿出类所在目录的绝对路径：
    String srcClassDirPath = srcClassDir.absolutePath
    if (!srcClassDirPath.endsWith(File.separator)) {
        srcClassDirPath += File.separator
    }
    // 从类的绝对路径中删掉前面所在目录的部分：
    // Class 目录是一个大目录，其路径不包含 Class 包名对应目录。
    String classShortPath = srcClassFile.absolutePath.replace(srcClassDirPath, '')
    // 由于构建机系统并不确定，还需要将路径转换为统一的标准，此处均以 Unix 路径为标准：
    if (File.separator != '/') {
        classShortPath = classShortPath.replace("\\\\", "/")
    }
    return classShortPath;
}

/**
 * 创建一个自定义的 ClassVisitor，用于读取 Class 文件的类信息。
 */
class ClassScannerClassVisitor extends ClassVisitor {

    static scanFromFileInputStream(InputStream classFileInputStream) {
        ClassReader classReader = new ClassReader(classFileInputStream)
        ClassWriter classWriter = new ClassWriter(classReader, 0)
        ClassScannerClassVisitor scannerClassVisitor = new ClassScannerClassVisitor(Opcodes.ASM5, classWriter)
        classReader.accept(scannerClassVisitor, ClassReader.EXPAND_FRAMES)
    }

    ClassScannerClassVisitor(int api, ClassVisitor classVisitor) {
        super(api, classVisitor)
    }

    @Override
    void visit(int version, int access, String className, String signature,
                String superName, String[] interfaces) {
        super.visit(version, access, className, signature, superName, interfaces)

        // 示例 - 读取类的接口信息：
        interfaces.each { interfaceName ->
        }
    }
}

/**
 * 通过自定义的 ClassScannerClassVisitor 从 JarEntry 中读取类信息。
 */
private static void scanClassFromJarEntry(File srcJarFile, JarEntry jarEntry) {
    InputStream srcJarFileInputStream = srcJarFile.getInputStream(jarEntry)
    ClassScannerClassVisitor.scanFromFileInputStream(srcJarFileInputStream)
    srcJarFileInputStream.close()
}

/**
 * 通过自定义的 ClassScannerClassVisitor 从 Class 文件中读取类信息。
 */
private static void scanClassFromClassFile(File classFile) {
    FileInputStream classFileInputStream = new FileInputStream(classFile)
    ClassScannerClassVisitor.scanFromFileInputStream(classFileInputStream)
    classFileInputStream.close()
}