Log.v(“ThreeTips”, “#17”)

Kotlin is new trend and I see everyone is switching to Kotlin language in Android Development. So In my next tips, I will use more Kotlin.

1 — Operator Overloading in Kotlin

Kotlin allows us to provide implementations for a predefined set of operators on our types. These operators have symbolic representation like *,-,+ etc. Lets examine it with a little snippet.

If you use RxJava in your android project, you need to create a and add every that you created to the CompositeDisposable. Without operator overloading, we do it like the following;

val disposables = CompositeDisposable()
val observable1 = your_observable
disposables.add(observable1)

You can define plus operator for adding new disposable to composite disposable.

operator fun CompositeDisposable.plusAssign(disposable: Disposable){
add(disposable)
}

It will simply call this extension function when you use “+” operator to add disposable to composite disposable. So you can use it just like following.

disposables += observable1

2 — Using font in Support Library (As of 26.0.0)

As of Android Support Library 26.0, you must declare both sets of attributes to ensure your fonts load on devices running Android 8.0 (API level 26) or lower. Otherwise your app crashes with following error.

Caused by: java.lang.NullPointerException
at android.graphics.FontFamily.nAddFontFromAssetManager

Solution, declare both sets of attributes, and in your fontStyle.

<font
android:font="@font/product_sans_regular"
android:fontStyle="normal"
android:fontWeight="400"

app:font="@font/product_sans_regular"
app:fontStyle="normal"
app:fontWeight="400" />

3 — Gradle 3.0: “api” vs “implementations”

If you upgraded your gradle plugin to 3.0, you might have seen “compile” is deprecated. You can also see that some documentations are already updated with

//before gradle 3.0
compile
“android.arch.lifecycle:runtime:1.0.3”
//After gradle 3.0
implementation
“android.arch.lifecycle:runtime:1.0.3”

So what is and what is ? Should I use key instead of ?

No. Actually the key explain itself. If you want to provide your dependency as an API then you should use . If you want to use the dependency as an implementation on your current module, then you should use “implementation”. When you use “implementation” instead of “compile”, you won’t be able to use those classes which belongs to the library in you sub modules.

Basically you can use “api” instead of “compile”.

But if you want faster build time in your app, you can do following.

A module →B module → C module → App Module

If “A module” is only needed in your “B module”, you can use in your “B module”. If you change your code in “A module”, “C” and “App” module won’t be recompiled again. So your build will be faster.

Bedanta has a great blogpost about this. Check it out from here.

Software Engineer at Storytel

Get the Medium app

A button that says 'Download on the App Store', and if clicked it will lead you to the iOS App store
A button that says 'Get it on, Google Play', and if clicked it will lead you to the Google Play store