When developing modern Android applications using Kotlin and Jetpack Compose, we often write reusable utility functions.
For example, we may need to:
- Capitalize the first letter of a String
- Validate email addresses
- Format prices
- Convert pixels to density-independent pixels
- Display a Toast message
- Format dates
- Check whether a collection is empty
- Create reusable Modifier behavior in Jetpack Compose
Traditionally, developers might create separate utility classes or helper functions for these operations.
Kotlin provides a powerful feature called extension functions that allows us to write these utilities in a more natural and readable way.
Extension functions let us call additional functions on existing types without modifying their original source code.
Kotlin also supports extension properties, which provide property-like access to computed values.
In this tutorial, we’ll explore extension functions and properties step by step with practical Kotlin and Android examples.
What You’ll Learn
By the end of this tutorial, you’ll understand:
- What extension functions are
- Why extension functions are useful
- Kotlin extension function syntax
- String extension functions
- Int and Double extensions
- Extension functions with parameters
- Extension functions with return values
- Nullable receiver extensions
- Generic extension functions
- Extension properties
- Extension functions vs member functions
- Static dispatch and extension resolution
- Scope and visibility
- Android Context extensions
- Formatting and validation utilities
- Jetpack Compose Modifier extensions
- Common mistakes and best practices
Let’s begin!
1. What Is an Extension Function in Kotlin?
An extension function allows us to define a function that can be called using the syntax of an existing class or type.
For example, Kotlin’s String class already provides many useful functions.
val message = "hello kotlin"
println(message.uppercase())
Output:
HELLO KOTLIN
But what if we want a custom function that converts the first character to uppercase?
We can create an extension function.
Example
fun String.capitalizeFirst(): String {
return replaceFirstChar {
it.uppercase()
}
}
Usage
fun main() {
val message = "hello kotlin"
println(message.capitalizeFirst())
}
Output:
Hello kotlin
Explanation
The function:
fun String.capitalizeFirst()
extends the String type with a callable function named capitalizeFirst().
We can now write:
message.capitalizeFirst()
instead of calling a separate utility function.
Important
Extension functions do not actually modify the original class.
They are resolved statically by Kotlin and do not add real member functions to the class.
2. Kotlin Extension Function Syntax
The general syntax is:
fun ReceiverType.functionName(
parameters
): ReturnType {
// Function body
}
Components
ReceiverType: The type being extended.
functionName: The extension function name.
parameters: Optional function parameters.
ReturnType: The value returned by the function.
Example
fun Int.square(): Int {
return this * this
}
Usage
fun main() {
val number = 5
println(number.square())
}
Output:
25
Explanation
The this keyword refers to the receiver object.
In this example:
this * this
multiplies the integer by itself.
3. Why Use Extension Functions?
Extension functions provide several benefits.
Benefits
- Improve code readability
- Reduce repetitive utility code
- Encourage reusable functions
- Organize related behavior
- Support cleaner APIs
- Improve Android utility development
- Work with existing classes
- Work with third-party library types
- Support generic programming
Traditional Utility Function
fun isPositive(number: Int): Boolean {
return number > 0
}
Usage:
println(isPositive(10))
Extension Function
fun Int.isPositive(): Boolean {
return this > 0
}
Usage:
println(10.isPositive())
Both approaches work.
The extension version can be more readable when the behavior naturally belongs to the receiver type.
4. Kotlin String Extension Functions
String extensions are among the most common extension functions.
Let’s create several useful examples.
Example 1: Capitalize First Character
fun String.capitalizeFirst(): String {
return replaceFirstChar {
it.uppercase()
}
}
Usage:
println("android".capitalizeFirst())
Output:
Android
Example 2: Reverse a String
fun String.reverseText(): String {
return reversed()
}
Usage:
println("Kotlin".reverseText())
Output:
niltoK
Example 3: Check Whether a String Is Long
fun String.isLongText(
minimumLength: Int = 10
): Boolean {
return length >= minimumLength
}
Usage:
println("Hello Android".isLongText())
println("Hello".isLongText())
Output:
true
false
Example 4: Remove Extra Spaces
fun String.removeExtraSpaces(): String {
return trim()
.replace(Regex("\\s+"), " ")
}
Usage:
val text = " Hello Kotlin Android "
println(text.removeExtraSpaces())
Output:
Hello Kotlin Android
Practical Android Uses
String extensions are useful for:
- Formatting usernames
- Cleaning search input
- Normalizing display text
- Formatting labels
- Reusable input transformations
5. Kotlin Extension Functions with Parameters
Extension functions can accept parameters just like regular functions.
Example
fun String.repeatText(
times: Int
): String {
return repeat(times)
}
Usage
fun main() {
val message = "Hi "
println(message.repeatText(3))
}
Output:
Hi Hi Hi
Another Example: Add a Prefix
fun String.addPrefix(
prefix: String
): String {
return prefix + this
}
Usage:
println("Android".addPrefix("Learn "))
Output:
Learn Android
Explanation
Extension functions can receive additional values through normal parameters.
The receiver remains accessible using this.
6. Kotlin Extension Functions with Return Values
Extension functions can return any Kotlin type.
Example: Calculate Discount
fun Double.applyDiscount(
percentage: Double
): Double {
return this - (this * percentage / 100)
}
Usage
fun main() {
val price = 1000.0
val finalPrice = price.applyDiscount(20.0)
println(finalPrice)
}
Output:
800.0
Practical Use
This approach can be useful for:
- Price calculations
- Unit conversions
- Formatting helpers
- Mathematical operations
- Data transformations
For financial calculations requiring exact decimal arithmetic, prefer appropriate decimal or integer-minor-unit representations rather than relying on Double.
7. Nullable Receiver Extension Functions
One of Kotlin’s powerful features is the ability to define extensions on nullable types.
Example
fun String?.orDefault(): String {
return this ?: "Not Available"
}
Usage
fun main() {
val name: String? = null
println(name.orDefault())
}
Output:
Not Available
Explanation
The receiver type is:
String?
This means the extension can be called even when the value is null.
Inside the function, this may be null.
Another Example
fun String?.isNullOrBlankText(): Boolean {
return this.isNullOrBlank()
}
Usage:
val text: String? = null
println(text.isNullOrBlankText())
Output:
true
Important
Kotlin already provides many null-safe standard library functions such as isNullOrBlank() and orEmpty().
Avoid creating custom extensions that merely duplicate existing functionality without adding meaningful value.
8. Kotlin Generic Extension Functions
Extension functions can use generic type parameters.
This allows one extension to work with multiple types.
Example
fun <T> List<T>.secondOrNull(): T? {
return getOrNull(1)
}
Usage
fun main() {
val numbers = listOf(10, 20, 30)
val names = listOf("Alex", "Emma", "John")
println(numbers.secondOrNull())
println(names.secondOrNull())
}
Output:
20
Emma
Explanation
The generic type parameter:
<T>
allows the extension to work with Lists containing different element types.
Practical Uses
Generic extensions can be useful for:
- Collection utilities
- Data transformations
- Reusable result handling
- Type-safe helpers
- Android application utilities
9. Kotlin Collection Extension Functions
We can create custom extension functions for collections.
Example 1: Find Even Numbers
fun List<Int>.evenNumbers(): List<Int> {
return filter {
it % 2 == 0
}
}
Usage:
val numbers = listOf(1, 2, 3, 4, 5, 6)
println(numbers.evenNumbers())
Output:
[2, 4, 6]
Example 2: Calculate Total Price
data class Product(
val name: String,
val price: Int
)
fun List<Product>.totalPrice(): Int {
return sumOf {
it.price
}
}
Usage:
val products = listOf(
Product("Mouse", 800),
Product("Keyboard", 2500),
Product("Cable", 300)
)
println(products.totalPrice())
Output:
3600
Example 3: Filter Expensive Products
fun List<Product>.abovePrice(
minimumPrice: Int
): List<Product> {
return filter {
it.price > minimumPrice
}
}
Usage:
val expensiveProducts = products.abovePrice(1000)
println(expensiveProducts)
Output:
[Product(name=Keyboard, price=2500)]
Why Is This Useful?
Collection extensions make reusable data processing more expressive.
However, keep extensions focused and avoid creating many narrowly useful functions that make the codebase harder to navigate.
10. What Are Extension Properties in Kotlin?
Kotlin also supports extension properties.
An extension property allows us to access a computed value using property syntax.
Syntax
val ReceiverType.propertyName: PropertyType
get() = expression
Example
val String.firstCharacter: Char?
get() = firstOrNull()
Usage
fun main() {
val name = "Kotlin"
println(name.firstCharacter)
}
Output:
K
Explanation
The extension property:
String.firstCharacter
provides a convenient way to retrieve the first character.
Unlike a regular property declared inside a class, an extension property cannot introduce a new backing field into the receiver object.
11. Kotlin Extension Properties with Computed Values
Let’s create an extension property that calculates the square of an integer.
Example
val Int.squared: Int
get() = this * this
Usage
fun main() {
val number = 8
println(number.squared)
}
Output:
64
Another Example: Is Adult
val Int.isAdult: Boolean
get() = this >= 18
Usage:
println(25.isAdult)
println(15.isAdult)
Output:
true
false
When to Use Extension Properties
Use extension properties for simple computed values that naturally read like properties.
For operations requiring parameters or substantial processing, an extension function is usually more appropriate.
12. Extension Functions vs Member Functions
Kotlin supports both member functions and extension functions.
Member Function
A member function is declared inside a class.
class User(
val name: String
) {
fun displayName(): String {
return name
}
}
Extension Function
An extension function is declared outside the class.
fun User.greeting(): String {
return "Hello, $name"
}
Usage
fun main() {
val user = User("Alex")
println(user.displayName())
println(user.greeting())
}
Output:
Alex
Hello, Alex
Comparison
| Feature | Member Function | Extension Function |
|---|---|---|
| Declared inside class | Yes | No |
| Can access public members | Yes | Yes |
| Can access private receiver members | Yes | No |
| Modifies original class API | Yes | No |
| Resolved virtually when overridable | Yes | No |
| Useful for external utilities | Sometimes | Yes |
Important Rule
If a member function and an applicable extension function have the same signature, the member function takes precedence.
13. Kotlin Extension Functions Are Statically Resolved
This is an important concept.
Extension functions are selected based on the declared type of the receiver expression, not its runtime subtype.
Example
open class Animal
class Dog : Animal()
fun Animal.describe(): String {
return "This is an animal"
}
fun Dog.describe(): String {
return "This is a dog"
}
Usage
fun main() {
val animal: Animal = Dog()
println(animal.describe())
}
Output:
This is an animal
Explanation
Although the runtime object is a Dog, the variable is declared as Animal.
Therefore, Kotlin selects:
fun Animal.describe()
This behavior is called static extension resolution.
Key Point
Extension functions do not provide runtime polymorphism.
For polymorphic behavior, use appropriate member functions, interfaces, or other object-oriented mechanisms.
14. Extension Function Scope and Visibility
Extension functions can be declared at the top level, inside classes, or within other scopes.
Top-Level Extension
fun String.toGreeting(): String {
return "Hello, $this"
}
This extension can be used wherever it is visible and imported.
Private Extension
private fun String.cleanText(): String {
return trim()
}
A private top-level extension is visible only within its file.
Internal Extension
internal fun String.normalized(): String {
return trim().lowercase()
}
An internal extension is accessible within the same Kotlin module, subject to Kotlin’s visibility rules.
Best Practice
Keep extensions near the features or modules that use them.
Avoid placing every extension function in one large utility file.
15. Practical Android Example: Context Toast Extension
In Android applications, displaying a Toast is a common task.
Traditional Approach
Toast.makeText(
context,
"Operation completed",
Toast.LENGTH_SHORT
).show()
We can simplify this using an extension function.
Create the Extension
fun Context.showToast(
message: String
) {
Toast.makeText(
this,
message,
Toast.LENGTH_SHORT
).show()
}
Required Imports
import android.content.Context
import android.widget.Toast
Usage in an Activity
showToast("Welcome to Android")
Usage in Jetpack Compose
@Composable
fun ToastDemoScreen() {
val context = LocalContext.current
Button(
onClick = {
context.showToast("Button clicked")
}
) {
Text("Show Toast")
}
}
Required Compose Imports
import androidx.compose.material3.Button
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.ui.platform.LocalContext
Why Is This Useful?
Instead of repeating the complete Toast implementation, we can call:
context.showToast("Hello")
This makes common Android operations more concise.
Important
Toast operations should run on the appropriate UI thread.
For modern in-app feedback, consider Material 3 Snackbar when the message needs to be associated with a screen or offer an action.
16. Practical Android Example: Email Validation Extension
Email validation is common in registration and profile forms.
Let’s create a simple Android-specific extension.
Extension Function
fun String.isValidEmail(): Boolean {
return android.util.Patterns.EMAIL_ADDRESS
.matcher(this)
.matches()
}
Usage
val email = "alex@example.com"
println(email.isValidEmail())
Output:
true
Another Example
val invalidEmail = "alexexample.com"
println(invalidEmail.isValidEmail())
Output:
false
Important
This example uses the Android Patterns API and should be executed in an Android environment.
It is a basic format check, not proof that an email address exists or belongs to a user.
Production applications should also validate data on the server when applicable.
17. Practical Android Example: Density Conversion Extensions
Android uses density-independent pixels (dp) for layout measurements.
Sometimes we need to convert between pixels and dp.
Convert dp to Pixels
fun Float.dpToPx(
density: Float
): Float {
return this * density
}
Convert Pixels to dp
fun Float.pxToDp(
density: Float
): Float {
return this / density
}
Usage
val density = 3f
val pixels = 16f.dpToPx(density)
val dp = pixels.pxToDp(density)
println(pixels)
println(dp)
Output:
48.0
16.0
Practical Note
In Jetpack Compose, use the framework’s built-in density APIs where appropriate.
For example:
val density = LocalDensity.current
val pixels = with(density) {
16.dp.toPx()
}
Prefer built-in APIs when they already solve the problem clearly.
18. Practical Android Example: Date Formatting Extension
Let’s create an extension function that formats a timestamp.
Example
fun Long.toReadableDate(): String {
val formatter = java.text.SimpleDateFormat(
"dd MMM yyyy",
java.util.Locale.getDefault()
)
return formatter.format(
java.util.Date(this)
)
}
Usage
val timestamp = System.currentTimeMillis()
println(timestamp.toReadableDate())
Explanation
The extension converts a Unix timestamp in milliseconds into a readable date.
Important
The output depends on the current date, locale, and timezone.
For modern Android projects, consider using the java.time APIs when supported by the project’s Android API configuration and desugaring setup.
Avoid sharing mutable SimpleDateFormat instances across threads.
19. Jetpack Compose Modifier Extension Functions
Jetpack Compose provides a powerful Modifier system for customizing UI components.
We can create extension functions on Modifier to define reusable UI styling.
Example
fun Modifier.cardSpacing(): Modifier {
return this.padding(12.dp)
}
Usage
@Composable
fun ProductCard() {
Card(
modifier = Modifier
.fillMaxWidth()
.cardSpacing()
) {
Text(
text = "Android Product",
modifier = Modifier.padding(16.dp)
)
}
}
Explanation
The extension:
Modifier.cardSpacing()
adds reusable padding behavior.
Why Is This Useful?
Modifier extensions can help maintain consistent UI styling across an application.
For example:
- Common spacing
- Reusable borders
- Background styling
- Touch target adjustments
- Custom drawing effects
Best Practice
Keep Modifier extensions predictable.
Prefer standard Modifier functions for simple one-off styling.
Create custom extensions when the behavior is repeated and has a clear meaning.
20. Jetpack Compose Mini-Project: Reusable Profile Utilities
Let’s build a small Jetpack Compose profile screen using Kotlin extension functions and properties.
Our screen will demonstrate:
- String formatting extension
- Email validation extension
- Extension property
- Reusable Modifier extension
- Toast extension
- Compose state handling
Step 1: Create String Extensions
fun String.displayName(): String {
return trim().replaceFirstChar {
it.uppercase()
}
}
val String.hasContent: Boolean
get() = isNotBlank()
Step 2: Create Email Validation Extension
fun String.isValidEmail(): Boolean {
return android.util.Patterns.EMAIL_ADDRESS
.matcher(this)
.matches()
}
Step 3: Create Context Toast Extension
fun Context.showToast(
message: String
) {
Toast.makeText(
this,
message,
Toast.LENGTH_SHORT
).show()
}
Step 4: Create Modifier Extension
fun Modifier.formSpacing(): Modifier {
return this.padding(vertical = 8.dp)
}
Step 5: Create the Profile Screen
@Composable
fun ProfileExtensionDemoScreen() {
val context = LocalContext.current
var name by rememberSaveable {
mutableStateOf("")
}
var email by rememberSaveable {
mutableStateOf("")
}
Column(
modifier = Modifier
.fillMaxSize()
.padding(24.dp),
verticalArrangement = Arrangement.spacedBy(12.dp)
) {
Text(
text = "Kotlin Extensions Demo",
style = MaterialTheme.typography.headlineMedium
)
OutlinedTextField(
value = name,
onValueChange = {
name = it
},
label = {
Text("Enter Name")
},
modifier = Modifier
.fillMaxWidth()
.formSpacing(),
singleLine = true
)
OutlinedTextField(
value = email,
onValueChange = {
email = it
},
label = {
Text("Enter Email")
},
modifier = Modifier
.fillMaxWidth()
.formSpacing(),
singleLine = true
)
Button(
onClick = {
when {
!name.hasContent -> {
context.showToast(
"Please enter your name"
)
}
!email.isValidEmail() -> {
context.showToast(
"Enter a valid email"
)
}
else -> {
context.showToast(
"Profile saved successfully"
)
}
}
},
modifier = Modifier.fillMaxWidth()
) {
Text("Save Profile")
}
if (name.hasContent) {
Text(
text = "Hello, ${name.displayName()}!",
style = MaterialTheme.typography.titleMedium
)
}
}
}
Required Imports
import android.content.Context
import android.widget.Toast
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.padding
import androidx.compose.material3.Button
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.OutlinedTextField
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.saveable.rememberSaveable
import androidx.compose.runtime.setValue
import androidx.compose.ui.Modifier
import androidx.compose.ui.platform.LocalContext
import androidx.compose.ui.unit.dp
Expected UI
+--------------------------------+
| |
| Kotlin Extensions Demo |
| |
| +----------------------------+ |
| | Enter Name | |
| +----------------------------+ |
| |
| +----------------------------+ |
| | Enter Email | |
| +----------------------------+ |
| |
| +----------------------------+ |
| | Save Profile | |
| +----------------------------+ |
| |
| Hello, Alex! |
| |
+--------------------------------+
How It Works
The screen uses several extensions.
Name formatting:
name.displayName()
Check for non-blank input:
name.hasContent
Email validation:
email.isValidEmail()
Toast message:
context.showToast("Profile saved")
Reusable UI spacing:
Modifier.formSpacing()
These extensions make the code easier to read and reduce repeated implementation details.
Production Note
This demo validates input and displays a success message but does not persist profile information.
A real application could use ViewModel, StateFlow, Room, DataStore, or a backend API to manage and save profile data.
21. Extension Functions vs Utility Objects
Sometimes developers use utility objects to organize helper functions.
Utility Object
object StringUtils {
fun capitalizeFirst(
value: String
): String {
return value.replaceFirstChar {
it.uppercase()
}
}
}
Usage
val result = StringUtils.capitalizeFirst("android")
Extension Function
fun String.capitalizeFirst(): String {
return replaceFirstChar {
it.uppercase()
}
}
Usage
val result = "android".capitalizeFirst()
Which Approach Is Better?
Extension functions are often preferable when the operation naturally applies to the receiver type.
Utility objects may be more appropriate when functions do not have a meaningful receiver or when grouping behavior under a named API improves clarity.
Choose the approach that makes the code easier to understand.
22. Common Kotlin Extension Function Mistakes
Mistake 1: Assuming Extensions Modify Classes
Extension functions do not add actual members to existing classes.
They provide additional callable functions resolved by Kotlin.
Mistake 2: Assuming Extensions Can Access Private Members
An extension cannot access private members of its receiver class merely because it uses receiver syntax.
Mistake 3: Confusing Static and Dynamic Dispatch
Extension functions are resolved statically based on the receiver’s declared type.
They do not behave like overridden member functions.
Mistake 4: Creating Too Many Extensions
Avoid turning every small operation into an extension function.
Use extensions when they provide clear readability or reuse benefits.
Mistake 5: Using Extension Properties for Expensive Operations
An extension property may look like a simple field access.
Avoid hiding expensive processing behind property syntax.
Prefer a function for operations with significant cost or side effects.
Mistake 6: Duplicating Kotlin Standard Library Functions
Before creating an extension, check whether Kotlin already provides the required functionality.
For example:
text.orEmpty()
and:
text.isNullOrBlank()
already exist.
Mistake 7: Creating Ambiguous Extension Names
Avoid generic extension names that conflict with existing APIs or extensions from other libraries.
Choose descriptive names and organize imports carefully.
23. Kotlin Extension Functions Best Practices
Follow these recommendations:
- Use extensions for meaningful reusable behavior.
- Keep extension functions focused and predictable.
- Prefer pure functions when possible.
- Avoid unnecessary side effects.
- Use nullable receiver extensions when they simplify null handling.
- Use generic extensions for truly reusable operations.
- Prefer existing Kotlin and Android APIs when available.
- Keep Android-specific extensions in Android modules.
- Avoid placing unrelated extensions in a single large file.
- Use clear names to prevent ambiguity.
- Avoid hiding expensive work behind extension properties.
- Write unit tests for important extension utilities.
- Document non-obvious behavior.
These practices help maintain a clean Kotlin codebase.
24. Kotlin Extensions Quick Reference
| Concept | Example |
|---|---|
| String extension | fun String.clean() = trim() |
| Int extension | fun Int.square() = this * this |
| Extension with parameter | fun Int.add(x: Int) = this + x |
| Nullable receiver | fun String?.safe() = this.orEmpty() |
| Generic extension | fun <T> List<T>.secondOrNull() = getOrNull(1) |
| Extension property | val String.isLong get() = length > 10 |
| Context extension | fun Context.showToast(...) |
| Modifier extension | fun Modifier.cardSpacing() |
| Static resolution | Based on declared receiver type |
| Member precedence | Applicable member wins over extension |
25. Practical Exercises
Try these exercises to improve your Kotlin extension function skills.
Exercise 1: String Extension
Create an extension function that converts a String to title case.
Exercise 2: Integer Extension
Create an extension function that checks whether an integer is odd.
Exercise 3: Discount Extension
Create an extension function for Double that calculates a discounted price.
Exercise 4: Nullable Extension
Create a nullable String extension that returns "Unknown" when the receiver is null or blank.
Exercise 5: Generic List Extension
Create a generic extension that returns the third element of a List or null.
Exercise 6: Extension Property
Create an extension property for Int that checks whether a number is negative.
Exercise 7: Android Toast Extension
Create a Context extension to display a Toast message.
Exercise 8: Jetpack Compose Modifier Extension
Create a Modifier extension that applies common padding and a rounded background.
Exercise 9: Profile Screen
Build a Jetpack Compose screen that uses:
- String extensions
- Email validation
- Extension properties
- Modifier extensions
- Toast extensions
- rememberSaveable
What We’ve Learned
In this tutorial, we learned:
- Kotlin extension functions
- Extension function syntax
- String extensions
- Numeric extensions
- Functions with parameters
- Functions with return values
- Nullable receiver extensions
- Generic extension functions
- Collection extensions
- Extension properties
- Computed properties
- Member functions vs extensions
- Static extension resolution
- Extension scope and visibility
- Android Context extensions
- Email validation utilities
- Density conversion
- Date formatting
- Jetpack Compose Modifier extensions
- Reusable Compose profile screen
- Common mistakes and best practices
Extension functions and properties are powerful Kotlin features that improve code readability and reusability.
They are especially valuable in modern Android development, where developers frequently create reusable utilities for UI components, data transformations, formatting, and application logic.
Understanding these concepts will help you write cleaner Kotlin code and build more maintainable Android applications.
What’s Next?
In our next tutorial, we’ll explore:
Kotlin Scope Functions Explained: let, run, with, apply & also
You’ll learn:
- What scope functions are
- Kotlin let()
- Kotlin run()
- Kotlin with()
- Kotlin apply()
- Kotlin also()
- this vs it
- Return values
- Null-safe scope function usage
- Practical Android examples
- Jetpack Compose use cases
- Common mistakes and best practices
Happy Coding!
Continue learning modern Android development with Moiks Developer Blog.