Developing Android apps with Java 8

Google has recently released a preview version of Android N, and brand new Java 8 features appeared around. They gave us a sneak peak about the future of Android development.

In this talk we are going to showcase all the supported new language features up to date, detailing which ones are retrocompatible and which ones will just be available starting on API 24 (N). We will get our hands on a Clean Architecture sample project which will use java 8 functionalities on its diffent layers, in order to make people think a little bit more about how those new language features can become handy for us to simplify our code and project architecture.

Transcript

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. ?