The power of Kotlin @Annotations

Transcript

1. The power of Kotlin @Annotations Giorgio Antonioli - Subito.it
2. • What an annotation is • How to apply it • How to create a custom annotation • How to create an annotation processor
3. @SuppressWarnings /* java */ @SuppressLint /* android */ @DrawableRes /* android */ @Inject /* javax */ @SerializedName /* gson */ @GET /* retrofit */
4. Annotation == Metadata
5. • Class • Annotation • Parameter • Property • Field • Local variable • Constructor • Getter • Setter • Expression • Type alias • Type • File
6. @Ann class Foo class Foo @Ann constructor() @Ann fun foo(arg: Int): Int fun foo(@Ann arg: Int): Int @Ann typealias Bar = Foo
7. class Bar { var foo: Int = 0 } —————— public final class Bar { private int foo; public final int getFoo() { return this.foo; } public final void setFoo(int var1) { this.foo = var1; } }
8. class Bar { @field:FirstAnn @get:SecondAnn @set:ThirdAnn @setparam:FourthAnn var foo: Int = 0 } —————— public final class Bar { @FirstAnn private int foo; @SecondAnn public final int getFoo() { return this.foo; } @ThirdAnn public final void setFoo(@FourthAnn int var1) { this.foo = var1; } }
9. class Bar { @field:[FirstAnn SecondAnn] var foo: Int = 0 } —————— public final class Bar { @FirstAnn @SecondAnn private int foo; public final int getFoo() { return this.foo; } public final void setFoo(int var1) { this.foo = var1; } }
10. • file • property • field • get • set • receiver • param • setparam • delegate
11. annotation class Foo
12. @Target(AnnotationTarget.CLASS) annotation class Foo
13. @Target(AnnotationTarget.CLASS, AnnotationTarget.FIELD) annotation class Foo
14. @Target(AnnotationTarget.CLASS) annotation class Foo(val bar: Int, val baz: String) @Foo(bar = 4, baz = "my-baz") class Quux
15. @Target(AnnotationTarget.CLASS) annotation class Foo(val bar: Int = 0, val baz: String = "default-baz") @Foo class Quux
16. • Java primitive types • Strings • Enums • Classes (KClass) • Annotations • Arrays of the types above
17. @Retention(AnnotationRetention.SOURCE) @Target(AnnotationTarget.CLASS) annotation class Foo
18. AnnotationRetention.SOURCE -> not stored in binary output AnnotationRetention.BINARY -> stored in binary output, not visible for reflection at runtime AnnotationRetention.RUNTIME (default) -> stored in binary output and visible for reflection at runtime
19. const val KITKAT = 19 const val LOLLIPOP = 21 const val PIE = 28 // Same using @StringDef @IntDef(KITKAT, LOLLIPOP, PIE) @Retention(AnnotationRetention.SOURCE) annotation class AndroidVersion @AndroidVersion fun obtainAndroidVersion(): Int = when (Build.VERSION.SDK_INT) { Build.VERSION_CODES.KITKAT -> KITKAT Build.VERSION_CODES.LOLLIPOP -> LOLLIPOP Build.VERSION_CODES.P -> PIE else -> throw IllegalArgumentException("The version is unsupported") }
20. • The processing runs at compile time • Uses KAPT (Kotlin Annotation Processing Tool) • Can not manipulate the existent code • Takes the source files as input and generates new source files • The processing runs in multiple rounds
21. data class Person( var name: String, var age: Int )
22. class PersonBuilder { private lateinit var name: String private var age: Int = 0 fun setName(name: String): PersonBuilder = apply { this.name = name } fun setAge(age: Int): PersonBuilder = apply { this.age = age } fun build(): Person = Person(name = name, age = age) }
23. @Retention(AnnotationRetention.BINARY) @Target(AnnotationTarget.PROPERTY_SETTER) annotation class BuilderSetter
24. data class Person( @set:BuilderSetter var name: String, @set:BuilderSetter var age: Int )
25. • builder-app • Person.kt (the model) • builder-annotations • BuilderSetter.kt (the annotation) • builder-processor • BuilderSetterProcessor.kt (the processor) • META-INF/services/javax.annotation.processing.Processor
26. @AutoService(Processor::class) class BuilderSetterProcessor : AbstractProcessor() { private lateinit var messenger: Messager override fun init(env: ProcessingEnvironment) { super.init(env) messenger = env.messager } override fun getSupportedSourceVersion(): SourceVersion = SourceVersion.latest() override fun getSupportedAnnotationTypes(): Set<String> = setOf(BuilderSetter::class.java.canonicalName) override fun process( annotations: MutableSet<out TypeElement>, roundEnv: RoundEnvironment ): Boolean { try { annotations.forEach { roundEnv.getElementsAnnotatedWith(it).forEach { elem -> // Process the annotated element elem.process() } } } catch (e: ProcessingException) { messenger.printMessage(Diagnostic.Kind.ERROR, e.msg, e.element) } return true } }
27. • JavaPoet by Square • KotlinPoet by Square • Auto Service by Google
28. • https://speakerdeck.com/fondesa/the-power-of-kotlin-at- annotations • https://github.com/Fondesa • https://www.linkedin.com/in/giorgioantonioli/ • https://github.com/Fondesa/Lyra • https://github.com/Fondesa/MangaNow