Kotlin has many amazing features but one that stands out is extensions. Extensions are used to add functionality to existing classes. They are extremely useful at helping to reduce boiler plate code. The good thing is that you can add them to any class, including the ones from third-party libraries that you can’t modify. Most of the time we see but Kotlin also supports . Extension functions Extension properties Useful Extension Functions Lets start with some extensions that make the code easier to read, the ones that improve the code quality over time by reducing boiler plate code. Context The Android API changes over time and something as simple as getting the color for a given ID can become not so simple. The extensions below helps reduce the boiler plate code associated with retrieving resources for a given ID. fun Context.getCompatColor(@ColorRes colorId: Int) = ResourcesCompat.getColor(resources, colorId, null)

fun Context.getCompatDrawable(@DrawableRes drawableId: Int) = AppCompatResources.getDrawable(this, drawableId)!! Usage // Activity
getCompatColor(R.color.white)

// Fragment
requireContext().getCompatColor(R.color.white) We all know how repeating it’s to check whether the user has granted the permissions the app requires. The extension below can help with that. It doesn’t solve the whole problem but helps reduce the code size. fun Context.hasPermissions(vararg permissions: String) = permissions.all { permission ->
    ContextCompat.checkSelfPermission(this, permission) == PackageManager.PERMISSION_GRANTED
} Usage // Traditional way (Activity)
(ContextCompat.checkSelfPermission(this, Manifest.permission.CAMERA)
   != PackageManager.PERMISSION_GRANTED) && (ContextCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION)
   != PackageManager.PERMISSION_GRANTED)

// Extension (Activity)
hasPermissions(Manifest.permission.CAMERA, Manifest.permission.ACCESS_FINE_LOCATION) Copying some text or URL to the clipboard should be something very simple. It only works with plain text but that’s what we use most of the time, if you need to support other formats you can change it. fun Context.copyToClipboard(content: String) {
    val clipboardManager = ContextCompat.getSystemService(this, ClipboardManager::class.java)!!
    val clip = ClipData.newPlainText("clipboard", content)
    clipboardManager.setPrimaryClip(clip)
} Is there an URL in your app that the user needs to open the browser to view? Are you handling the case where the browser or equivalent app might be missing? The next extension abstracts most of what’s needed. You just need to give it the Uri and do something such as showing an error if there’s no app to resolve the intent. fun Context.isResolvable(intent: Intent) = intent.resolveActivity(packageManager) != null

fun Context.view(uri: Uri, onAppMissing: () -> Unit) {
    val intent = Intent(Intent.ACTION_VIEW, uri)

    if (!isResolvable(intent)) {
        onAppMissing()
        return
    }

    startActivity(intent)
} Usage // Activity
view(uri, onAppMissing = {
    // show error message
}) Date This extension is very useful if you need to log a date object over and over or send it via an API call. Something to notice here is that the ISO format is universal, it doesn’t change from country to country, I’ll show why that’s important later. val isoFormatter = SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS")

fun Date.toISOFormat() : String = isoFormatter.format(this) Usage Date(1620862687852).toISOFormat() // 2021-05-12 23:38:07.540 Some other extensions that might be useful fun Date.plusDays(days: Int): Date {
    return Date(this.time + (days * ONE_DAY_MS))
}

fun Date.plusMillis(millis: Long): Date {
    return Date(this.time + millis)
} All that glitters is not gold Many things including extensions can be abused. Some of them look good, but are actually disguised code smells. Let’s start with a useless extension. I was reading an article about extensions the other day and found this one. fun Any?.isNull() = this == null

if (something.isNull()) { ... } There’s no code reduction by using the extension. By using the extension the compiler will consider it a normal function call and refrain from optimizing the null case if possible. That’s bad use of OOP, we add methods to objects to “ask” them about something, null by definition is the absence of an something. An object is never null, what’s is null is the reference to an object. Be careful with localization The extension below may look reasonable to most of us. It formats a Double to its decimal format. fun Any?.isNull() = this == null

if (something.isNull()) { ... } The dangerous thing about this code is that money is not formatted equally worldwide. In some countries you’ll see (comma first, dot after), in others (dot first, comma after). This is only a problem if the app is/will be used in many countries. 1,200.00 1.200,00 My solution would be to add the formatting pattern to and create an extension on to handle that. That way you can define the monetary format for each language and still use the same function. strings.xml Context fun Context.formatPrice(price: Double) : String {
    val formatter = DecimalFormat(getString(R.string.price_formatter))
    return formatter.format(price)
} Extension Properties Kotlin also allows us to add properties as extensions. I’ve not found an use case for them yet but it’s useful to know that it’s possible to use them. val <T> List<T>.lastIndex: Int
    get() = size - 1 Thank you for reading. If there’s anything you disagree with, please leave a comment below so we can discuss it and arrive at a better solution. Cover photo by on Fran Jacquier Unsplash Also published . here

This story contains new, firsthand information uncovered by the writer.

The Ultimate Jetpack Compose Cheat Sheet

How I Built a Budget Tracker with Jetpack Compose

Portfolio

Newsletter

Read My Stories

Too Long; Didn't Read

Make resilience your competitive advantage

Improve Your Code Quality With These Useful Kotlin Extensions for Android

About Author

Comments

TOPICS

THIS ARTICLE WAS FEATURED IN

Related Stories

Untitled Story

Ditch the Notification and Show an Activity on Your Android Lock Screen Instead

Java bits: 0xFF and 0xFFL

10 Things You Didn't Know You Could Do With Google Keep

10 Things to check on Android code reviews

10 Mistakes In Mobile App Development That Make You Look Dumb

Ditch the Notification and Show an Activity on Your Android Lock Screen Instead

Java bits: 0xFF and 0xFFL

10 Things You Didn't Know You Could Do With Google Keep

10 Things to check on Android code reviews

10 Mistakes In Mobile App Development That Make You Look Dumb

Light-Mode

Classic

Newspaper

Dark-Mode

Neon Noir

Minty

HN StartUps