Building a DRYer Android App with Kotlin

Building a DRYer Android App with
Kotlin
by Boonya Kitpitak

DRY
➔ Don’t Repeat Yourself
➔ Reducing Repetition
WET
➔ Waste Everyone Time
➔ We Enjoy Typing
➔ Write Everything Twice
(or more)

Building a DRYer Android App with Kotlin
Avoid repeating yourself by using Higher
Order Function and Extension function.

Outline
➔ Higher order function
➔ Extension function
➔ Higher order function + Extension function
➔ Conclusion

Higher Order Function
“A higher-order function is a function that takes functions
as parameters, or returns a function.”

fun higherOrderFunction(block: () -> Unit) {
…
block()
…
}
Parameter Return value

Example : Suppose I want to measure the execution time of a function
val startTime = System.currentTimeMillis()
printSpeakerList()
val endTime = System.currentTimeMillis()
println("Executed in ${endTime - startTime}ms")
*https://hackernoon.com/a-practical-use-for-higher-order-functions-in-kotlin-7ff89cebf6fd

What if I want to measure the execution time of other lines of code ?
printSpeakerList()
printAudienceList()
printOrganizerList()

Make it DRY: Define a higher order function that accept function


fun printExecutionTime( block: () -> Unit ) {

}
block()

//Operation your want to measure

printExecutionTime ({
printOrganizerList()
})
Using our higher order function
printAudienceList()
})
printSpeakerList()
})
fun printExecutionTime(block: () -> Unit) {
block()
}
Higher Order Function
Lambda

Higher Order Function != Lambda
printAudienceList()
})

Setting Status bar color : Only available after Lollipop
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
window.setStatusBarColor(Color.BLACK)
}
}
window.setStatusBarColor(Color.BLACK) }
* https://www.androidauthority.com/android-m-dark-status-bar-icons-613241/

blocks of code that are only executed if the version is Lollipop or newer:
supportsLollipop ({
})
inline fun supportsLollipop(block: () -> Unit) {
block()
}
}
supportsLollipop {
}

Also work when checking Build Variant
inline fun debug(block:() -> Unit) {
if (BuildConfig.DEBUG) {
block()
}
}
debug {
// do something
}

Extension Function
“Ability to extend a class with new functionality without
having to inherit from the class or use any type of design
pattern.”

Extension function example: String to uri

val uri1 = Uri.parse(“https://stackoverflow.com”)
val uri2 = Uri.parse(“https://youtube.com”)
/**
* Creates a Uri from the given encoded URI string.
*
* @see Uri.parse
*/
fun String.toUri(): Uri = Uri.parse(this)
val uri1 = “https://stackoverflow.com”.toUri()
val uri2 = “https://youtube.com”.toUri()

Extension function example: Create toast in Fragment
Toast.makeText(context, "Hello MobileConf 2018", Toast.LENGTH_LONG).show()
Toast.makeText(context, "Hello MobileConf 2018", Toast.LENGTH_SHORT).show()
fun Fragment.longToast(text: String) {
Toast.makeText(context, text, Toast.LENGTH_LONG).show()
}
fun Fragment.shortToast(text: String) {
Toast.makeText(context, text, Toast.LENGTH_SHORT).show()
}
longToast("Hello MobileConf 2018")
shortToast( "Hello MobileConf 2018")

Extension Function + Higher Order Function
“ Let’s make it even shorter ”

Extension function example: Edit SharePreference
sharedPreferences.edit()
.putString(“event_name”, “MobileConf2018”)
.apply()
sharedPreferences.edit {
putString(“event_name”, “MobileConf2018”)
}
inline fun SharedPreferences.edit(
action: SharedPreferences.Editor.() -> Unit
) {
val editor = edit()
action(editor)
editor.apply()
}

Let’s make Retrofit network call DRYer
val call = api.getSpeakerList()
call.enqueue(object : Callback<List<Speaker>> {
override fun onResponse (call:Call<List<Speaker>>?, response:Response<List<Speaker>>?) {
response?.let {
if (response.isSuccessful) {
processSpeakerList(it)
} else {
handleError()
}
}
}
override fun onFailure(call: Call<List<Speaker>>?, t: Throwable?) {
handleError()
logErrorToFabric()
logErrorToFirebase()
}
})

inline fun <T> retrofit2.Call <T>.enqueue(crossinline successHandler : (T?) -> Unit,
crossinline failureHandler: () -> Unit) =
this.enqueue(object : Callback<T> {
override fun onResponse(call: Call<T>?, response: Response<T>?) {
response?.let {
successHandler(it.body())
} else {
failureHandler()
}
}
}
override fun onFailure(call: Call<T>?, t: Throwable?) {

failureHandler()
logErrorToFabric()
}
}
})
}
Declaring extension function

val call = api.getSpeakerList()
call.enqueue(object : Callback<List<Speaker>> {
override fun onResponse(call:Call<List<Speaker>>?, response:Response<List<Speaker>>?){
response?.let {
} else {
handleError()
}
}
}
override fun onFailure(call: Call<List<Speaker>>?, t: Throwable?) {
handleError()
logErrorToFabric()
}
})
call.enqueue({
}, {
handleError()
})

Where should we declare extension function ?
Extension function should be declare as top-level function ( function that
locate outside of the class )

Inline function ?
An inline function will be substituted by its code during compilation, instead of
doing the real call to a function. It will reduce memory allocations and runtime
overhead in some situations.
inline fun debug(block:() -> Unit) {
if (BuildConfig.DEBUG) {
block()
}
}
inline fun supportsLollipop(block: () -> Unit) {
block()
}
}

Conclusion
- Higher order function is function that accept or return function
- Extension function can add more functionality to existing class
- They both help make our code DRYer

Boonya Kitpitak (Ben)
Android Developer from Oozou
ben@oozou.com
medium.com/@boonya.kitpitak

Building a DRYer Android App with Kotlin

More Related Content

What's hot (20)

Similar to Building a DRYer Android App with Kotlin (20)

Recently uploaded (20)

Building a DRYer Android App with Kotlin