The document discusses the introduction of Java 8 features in Android N, specifically focusing on new tools like the Jack compiler and Jill library linker, which enhance build processes and support advanced Java functionalities. It outlines supported Java 8 features such as lambda expressions, default methods in interfaces, functional interfaces, and streams, alongside instructions for incorporating these tools into new and existing projects. The document also provides code examples and links to further documentation for deeper insights into using these features and tools.

1. Jorge Castillo
www.twitter.com/JorgeCastilloPr
www.github.com/JorgeCastilloPrz
jorge.castillo.prz@gmail.com
Developing Android apps with Java 8

2. About us

3. Candidates Companies

4. Our Android team Still hiring!
karumi.com

5. Android N Preview recently published

6. Java 8 appeared in the spotlight

7. Two new tools added to The SDK
● Jack compiler (Java Android Compiler Kit)
● Jill (Jack Intermediate Library Linker)

8. ● Compiles Java sources directly into DEX bytecode
● Improves build times (pre-dexing, incremental compilation)
● Handles shrinking, obfuscation, repackaging and multidex
● Executes annotation processors
Jack
dependencies {
compile 'com.google.dagger:dagger:2.5'
compile 'com.jakewharton:butterknife:8.1.0'
annotationProcessor 'com.jakewharton:butterknife-compiler:8.1.0'
annotationProcessor 'com.google.dagger:dagger-compiler:2.5'
}

9. Jack
Java
source files
Dex files
Shrinking
Repackaging
Obfuscation
Multidex
Jack

10. What about libraries? (.jar, .aar, .apklib)

11. Jill
Jayce
Jack
Extract Res
● Translate library dependencies to Jack format (.jack)
● Prepares them to be quickly merged with other .jack files
Select Res Resources
directory
JACK used to generate a
pre-dexed library
Jayce
Pre-dex
Res
.jack
.class
res
.jar
Jill (Jack Intermediate library linker)

12. APK
Predexing

13. ● No more .class intermediate step in toolchain:
○ Bytecode manipulation tools based on .class files (like JaCoCo)
are not working anymore.
○ Lint detectors based on .class file analysis not working anymore.
● Java 8 just supported on versions >= N (API 24)*
Limitations

14. Okay but, how do I use the new tools ?
Let’s calm down (vamo a calmarno.)

15. ● For new projects: File -> New project -> pick Android N
● For already started projects: Add this to your root build.gradle:
buildscript {
repositories {
jcenter()
}
dependencies {
classpath 'com.android.tools.build:gradle:2.2.0-alpha4'
}
}

16. android {
compileSdkVersion 24
buildToolsVersion "24.0.0"
defaultConfig {
applicationId "com.github.jorgecastillo.java8testproject"
minSdkVersion 9
targetSdkVersion 24
jackOptions {
enabled true
}
}
compileOptions {
sourceCompatibility JavaVersion.VERSION_1_8
targetCompatibility JavaVersion.VERSION_1_8
}
app build.gradle

17. Java 8

18. Supported features

19. ● Default and static interface methods
● Lambdas
● Functional Interfaces
● Method references
● Repeatable annotations
● Some new reflection methods such as
AnnotatedElement.getAnnotationsByType(Class)
● Streams
● Optionals
minSdkVersion 24 minSdkVersion 9
● Lambdas
● Functional Interfaces (not the ones out
of the box from the JDK 8)
● Method references
● Repeatable annotations

20. Interfaces - Default methods

21. public interface DiscoverMoviesPresenter extends DiscoverMovies.Callback {
default void discoverMovies(SortingOption sortingOption) {
getLoadingView().showLoading();
getDiscoverMoviesUseCase().execute(sortingOption, this);
}
@Override default void onSuccess(List<Movie> movies) {
getLoadingView().hideLoading();
getMovieListView().renderMovies(movies);
}
@Override default void onError(String message) {
getLoadingView().hideLoading();
getMovieListView().displayRenderMoviesError(message);
}
LoadingView getLoadingView();
MovieListView getMovieListView();
DiscoverMovies getDiscoverMoviesUseCase();
}

22. ● They make Java 8 interfaces very similar to Traits or rich interfaces
from other modern languages
● They allow developers to compose class behavior based on multiple
interfaces
● Interfaces cannot store state
Interfaces - Default methods

23. Interfaces - Static methods

24. ● I would use them for utility methods tied to the contract
Interfaces - Static methods

25. public interface TimeMachine {
void goToTime(int hour, int minute, int seconds);
void goToDate(int day, int month, int year);
Long getCurrentTime();
Date getCurrentDate();
default ZonedDateTime getZonedDateTime(String zoneString) {
return new ZonedDateTime(getCurrentTime(), getZoneId(zoneString));
}
static Long getZoneId(String zoneString) {
// ...
return 10L;
}
}

26. Lambdas

27. ● Literal representation of a function
● As in other modern languages: input args -> function body
● Assignable to variables
● Being passed as method arguments and returned as return values
(High order functions)
● First class citizen
● Translated to anonymous classes for lower API versions
Lambdas

28. Lambda declaration
private List<Movie> validMovies(
List<Movie> movies,
Function<Movie, Boolean> isValid) {
return movies.stream().filter(isValid::apply)
.collect(Collectors.toList());
}
Function<Movie, Boolean> isValid = movie -> movie.getId() % 2 == 0;
validMovies(movies, isValid);
validMovies(movies, movie -> movie.getId() % 2 == 0); (inline)

29. What if multiple args needed?

30. Functional Interfaces

31. ● Provide target types for lambda expressions and method references
● Java 8 gives you some of them out of the box
Functional interfaces

32. Interfaces - Static methods

33. ● Custom functional interface for lambdas with 3 input arguments
@FunctionalInterface public interface Function3<A, B, C, R> {
R apply(A a, B b, C c);
}
Function3<Long, Integer, Boolean, Boolean> isEven = (l, i, b) -> l % 2 == 0;
● Use it
Function3<Long, Integer, Boolean, Boolean> isEven2 = (l, i, b) -> {
return l % 2 == 0;
};

34. Method references

35. ● Compact, easy-to-read lambda expressions for methods that
already exist
● 4 different types
Method references

36. // static method reference
isValid(User::isYoung);
// instance method reference
isValid(user::isOld);
String[] stringArray = {"Barbara", "James", "Ipolito", "Mary", "John"};
// Instance method reference of arbitrary type
// (string1.compareToIgnoreCase(string2))
Arrays.sort(stringArray, String::compareToIgnoreCase);
// Constructor method reference
generateUsers(User::new);

37. Repeatable annotations

38. ● There are some situations where you want to apply the same
annotation to a declaration or type use.
Repeatable annotations

39. Streams

40. ● Very powerful concept available in many languages
● You can extract the stream from any collection
● flatMap(), reduce(), count(), distinct(), forEach(), max(), min(), sorted(comparator) ...
Streams
users.stream()
.filter(user -> user.getAvatarUrl() != null)
.map(User::getAvatarUrl)
.findFirst()
.orElse("http://anyimage.com/fallback_avatar.png");
String avatar =
List<User> users = new ArrayList<>();

41. ● Jack & Jill
○ Jack documentation https://source.android.com/source/jack.html
○ More details http://android-developers.blogspot.com.es/2014/12/hello-world-meet-our-new-
experimental.html
○ Annotation Processing open issue https://code.google.com/p/android/issues/detail?id=204065
● Java 8 in Android N
○ Supported features with links to documentation http://developer.android.com/preview/j8-jack.html
○ Functional Interfaces out of the box https://docs.oracle.
com/javase/8/docs/api/java/util/function/package-summary.html
Bibliography

42. ?