Dancing with Android in a World Without Kotlin

[[190578]]

It's easier to start something than to walk away from it. — Donald Rumsfeld

Life without Kotlin is like playing Warcraft 3 on a trackpad. Buying a mouse is easy, but what do you do if your new employer doesn’t want you to use Kotlin in production?

Here are some options.

• Talk to your product owner about getting the right to use Kotlin.
• Use Kotlin and don’t tell anyone because you know the best stuff is just for you.
• Wipe your tears and use Java with pride.

Imagine that you lose the fight with the product owner, and as a professional engineer, you cannot use those trendy technologies privately without their consent. I know this sounds terrible, especially when you have tasted the benefits of Kotlin, but don't lose faith in life.

In the rest of the article, I want to briefly describe some of the features of Kotlin that you can apply to your Java code in Android through some well-known tools and libraries. A basic understanding of Kotlin and Java is required.

Data Class

I think you must have fallen in love with Kotlin's data classes. It's easy for you to get equals(), hashCode(), toString(), and copy(). Specifically, the data keyword can also generate componentN() functions corresponding to the properties in the declaration order. They are used for destructuring declarations.

 data class Person(val name: String)
 val (riddle) = Person("Peter")
 println(riddle)

Do you know what will be printed? Indeed, it will not be the value returned from toString() of the Person class. This is the effect of destructuring declaration, which assigns the value from name to riddle. Using parentheses (riddle) the compiler knows that it must use the destructuring declaration mechanism.

 val (riddle): String = Person("Peter").component1()
 println(riddle) // prints Peter)

This code doesn't compile. It just shows how constructor declarations work.

As you can see the data keyword is a super useful language feature, so what can you do to bring it to your Java world? Use an annotation processor and modify the Abstract Syntax Tree. If you want to go deeper, read the article listed at the end of the article (Project Lombok — Trick Explained).

Using Project Lombok you can achieve almost the same functionality provided by the data keyword. Unfortunately, there is no way to do destructuring declarations.

 import lombok.Data;
 @Data class Person {
 final String name;
 }

The @Data annotation generates equals(), hashCode(), and toString(). In addition, it creates getters for all fields, setters for all non-final fields, and constructors for all required fields (final). It is worth noting that Lombok is only used for compilation, so the library code will not be added to your final .apk.

Lambda Expressions

Android engineers have a very hard life because of the lack of Java 8 features in Android, and one of them is lambda expressions. Lambdas are great because they save tons of boilerplate for you. You can use them in callbacks and streams. In Kotlin, lambda expressions are built-in and they look much better than they do in Java. Also, the bytecode of the lambda can be inserted directly into the bytecode of the calling method, so the method count does not increase. It is possible to use inline functions.

 button.setOnClickListener { println("Hello World") }

Recently Google announced support for Java 8 features in Android, and thanks to the Jack compiler you can use lambdas in your code. It is also important to mention that they are available on API level 23 and lower.

 button.setOnClickListener(view -> System.out.println("Hello World!"));

How to use them? Just add the following lines to your build.gradle file.

 defaultConfig {
 jackOptions {
 enabled true
 }
 }
 compileOptions {
 sourceCompatibility JavaVersion.VERSION_1_8
 targetCompatibility JavaVersion.VERSION_1_8
 }

If you don't like using the Jack compiler, or you can't use it for some reason, there is a different solution for you. The Retrolambda project allows you to run Java 8 code with lambda expressions on Java 7, 6 or 5. Here is the setup process.

 dependencies {
 classpath 'me.tatarka:gradle-retrolambda:3.4.0'
 }
 apply plugin: 'me.tatarka.retrolambda'
 compileOptions {
 sourceCompatibility JavaVersion.VERSION_1_8
 targetCompatibility JavaVersion.VERSION_1_8
 }

As I mentioned before, lambda inline functions in Kotlin do not increase the method count, but how to use them under Jack or Retrolambda? Apparently, they are not free, and the hidden costs are as follows.

​​

This table shows the number of methods generated using different versions of the Retrolambda and Jack compilers. This comparison is from Jake Wharton's "Exploring the Hidden Costs of Java" technical talk.

Data Operations

Kotlin introduced higher-order functions as an alternative to streams. They are very useful when you have to transform one set of data into another or filter a collection.

 fun foo(persons: MutableList<Person>) {
 persons.filter { it.age >= 21 }
 .filter { it.name.startsWith("P") }
 .map { it.name }
 .sorted()
 .forEach(::println)
 }
 data class Person(val name: String, val age: Int)

Streams are also provided by Google through the Jack compiler. Unfortunately, Jack does not work with Lombok because it skips generating intermediate .class files when compiling code, and Lombok relies on these files.

 void foo(List<Person> persons) {
 persons.stream()
 .filter(it -> it.getAge() >= 21)
 .filter(it -> it.getName().startsWith("P"))
 .map(Person::getName)
 .sorted()
 .forEach(System.out::println);
 }
 class Person {
 final private String name;
 final private int age;
 public Person(String name, int age) {
 this.name = name;
 this.age = age;
 }
 String getName() { return name; }
 int getAge() { return age; }
 }

This is great, so where’s the catch? Sadly, streams are only available from API 24. Good job Google, but which app has minSdkVersion = 24?

Fortunately, the Android platform has a great open source community that provides many great libraries. One of them is the Lightweight-Stream-API, which contains an iterator-based stream implementation for Java 7 and below.

 import lombok.Data;
 import com.annimon.stream.Stream;
 void foo(List<Person> persons) {
 Stream.of(persons)
 .filter(it -> it.getAge() >= 21)
 .filter(it -> it.getName().startsWith("P"))
 .map(Person::getName)
 .sorted()
 .forEach(System.out::println);
 }
 @Data class Person {
 final String name;
 final int age;
 }

The example above combines Lombok, Retrolambda and the Lightweight-Stream-API and it looks almost as awesome as Kotlin. Using a static factory method allows you to convert any Iterable into a stream and apply lambdas to it, just like Java 8 streams. It would be perfect to wrap the static call Stream.of(persons) as an extension function of the Iterable type, but Java doesn't support it.

Extension Functions

The extension mechanism provides the ability to add functionality to a class without inheriting from it. This well-known concept fits the Android world perfectly, which is why Kotlin is popular in that community.

Is there a technique or magic to add extension functions to your Java toolbox? With Lombok, you can use them as an experimental feature. According to the Lombok documentation, they want to move it out of experimental status and basically nothing will change soon. Let's refactor an example and wrap Stream.of(persons) into an extension function.

 import lombok.Data;
 import lombok.experimental.ExtensionMethod;
 @ExtensionMethod(Streams.class)
 public class Foo {
 void foo(List<Person> persons) {
 persons.toStream()
 .filter(it -> it.getAge() >= 21)
 .filter(it -> it.getName().startsWith("P"))
 .map(Person::getName)
 .sorted()
 .forEach(System.out::println);
 }
 }
 @Data class Person {
 final String name;
 final int age;
 }
 class Streams {
 static <T> Stream<T> toStream(List<T> list) {
 return Stream.of(list);
 }
 }

All methods are public, static, and have at least one parameter of a non-primitive type, thus they are extension methods. The @ExtensionMethod annotation allows you to specify a class that contains your extension function. You can also pass an array instead of using a .class object.

I'm fully aware that some of my ideas are very controversial, especially Lombok, and I'm also aware that there are a lot of libraries out there that can make your life easier. Please don't hesitate to share your experiences in the comments. Cheers!

​​​​