Digest #127

This Weeks Links

Fragmented Podcast 70: An honest discussion about Realm
In this episode Donn and Kaushik have an honest discussion about Realm (a client side database). Donn has worked pretty extensively with Realm and even consulted for their Android platform previously. But Kaushik has only recently tried it out on a production app.

How “Effective Java” may have influenced the design of Kotlin — Part 1
Modern programming languages have an advantage over established languages because they can learn from their weaknesses and mistakes. This series and part 1 takes a looks at some things Kotlin may have picked up from “Effective Java”.

Bringing Your App’s Data To Every User’s Wrist With Android Wear
In this post, Daniele Bonaldo, will take you through design your Android Wear app, so that it’s data is directly accessible from the face of a smartwatch. The post will also show you how to sync data between a mobile an android phone and a smartwatch, then display it using the new Complications API.

Understanding Android APK and reducing size [Part 2]
Device storage and bandwidth limitations of users are just a couple of reasons App size really matters, especially when going live on the Play Store. The second part of this series goes on to explain how to publish the APK files that were created in Part 1, to the Play Store.

Using Mockito with Kotlin
In this post, Pavel Dudka, discusses using the Mockito framework to mock classes in Kotlin. The post graciously accepts and shares the feedback of the readers to deliver an expanded post which provides multiple solutions to tackle the issue surrounding mocking final classes.

Android Dagger2: Critical things to know before you implement.
There are certain aspects of the Dagger2 which should be understood. In this post, Janishar Ali, will explore when and how a dependency class is instantiated to provide a better understanding and help avoid disasters.

Simple Things – Part 2
This series, Mark Allison, will cover some of the basics of Android Things and guide your through creating a simple weather station. Part 2 takes a look at the General Purpose Input Output (GPIO) class, used to interact with devices and the Rainbow HAT driver.

Writing your first Android Things driver
While Android Things includes ‘user drivers’ which allow you to control certain peripherals, custom drivers will provided the possibility for an expanded peripherals list and functionality. Join Xavi Rigau as he shows you what writing a new peripherals driver for Android Things will involve.

Smoke & Mirrors: The Magic Behind Wonderful UI in Android
This post provides a video and notes of a talk by by Israel Ferrer Camacho on creating a flawless, and smooth user experience using ““smoke and mirrors” – techniques that are not what they initially appear to be.

Simple RxJava mistakes and how to avoid them
Straight to the point, this post will provide you with some examples of common mistakes devs make in RxJava. You will then be shown techniques and tips you can use to avoid making the same mistakes yourself.

Jobs

Looking to hire an Android Dev? Look no further, post your job in the Android Dev Digest for one to four weeks. Reach over 15,000 Android professionals. Learn More

Use OkHttp to make Network Requests on Android
In this tutorial and video, S.Saurel will show you how to use the OkHttp Library, to make Network Requests. The demo will call a JSON web service and display the result on the screen.

Using Mockito 2.x on Android
Mockito now has first class support for Android instrumentation tests. Mocking final classes, mocking final methods and running Mockito directly onto an actual Android device are all now possible. Check out this post by Jeroen Mols for more details.

Learn to draw an Analog Clock on Android with the Canvas 2D API
In this tutorial, S.Saurel will guide you through using the Canvas 2D API. You will create a custom view and draw on a canvas to make an Analog Clock face for Android.

Crash Reporting With Crashlytics
Crashes are almost impossible to avoid but minimizing them is very important. Crashlytics can assist you provide insight into a crash, to help you avoid poor user experiences. In this tutorial, Chike Mgbemena will show you how to integrate Crashlytics and get started with an example app.

Silence speaks louder than words when finding malware
Some malware can degrade the Android experience to such an extent that some users factory reset or abandon their devices. This blog post explores how the Android Security team uses this measureable data to identify the security-related reasons that devices stop working, in an effort to prevent it occurring.

Continuous Integration with Android
This post will introduce you to CircleCI and walk you through this continuous integration and delivery platform’s setup, configuration with Firebase and testing.

Learn to parse an HTML Page on Android with JSoup
In this tutorial and video, S.Saurel will demonstrate how to use the JSoup Library, a great API for extracting and manipulating data, to parse a HTML page on Android.

Videos

Caster.IO Lesson 151: RxJava Operators – defer()
This lesson describes how you can easily take any expensive method and wrap the call inside an RxJava Observable using the defer() operator.

We describe Observable.defer() and how we can use this to wrap any method in an Observable so that we can defer the execution of an expensive method until the correct time, and so that we can control which threads are used to execute the method.

We provide an example project where we use Observable.defer() and Observable.just() together to execute a slow method on a background thread and return the result on the Android main thread.

We describe why simply using Observable.just() on its own can’t help us solve this problem.