class MyPlugin : Plugin<Project> {

    override fun apply(project: Project) {
        val androidComponents = project.extensions.getByType(AndroidComponentsExtension::class.java)
        androidComponents.onVariants { variant ->
            val task = project.tasks.register("${variant.name}XXX", MyClassesTask::class.java)

            /*
            variant.artifacts
                .forScope(ScopedArtifacts.Scope.ALL)
                .use(taskProvider)
                .toTransform(
                    ScopedArtifact.CLASSES,
                    MyTask::allJars,
                    MyTask::allDirectories,
                    MyTask::outputFile
                )
            */
            variant.toTransformAll(task) //Equivalent to the above
// variant.toTransformAll(task,false) Passing false as the second parameter means using the original unaccelerated logic
        }
    }
}

//Inheriting DefaultTransformTask
abstract class MyClassesTask : DefaultTransformTask() {

    // Equivalent to the method annotated by @TaskAction before
    override fun startTask() {
        /**
         * singleClassesJar() Whether there is only one jar package, returning true means that there was a plug-in using toTransform before, and it did not use this plug-in or did not follow this design
         */
        /**
         * isFastDex is the second parameter passed in when calling toTransformAll
         */
        allDirectories().forEach { directory ->
            directory.walk().forEach { file ->
                if (file.isFile) {
                    val relativePath = file.getRelativePath(directory)
                    val jarEntryName: String = relativePath.toClassPath()

                    FileInputStream(file).use { inputs ->
                        val cr = ClassReader(inputs)
                        val cw = ClassWriter(cr, 0)
                        cr.accept(
                            MyClassVisitor(cw),
                            ClassReader.EXPAND_FRAMES
                        )
                        cw.toByteArray().inputStream().use {
                            //write jar
                            directory.saveJarEntry(jarEntryName, it)
                        }
                    }
                }
            }
        }

        allJars().forEach { file ->
            if (file.absolutePath in ignoreJar) {
                return@forEach
            }
            val jarFile = JarFile(file)
            val enumeration = jarFile.entries()
            while (enumeration.hasMoreElements()) {
                val jarEntry = enumeration.nextElement()
                val entryName = jarEntry.name
                if (jarEntry.isDirectory || entryName.isEmpty() || entryName.startsWith("META-INF/") || "module-info.class" == entryName || !entryName.endsWith(
                        ".class"
                    )
                ) {
                    continue
                }
                jarFile.getInputStream(jarEntry).use { inputs ->
                    val cr = ClassReader(inputs)
                    val cw = ClassWriter(cr, 0)
                    cr.accept(
                        MyClassVisitor(cw),
                        ClassReader.EXPAND_FRAMES
                    )
                    cw.toByteArray().inputStream().use {
                        //write jar
                        file.saveJarEntry(jarEntryName, it)
                    }
                }
            } jarFile . close ()
        }
    }

    override fun endTask() {
        //Write some final work here
    }

}