Searching the web, it is not clear if Java 8 is supported for Android development or not.
Before I download/setup Java 8, can some one point me at any \"official\" d
affffd this line into module lvl build gradel
compileOptions {
sourceCompatibility JavaVersion.VERSION_1_8
targetCompatibility JavaVersion.VERSION_1_8
}
I wrote a similar answer to a similar question on Stack Overflow, but here is part of that answer.
The new version of Android Studio (2.1) has support for Java 8 features. Here is an extract from the Android Developers blogspot post:
... Android Studio 2.1 release includes support for the new Jack compiler and support for Java 8.
...
To use Java 8 language features when developing with the N Developer Preview, you need to use the Jack compiler. The New Project Wizard [File→ New→ Project] generates the correct configurations for projects targeting the N.
Android does not support Java 1.8 yet (it only supports up to 1.7), so you cannot use Java 8 features like lambdas.
This answer gives more detail on Android Studio's compatibility; it states:
If you want to use lambdas, one of the major features of Java 8 in Android, you can use gradle-retrolamba
If you want to know more about using gradle-retrolambda
, this answer gives a lot of detail on doing that.
Yes. We will use Java 8 soon!
We've decided to add support for Java 8 language features directly into the current javac and dx set of tools, and deprecate the Jack toolchain. With this new direction, existing tools and plugins dependent on the Java class file format should continue to work. Moving forward, Java 8 language features will be natively supported by the Android build system. We're aiming to launch this as part of Android Studio in the coming weeks, and we wanted to share this decision early with you.
https://android-developers.googleblog.com/2017/03/future-of-java-8-language-feature.html
You can indeed use gradle-retrolamba
gradle build dependency to use Java 8 for Android Development.
Below is the complete guide that I have recently followed to run lambda expressions for Android development. The original source of this guide is mentioned at the end.
In this guide, a method for bringing some Java 8 features into Android Development Tools will be demonstrated, specifically aiming at Eclipse IDE. However, steps which will be described throughout this guide might also be adapted to Google’s new uprising development environment, Android Studio. It is based on the community edition of popular IntelliJ Idea IDE by JetBrains and it has recently been upgraded to its ‘beta’ version by Google in early July 2014, slightly before this guide was written. Eclipse will remain as the prominent development environment, at least for a while, and considering the fact that most Android projects have been developed using Eclipse, a method for bringing new Java 8 features like lambda expressions into ADT seems to be quite useful for developers.
Android Development is based on a custom Java implementation called Apache Harmony Project which was terminated back in 2011. The most commonly used Java syntax in Android Development is Java 6 (v1.6) and Java 7 (v1.7) is also partially supported on the KitKat edition (Android 4.4.+). Therefore, Java 8 features like lambda expressions cannot be used directly in the Android App Development without applying some tweaks into the development tools. Luckily, these constructs are basically some ‘syntactic sugar’ enhancements which give developers the shortcomings of things like ‘anonymous classes’ and they can be translated into Java 6 or Java 7 classes.
A recent approach for translating a Java 8 source code into lower Java versions is called RetroLambda. This library makes developers run Java 8 code with lambda expressions on Java 7 or even lower. Unfortunately, Java 8 features other than lambda expressions are not supported by RetroLambda for now but the concept of lambda expressions is the biggest leap on Java 8 platform and it’s a great tool for Android developers anyway.
Details about this library can be found on its GitHub page:
https://github.com/orfjackal/retrolambda#getting-started
Also, a Gradle plugin for RetroLambda created by another developer allows Gradle-based builds to be implemented in Java or Android Projects. However, the developer only mentions about integrating this plugin into Android Studio environment. Details can be found on its GitHub page:
https://github.com/evant/gradle-retrolambda
Using these infrastructures within an Eclipse-based development environment cannot be approached directly but it’s doable and will be demonstrated throughout this guide.
This guide assumes that the reader has a basic understanding of Android Development and it is based on ADT version 22.6.2 because recent ADT version 23.0.2 seems to have problems like layout folder creation. Details about this issue can be found under the following link:
http://code.google.com/p/android/issues/detail?id=72591
Steps in this guide will be given for a Windows 8.1, 64-bit development machine but they can easily be adapted to other platforms. The new build system Gradle
will be used for build/clean processes and its installation procedure will also be provided. Also, both JDK 8
and JDK 7
must coexist on the development machine. Steps given below must be followed to install them:
bin
folder to your %PATH%
variableJAVA_HOME
with the value of the path of JDK 8 home folderJAVA8_HOME
again with the value of the path of JDK 8 home folderJAVA7_HOME
with the value of the path of JDK 7 home folderjava -version
command and verify that Java 8 is up and runningjavac -version
command in the same window and verify that JDK 8 Java compiler is also up and runningNow, ADT-22.6.2 must be downloaded from the following link:
http://dl.google.com/android/adt/22.6.2/adt-bundle-windows-x86_64-20140321.zip
D:\adt
ANDROID_HOME
with the value of the path of your ADT installation folder, e.g. D:\adt\sdk
Andoid SDK Platform Tools
and Andoid SDK Tools
folders, e.g. D:\adt\sdk\tools
and D:\adt\sdk\platform-tools
, to your %PATH%
variableD:\adt\eclipse
D:\adt\workspace
Android SDK Manager
button which is located on the toolbarAndroid SDK Build tools Rev. 19.1
and Android Support Library
only. Un-select everything else and install these two packages.If everything goes well, ADT will be up and running.
The installation of the following tools is also highly recommended:
Eclipse Kepler Java 8 Support: It makes Eclipse recognize new Java 8 syntax extensions and makes you get rid of annoying red dots
in your Java code editor. It might be installed through Help -> Install New Software
in Eclipse. Enter http://download.eclipse.org/eclipse/updates/4.3-P-builds/ into the Work with
field and continue to install it.
Nodeclipse/Enide Gradle: It is mainly used to highlight Groovy language keywords. Groovy is used as the DSL for Gradle build scripts. This plugin can be installed through Eclipse Marketplace
. However, Eclipse within ADT-22.6.2 does not come along with Eclipse Marketplace Client
. Therefore, you will first need to install Eclipse Marketplace Client
by means of Install New Software
tool in Eclipse. Enter http//:download.eclipse.org/mpc/kepler/ into the Work with
field and continue to install it. After installing Eclipse Marketplace Client
, you may search for Nodeclipse/Enide Gradle
in the Eclipse Marketplace Client
and install it.
Genymotion Virtual Device: It is a great replacement of the default Android Virtual Device
which comes along with ADT. AVD is annoyingly cumbersome and it keeps on crashing for no reason. Genymotion makes you prepare Android VD's using CyanogenMod
images which are executed by Oracle VirtualBox. Its single user license is for free and it can be downloaded from http://www.genymotion.com. Only a login is required and it can also be integrated into Eclipse. Details can be found under:
https://cloud.genymotion.com/page/doc/#collapse8
Below is a screenshot of an Android 4.3 based CyanogenMod virtual device,
It might be considered as a fully-fledge Android device running on a x86 or x64 based personal computer. In order to use Google services like Google PlayStore
on this virtual device, a gapps
image for the Android version that it uses must be flashed onto the device. A proper gapps
image for the device might be downloaded from CyanogenMod website:
http://wiki.cyanogenmod.org/w/Google_Apps
Gradle installation is optional since it is also provided by Android SDK itself but its separate installation is highly recommended. Installation of it might be conducted by following these steps:
Go to Gradle web site: http://www.gradle.org/
Click Downloads
Previous Releases
choose version 1.10 and download either gradle-1.10-all.zip or gradle-1.10-bin.zipD:\adt\gradle
GRADLE_HOME
with the value of the path of your Gradle installation folder, e.g. D:\adt\gradle
D:\adt\gradle\bin
, to your %PATH%
variablegradle -v
command and verify that it`s up and running
If you have come up to this point successfully then it means that you are ready to create your first Android App using Java 8 features.A simple app will be created to demonstrate the usage of the tools which were described in the previous section. You may simply follow the steps given below to get an insight on using lambda expressions in Android Developer Tools:
File -> New -> Other -> Android -> Android Application Project
Next
button on the following forms and click the Finish
button on the last one. Wait till ADT finishes loading up the projectNew -> Folder
and name it builders
gen (Generated Java Files)
folder and delete it. Gradle will generate the same files for us soon and we will add them into the projects build path. The
gen` folder created by the default Ant builder is no longer needed and the artifacts under that folder will be obsoleteCreate following batch files under the builders
folder:
Fill in these batch files as follows:
gradle_build.cmd:
gradle_post_build.cmd:
gradle_clean.cmd:
Project -> Build Automatically
menu optionProperties -> Builders
and un-select all default builders provided by ADTNew
button in the same window and select Program
and click OK
Main
Tab of the new Builder Configuration
Refresh
Tab of the new Builder Configuration
Environment
Tab of the new Builder Configuration
Build Options
Tab of the new Builder Configuration
Gradle_Post_Build
that uses gradle_post_build.cmd
as its program. All other settings of this builder must exactly be the same with the previously created builder. This builder will be responsible for copying the artifacts created by the build process into the bin
folder.Gradle_Cleaner
that uses gradle_clean.cmd
as its program. Only Run the builder
setting in the final tab must be set as During a Clean
. All other settings of this builder must exactly be the same with the first builder. This builder will be responsible for cleaning the artifacts created by the build process as the name suggests.New Builders of the HelloLambda
Project
Export
Android -> Generate Gradle Build Files
and click Next
Finish
gradlew
and gradlew.bat
. Also delete gradle
folderProject -> Clean
menu option. Fill in the form that shows up as follows:Clean Project
Window
OK
and wait till the cleaning process completessetContentView
function in your MainActivity
class:build.gradle
file till the sourceCompatibility
section as follows:Properties -> Java Compiler
option and set all compliance levels to Java 8. This will make Eclipse recognize new Java 8 constructs like lambda expressions.No
in the notification windowBuild project
. Eclipse will start building the project.Build Process
Right-click on the project and go to Properties -> Java Build Path
. Add the following folders to the build path (also shown in below image):
build\source\buildConfig\debug
build\source\r\debug
Eclipse will now be able to recognize R.java
and buildConfig.java
files and it will not display any red dots
which denote errors related to the resource files of the project.
Run Configuration
for your Android target platform by right-clicking on the project and then selecting Run As -> Run Configurations
. For instance, this demo application looks like shown below on the Genymotion VD:You may observe in the LogCat
window that the code snippet with a simple lambda expression works properly
Source: Using Java 8 Lambda Expressions in Android Developer Tools
Google just announced that Java 8 will be natively support by Android and that the Jack toolchain will deprecate:
We've decided to add support for Java 8 language features directly into the current javac and dx set of tools, and deprecate the Jack toolchain. With this new direction, existing tools and plugins dependent on the Java class file format should continue to work. Moving forward, Java 8 language features will be natively supported by the Android build system. We're aiming to launch this as part of Android Studio in the coming weeks, and we wanted to share this decision early with you.
More Info here: https://android-developers.googleblog.com/2017/03/future-of-java-8-language-feature.html
I figured I would post an updated answer for those looking at for something a little more current.
Currently Android and Android Studio are supporting a subset of Java 8 features. According to the Android documentation located on their website, Google says:
Support for Java 8 language features requires a new compiler called Jack. Jack is supported only on Android Studio 2.1 and higher. So if you want to use Java 8 language features, you need to use Android Studio 2.1 to build your app.
If you already have Android Studio installed, make sure you update to the latest version by clicking Help > Check for Update (on Mac, Android Studio > Check for Updates). If you don't already have the IDE installed on your workstation, download Android Studio here.
Supported Java 8 Language Features and APIs
Android does not support all Java 8 language features. However, the following features are available when developing apps targeting Android 7.0 (API level 24):
- Default and static interface methods Lambda expressions (also available on API level 23 and lower)
- Repeatable annotations
- Method References (also available on API level 23 and lower)
- Type Annotations (also available on API level 23 and lower)
Additionally, the following Java 8 language APIs are also available:
Reflection and language-related APIs:
- java.lang.FunctionalInterface
- java.lang.annotation.Repeatable
- java.lang.reflect.Method.isDefault() and Reflection APIs associated with repeatable annotations, such as AnnotatedElement.getAnnotationsByType(Class)
Utility APIs:
- java.util.function
- java.util.stream
In order to use the new Java 8 language features, you need to also use the Jack toolchain. This new Android toolchain compiles Java language sources into Android-readable DEX bytecode, has its own .jack library format, and provides most toolchain features as part of a single tool: repackaging, shrinking, obfuscation and multidex.
Here is a comparison of the two toolchains used to build Android DEX files:
Legacy javac toolchain: javac (.java → .class) → dx (.class → .dex) New Jack toolchain: Jack (.java → .jack → .dex)