Implement dynamic code loading using code generator x reflection

app/build.gradle

@@ -1,6 +1,7 @@
 apply plugin: 'com.android.application'
 apply plugin: 'kotlin-android'
 apply plugin: 'kotlin-android-extensions'
+apply plugin: 'kotlin-kapt'
 apply from: "$rootDir/build-system/dependencies-feature-generator.gradle"
 
 android {
@@ -27,6 +28,8 @@ dependencies {
     }
 
     implementation project(':launcher:main')
+    implementation project(':launcher:annotations')
+    kapt project(':launcher:compiler')
 
     implementation"org.jetbrains.kotlin:kotlin-stdlib-jdk7:$kotlin_version"
     implementation 'androidx.appcompat:appcompat:1.0.2'

app/src/main/java/com/wisnu/ordertiket/MainLauncher.kt

@@ -1,19 +1,20 @@
 package com.wisnu.ordertiket
 
 import android.app.Application
-import com.wisnu.feature.order.flight.OrderFlightFeatureApplication
-import com.wisnu.feature.order.hotel.OrderHotelFeatureApplication
-import com.wisnu.feature.order.train.OrderTrainFeatureApplication
-import com.wisnu.feature.setting.SettingFeatureApplication
-import com.wisnu.feature.transaction.TransactionFeatureApplication
+import com.wisnu.launcher.annotations.RegisterFeature
 import com.wisnu.launcher.main.BaseLauncher
+import com.wisnu.launcher.main.FeatureApplicationClassName
 
+@RegisterFeature(
+    FeatureApplicationClassName.ORDER_FLIGHT,
+    FeatureApplicationClassName.ORDER_HOTEL,
+    FeatureApplicationClassName.ORDER_TRAIN,
+    FeatureApplicationClassName.TRANSACTION,
+    FeatureApplicationClassName.SETTING
+)
 class MainLauncher(application: Application) : BaseLauncher(application) {
     init {
-        registerFeatureApplication(OrderFlightFeatureApplication())
-        registerFeatureApplication(OrderHotelFeatureApplication())
-        registerFeatureApplication(OrderTrainFeatureApplication())
-        registerFeatureApplication(TransactionFeatureApplication())
-        registerFeatureApplication(SettingFeatureApplication())
+        MainLauncherUtils.buildFeatures()
+            .forEach { registerFeatureApplication(it) }
     }
 }

build-system/dependencies-module.gradle

@@ -1,6 +1,7 @@
 apply plugin: 'com.android.library'
 apply plugin: 'kotlin-android'
 apply plugin: 'kotlin-android-extensions'
+apply plugin: 'kotlin-kapt'
 apply from: "$rootDir/build-system/dependencies-feature-generator.gradle"
 
 androidExtensions {

gradle.properties

@@ -19,3 +19,4 @@ android.useAndroidX=true
 android.enableJetifier=true
 # Kotlin code style for this project: "official" or "obsolete":
 kotlin.code.style=official
+kapt.incremental.apt=true

launcher/annotations/build.gradle

@@ -1,4 +1,8 @@
 apply plugin: 'java-library'
 
-sourceCompatibility = JavaVersion.VERSION_1_8
-targetCompatibility = JavaVersion.VERSION_1_8
+dependencies {
+    implementation fileTree(dir: 'libs', include: ['*.jar'])
+}
+
+sourceCompatibility = "7"
+targetCompatibility = "7"

launcher/annotations/src/main/java/com/wisnu/launcher/annotations/RegisterFeature.java

@@ -0,0 +1,12 @@
+package com.wisnu.launcher.annotations;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.CLASS)
+public @interface RegisterFeature {
+    String[] value();
+}

launcher/compiler/build.gradle

@@ -3,6 +3,7 @@ apply plugin: 'kotlin'
 dependencies {
     implementation project(':launcher:annotations')
     implementation "com.squareup:javapoet:1.11.1"
+    implementation"org.jetbrains.kotlin:kotlin-stdlib-jdk7:$kotlin_version"
 }
 
 sourceCompatibility = JavaVersion.VERSION_1_8

launcher/compiler/src/main/java/com/wisnu/launcher/compiler/ClassExtensions.kt

@@ -0,0 +1,14 @@
+package com.wisnu.launcher.compiler
+
+private val classMap = mutableMapOf<String, Class<*>>()
+
+private inline fun <reified T : Any> Any.castOrNull() = this as? T
+
+internal fun <T> String.loadClassOrNull(): Class<out T>? =
+    classMap.getOrPut(this) {
+        try {
+            Class.forName(this)
+        } catch (e: ClassNotFoundException) {
+            return null
+        }
+    }.castOrNull()

launcher/compiler/src/main/java/com/wisnu/launcher/compiler/FeatureAnnotatedClass.kt

@@ -0,0 +1,32 @@
+package com.wisnu.launcher.compiler
+
+import com.squareup.javapoet.ClassName
+import com.wisnu.launcher.annotations.RegisterFeature
+import javax.lang.model.element.TypeElement
+import javax.lang.model.util.Elements
+
+class FeatureAnnotatedClass(element: TypeElement, elementUtils: Elements) {
+
+    val className: ClassName
+    val features: Array<String>
+
+    init {
+        val packageName = getPackageName(elementUtils, element)
+        val originalClassName = getClassName(element, packageName)
+        this.className = ClassName.get(packageName, originalClassName)
+        this.features = element.getAnnotation(RegisterFeature::class.java).value
+    }
+
+    private fun getPackageName(elementUtils: Elements, type: TypeElement): String {
+        return elementUtils.getPackageOf(type).qualifiedName.toString()
+    }
+
+    private fun getClassName(element: TypeElement, packageName: String): String {
+        return element.qualifiedName.toString().substring(packageName.length + 1).replace('.', '$')
+    }
+
+    override fun toString(): String {
+        return className.toString()
+    }
+
+}

launcher/compiler/src/main/java/com/wisnu/launcher/compiler/FeatureListWriter.kt

@@ -0,0 +1,42 @@
+package com.wisnu.launcher.compiler
+
+import com.squareup.javapoet.*
+import java.io.IOException
+import java.util.*
+import javax.annotation.processing.Filer
+import javax.lang.model.element.Modifier
+
+class FeatureListWriter(private val featureAnnotatedClass: FeatureAnnotatedClass) {
+
+    @Throws(IOException::class)
+    fun write(filer: Filer) {
+        val classBuilder = TypeSpec.classBuilder("${featureAnnotatedClass.className.simpleName()}Utils")
+        classBuilder.addModifiers(Modifier.PUBLIC, Modifier.FINAL)
+        classBuilder.addMethod(createBuildFeaturesMethod())
+        JavaFile.builder(featureAnnotatedClass.className.packageName(), classBuilder.build()).build().writeTo(filer)
+    }
+
+    private fun createBuildFeaturesMethod(): MethodSpec {
+        val methodName = "buildFeatures"
+        val localVariableName = "Features"
+        val featureType = ClassName.get("com.wisnu.launcher.main", "FeatureApplication")
+        val listType = ClassName.get(List::class.java)
+        val arrayListType = ClassName.get(ArrayList::class.java)
+        val returnType = ParameterizedTypeName.get(listType, featureType)
+
+        val buildFeatures = MethodSpec.methodBuilder(methodName)
+            .addModifiers(Modifier.STATIC)
+            .addModifiers(Modifier.FINAL)
+            .returns(returnType)
+            .addStatement("\$T $localVariableName = new \$T<>()", returnType, arrayListType)
+
+        featureAnnotatedClass.features
+            .filter { it.loadClassOrNull<Any>() != null }
+            .forEach { buildFeatures.addStatement("$localVariableName.add(new $it())") }
+
+        buildFeatures.addStatement("return $localVariableName")
+
+        return buildFeatures.build()
+    }
+
+}

launcher/compiler/src/main/java/com/wisnu/launcher/compiler/FeatureProcessor.kt

@@ -0,0 +1,49 @@
+package com.wisnu.launcher.compiler
+
+import com.wisnu.launcher.annotations.RegisterFeature
+import java.io.IOException
+import javax.annotation.processing.*
+import javax.lang.model.SourceVersion
+import javax.lang.model.element.TypeElement
+import javax.lang.model.util.Elements
+import javax.tools.Diagnostic
+import kotlin.properties.Delegates
+import javax.annotation.processing.ProcessingEnvironment
+
+class FeatureProcessor : AbstractProcessor() {
+    private var filer: Filer by Delegates.notNull()
+    private var messager: Messager by Delegates.notNull()
+    private var elementUtils: Elements by Delegates.notNull()
+
+    @Synchronized
+    override fun init(processingEnv: ProcessingEnvironment) {
+        super.init(processingEnv)
+        filer = processingEnv.filer
+        messager = processingEnv.messager
+        elementUtils = processingEnv.elementUtils
+    }
+
+    override fun getSupportedSourceVersion(): SourceVersion = SourceVersion.latestSupported()
+
+    override fun getSupportedAnnotationTypes(): Set<String> = hashSetOf(RegisterFeature::class.java.canonicalName)
+
+    override fun process(annotations: Set<TypeElement>, roundEnv: RoundEnvironment): Boolean {
+        parseEnv(roundEnv, elementUtils)
+            .map { FeatureListWriter(it) }
+            .forEach {
+                try {
+                    it.write(filer)
+                } catch (e: IOException) {
+                    messager.printMessage(Diagnostic.Kind.ERROR, e.message)
+                }
+            }
+        return true
+    }
+
+    private fun parseEnv(roundEnv: RoundEnvironment, elementUtils: Elements): List<FeatureAnnotatedClass> {
+        return roundEnv.getElementsAnnotatedWith(RegisterFeature::class.java).map {
+            FeatureAnnotatedClass(it as TypeElement, elementUtils)
+        }
+    }
+
+}

launcher/compiler/src/main/resources/META-INF/services/javax.annotation.processing.Processor

@@ -0,0 +1 @@
+com.wisnu.launcher.compiler.FeatureProcessor

launcher/main/src/main/java/com/wisnu/launcher/main/Constant.kt

@@ -6,4 +6,12 @@ object FeatureType {
     const val ORDER_FLIGHT = 2
     const val ORDER_TRAIN = 3
     const val ORDER_HOTEL = 4
+}
+
+object FeatureApplicationClassName {
+    const val ORDER_FLIGHT = "com.wisnu.feature.order.flight.OrderFlightFeatureApplication"
+    const val ORDER_HOTEL = "com.wisnu.feature.order.hotel.OrderHotelFeatureApplication"
+    const val ORDER_TRAIN = "com.wisnu.feature.order.train.OrderTrainFeatureApplication"
+    const val TRANSACTION = "com.wisnu.feature.transaction.TransactionFeatureApplication"
+    const val SETTING = "com.wisnu.feature.setting.SettingFeatureApplication"
 }