Android N Java 8 features (Jack compiler) and Kotlin interop

Solution 1:

disclaimer: I work on Jack

This won't affect you. Kotlin's compiler produces Java 6 bytecode, which Jack/Jill can import just fine.

Solution 2:

@Pavel Dudka

Jack - is a compiler. Similar to javac, but it does a slightly different thing:

As you can see, Jack compiles Java source code straight into Dex file! We don't have intermediate *.class files anymore, so dx tool is not needed!

But wait! What if I include a third-party library in my project (which comes as a collection of .class files)?

And that's when Jill comes into play:

Jill can process class files and transform them into special Jayce format which can be used as an input for Jack compiler.

So now let's step aside for a second and think... What is going to happen to all those cool plugins we got so addicted to? They all need .class files and Jack compiler doesn't have those anymore...

Luckily, Jack provides some of those important for us features out of the box:

• Retrolambda - will not be needed. Jack can handle lambdas properly
• Proguard - it is baked into Jack now, so you can still use obfuscation and minimization

Advantages:

Jack supports Java programming language 1.7 and integrates additional features described below.

• Predexing

  When generating a JACK library file, the .dex of the library is generated and stored inside the .jack library file as a pre-dex. When compiling, JACK reuses the pre-dex from each library. All libraries are pre-dexed.

• Incremental compilation

  Incremental compilation means that only components that were touched since the last compilation, and their dependencies, are recompiled. Incremental compilation can be significantly faster than a full compilation when changes are limited to only a limited set of components.

• Repackaging

  JACK uses jarjar configuration files to do the repackaging.

• Multidex support

  Since dex files are limited to 65K methods, apps with over 65K methods must be split into multiple dex files. (See ‘Building Apps with Over 65K Methods’ for more information about multidex.)

Disadvantages:

• Transform API is not supported by Jack - there is no intermediate Java bytecode you can modify, so some plugins I didn't mention here will stop working
• Annotation processing is not currently supported by Jack, so if you heavily depend on libraries like Dagger, AutoValue, etc., you should think twice before switching to Jack. EDIT: As pointed out by Jake Wharton, Jack in N Preview has annotation processing support, but it is not exposed yet through Gradle.
• Lint detectors which operate on a Java bytecode level are not supported.
• Jacoco is not supported - well, I personally find Jacoco questionable (it doesnt really show what you want to see), so can totally live without it
• Dexguard - enterprise version of Proguard is not currently supported

Solution 3:

Google is not going to push Jack as the default tool, but Jack and Jill.
Compiling .class files to dex with Jill is here to stay. Otherwise, you can say goodbye to jar/aar libraries.

Whether Jack or Jill will be slower is still up for debate. The Android team hopes that jack will be faster than the current build process, but that's not the case right now

Furthermore, Jack and Dex are available in the open, nothing prevents the kotlin team from writing a tool emiting .jack or .dex files from kotlin sourcecode.

Solution 4:

UPDATE (03/16/2017)

Luckily, Jack is dead and so it won't affect Kotlin developers.

If Jack is the future then you will get stuck in the past with Kotlin. Currently Jack doesn't support plugins that can compile non-Java source into Dalvik bytecode. And even if it did JetBrains would need to add a new backend to the Kotlin compiler which is not a trivial task. So you will have to use Kotlin with Jill and it's going to be something very similar to the toolchain you use now.

As you can see in the image below even if it's impossible to explicitly turn off Jack you'll still be able to convert the project to a library project to use Jill. And the application project will just reference this library project.

The only way I see how Kotlin can work with Jack, which probably will not be implemented, is adding a Java backend to the Kotlin compiler, i.e. a backend that generates Java code like Xtend. In this case code generated by the Kotlin compiler can be processed by Jack as any other Java code.

But at the moment we don't know exactly what Jack will support when it's released. Maybe something will change dramatically and adding Kotlin support to Jack will become possible.