When developing an Android app, particularly when working with databases, you may often face a common question:

“Which date and time format should I use?”

As a junior developer, I struggled with this decision. A quick Google search led me to a discussion on StackOverflow from eight years ago: “How to properly store date and time in SQLite?”. The insights were interesting, but I still sought clarity.

So, I turned to ChatGPT and asked:

“As a senior Android developer, how do you save your date-time data format in Android?”

Here’s what I learned from the responses and best practices followed by seasoned developers:

Commonly Used Date and Time Formats

1. Timestamps (Milliseconds or Seconds)

A timestamp is a numeric representation of the date and time, often the number of milliseconds or seconds since the Unix epoch (1970-01-01T00:00:00Z). In Android, this is commonly stored as a Long value.

Example in Kotlin:

val millis: Long = 1732986000000 // Represents a specific date and time
// Or get the current timestamp
val millis = System.currentTimeMillis()

Pros:

• Efficient for computations: Easy to sort, compare, and perform date calculations.
• Compact: Takes up less space compared to strings.
• Time zone neutral: Always represents the same moment in time, regardless of location.

Cons:

• Not human-readable: Debugging timestamps can be challenging without converting them to a readable format.

2. ISO 8601 Strings

ISO 8601 is a standardized, human-readable string format for dates and times, such as yyyy-MM-dd'T'HH:mm:ss'Z'. This is widely used in APIs and cross-platform systems.

Example in Kotlin:

val isoDateString = Instant.now().toString() // Outputs "2024-12-21T14:30:00Z"

Pros:

• Readable and intuitive: Easier for humans to understand at a glance.
• Interoperable: Commonly used in backend APIs and across different systems.

Cons:

• Less efficient for operations: Sorting and calculations are more complex compared to timestamps.
• Larger storage size: Strings take more space than a numeric representation.

Additional Best Practices: Handling Time Zones

When working with date and time data, handling time zones properly is crucial. Here’s how senior developers address this:

1. Always Use UTC for Storage

Save your dates and times in Coordinated Universal Time (UTC) to avoid inconsistencies caused by time zone differences.

Example in Kotlin:

val utcTime = ZonedDateTime.now(ZoneOffset.UTC).toInstant()

2. Convert to Local Time for Display

When presenting date and time to the user, convert UTC to the user’s local time zone. This ensures the displayed time is relevant to the user.

Example in Kotlin:

val localTime = Instant.ofEpochMilli(timestamp)
    .atZone(ZoneId.systemDefault())
    .toLocalDateTime()

How to Choose the Right Format

Here’s a simple guide to help you decide:

Use Timestamps if:

• You’re working with databases (e.g., Room or SQLite) and need efficient sorting or filtering.
• Space efficiency is a concern.

Use ISO 8601 Strings if:

• The format needs to be human-readable (e.g., for APIs or logs).
• The data will be shared across systems with varying implementations.

For most Android apps, using timestamps for storage and converting them to ISO 8601 strings or localized formats for display strikes a good balance.

Wrapping Up

Choosing the right date and time format depends on your app’s specific needs. By understanding the trade-offs between timestamps and ISO 8601 strings, as well as the importance of handling time zones correctly, you can design a robust and scalable app.

I hope this article helps you make informed decisions about date and time storage in your Android projects. Let me know your thoughts in the comments!

Thank you for being a part of the community

Before you go:

• Be sure to clap and follow the writer ️👏️️
• Follow us: X | LinkedIn | YouTube | Newsletter | Podcast
• Check out CoFeed, the smart way to stay up-to-date with the latest in tech 🧪
• Start your own free AI-powered blog on Differ 🚀
• Join our content creators community on Discord 🧑🏻‍💻
• For more content, visit plainenglish.io + stackademic.com

Choosing the Right Date and Time Format in Android Development was originally published in Stackademic on Medium, where people are continuing the conversation by highlighting and responding to this story.

In this tutorial, I’ll guide you through creating a visually appealing and functional Expandable Card using Jetpack Compose. This design is perfect for scenarios where you want to group content and allow users to expand or collapse it for better visibility and interaction. Let’s dive in!

What You’ll Build

We’ll create a reusable DailyCashFlowCardItem component that displays a date, total income, and total expenses, along with an expandable list of categorized cash flows. The card allows users to toggle the visibility of its content and supports actions like editing or deleting individual items.

Here’s how the final design will look:

• Collapsed: Only the date and summary are visible.
• Expanded: Displays detailed cash flow entries.

Key Features

1. Expand and collapse animations.
2. Reusable and easy to customize.

Step 1: Setting Up the Card Component

The main component, DailyCashFlowCardItem, uses a Card with a Column to structure the content. We toggle the visibility of its detailed content using an AnimatedVisibility wrapper.

@Composable
fun DailyCashFlowCardItem(
    modifier: Modifier = Modifier,
    date: String,
    totalExpenses: Double = 0.0,
    totalIncome: Double = 0.0,
    cashFlowList: List<CashFlowAndCategory>,
    onDeleteCashFlow: (CashFlow) -> Unit,
    navigateToEditCashFlowScreen: (Int) -> Unit
) {
    // State to hold the visibility of the content inside the card
    // to show wether its expanded or collapsed
    var itemRowVisible by remember { mutableStateOf(true) }
    
    Card(
        modifier = modifier.fillMaxWidth(),
        colors = CardDefaults.cardColors(containerColor = MaterialTheme.colorScheme.surfaceContainer),
        elevation = CardDefaults.elevatedCardElevation(defaultElevation = 2.dp)
    ) {
        Column {
            DailyCashFlowHeader(
                totalExpenses = totalExpenses,
                totalIncome = totalIncome,
                date = date,
                onClick = { itemRowVisible = !itemRowVisible }
            )
            AnimatedVisibility(visible = itemRowVisible) {
                HorizontalDivider()
            }
           // Toggles visibility based on the itemRowVisible state.
          // When itemRowVisible is true, the content is displayed; when false, it's hidden.
            AnimatedVisibility(
                visible = itemRowVisible,
                enter = expandVertically(animationSpec = tween(300)) + fadeIn(
                    animationSpec = tween(300)
                ), // Provides a smooth vertical expansion coupled with a gradual fade-in effect for enhanced visual appeal.
                exit = shrinkVertically(animationSpec = tween(300)) + fadeOut(
                    animationSpec = tween(300) // Combines a smooth vertical shrink with a fade-out effect, creating a polished transition during the collapse of the expanded view.
                )
            ) {
                Column {
                    cashFlowList.forEachIndexed { index, cashFlowAndCategory ->
                        SwipeableItemWithActions(
                            isRevealed = cashFlowAndCategory.isOptionsRevealed,
                            actions = {
                                ActionIcon(
                                    icon = Icons.Default.Delete,
                                    tint = MaterialTheme.colorScheme.error,
                                    onClick = { onDeleteCashFlow(cashFlowAndCategory.cashFlow) }
                                )
                            },
                            onExpanded = {
                                cashFlowAndCategory.isOptionsRevealed = true
                            },
                            onCollapsed = {
                                cashFlowAndCategory.isOptionsRevealed = false
                            }
                        ) {
                            DailyCashFlowItemRow(
                                cashFlow = cashFlowAndCategory,
                                emoji = cashFlowAndCategory.category.emoji
                            )
                        }
                        if (index != cashFlowList.lastIndex) {
                            HorizontalDivider()
                        }
                    }
                }
            }
        }
    }
}

Step 2: Creating the Header

The header displays the date, total income, and total expenses. Tapping the header toggles the expanded/collapsed state.

@Composable
fun DailyCashFlowHeader(
    modifier: Modifier = Modifier,
    totalExpenses: Double,
    totalIncome: Double,
    date: String,
    onClick: () -> Unit = {},
) {
    Column(modifier.clickable { onClick() }) {
        Row(
            modifier = Modifier
                .fillMaxWidth()
                .padding(12.dp)
        ) {
            Text(
                text = date,
                style = MaterialTheme.typography.labelLarge,
                color = MaterialTheme.colorScheme.outline
            )
            Spacer(modifier = Modifier.weight(1f))
            Text(
                text = totalIncome.formatToRupiah(),
                style = MaterialTheme.typography.titleSmall,
                color = MaterialTheme.colorScheme.tertiaryContainer
            )
            Spacer(modifier = Modifier.width(6.dp))
            Text(
                text = totalExpenses.formatToRupiah(),
                style = MaterialTheme.typography.titleSmall,
                color = MaterialTheme.colorScheme.error
            )
        }
    }
}

Step 3: Adding List Items

The list items represent individual cash flow entries, including an emoji, category name, amount, and an optional note.

@Composable
fun DailyCashFlowItemRow(
    modifier: Modifier = Modifier,
    cashFlow: CashFlowAndCategoryDomain,
    emoji: String
) {
    Row(
        modifier = modifier
            .padding(12.dp)
            .fillMaxWidth(),
        verticalAlignment = Alignment.CenterVertically
    ) {
        Box(
            modifier = Modifier
                .size(32.dp)
                .clip(RoundedCornerShape(4.dp))
                .background(MaterialTheme.colorScheme.tertiaryContainer)
        ) {
            Text(text = emoji, modifier = Modifier.align(Alignment.Center))
        }
        Spacer(modifier = Modifier.width(8.dp))
        Column(modifier = Modifier.weight(1f)) {
            Text(text = cashFlow.category.name, style = MaterialTheme.typography.titleMedium)
            if (cashFlow.cashFlow.note.isNotEmpty()) Text(
                text = cashFlow.cashFlow.note,
                color = MaterialTheme.colorScheme.outlineVariant,
                maxLines = 1,
                overflow = TextOverflow.Ellipsis,
                fontSize = 12.sp
            )
        }
        Text(
            text = cashFlow.cashFlow.amount.formatToRupiah(),
            style = MaterialTheme.typography.titleSmall,
            color = if (cashFlow.cashFlow.categoryId != 1) MaterialTheme.colorScheme.error else MaterialTheme.colorScheme.tertiaryContainer
        )
    }
}

Step 4: Adding Swipeable Actions

You can add your own swipeable actions like deleting or editing items. This is achieved using a reusable SwipeableItemWithActions custom component.

Conclusion

In this tutorial, you learned how to build a polished expandable card in Jetpack Compose, complete with animations. This reusable component can enhance any app’s user experience by neatly organizing information.

Feel free to explore, modify, and share your version of this card design. Happy coding!

Stackademic 🎓

Thank you for reading until the end. Before you go:

• Please consider clapping and following the writer! 👏
• Follow us X | LinkedIn | YouTube | Discord | Newsletter | Podcast
• Create a free AI-powered blog on Differ.
• More content at Stackademic.com
• Have a story to share? Join our global community of writers today!

Create an Expandable Card in Jetpack Compose was originally published in Stackademic on Medium, where people are continuing the conversation by highlighting and responding to this story.

Hey everyone! Today, I would like to share a step-by-step tutorial on how to add Lottie animations to an Android app using Jetpack Compose. Let’s dive in!

What is Lottie Animation?

Lottie is a JSON-based animation file format originally developed by Airbnb. It’s cross-platform, lightweight, and scalable, making it a perfect choice for high-quality animations on mobile apps without increasing app size significantly.

Goal

Our end goal is to create an app where users can enter a voucher code. If the code matches the correct one, a confetti animation will play; otherwise, nothing happens. Here’s what it’ll look like:

1. Set Up Your Project

Start by adding the Lottie library to your build.gradle file at the app module level:

dependencies {

    // other dependencies

    // Lottie
    implementation(libs.lottie.compose)
}

If you’re using Gradle version catalog, don’t forget to define the library name and version in libs.version.toml:

[versions]
lottieCompose = "6.6.0"

[libraries]
lottie-compose = { module = "com.airbnb.android:lottie-compose", version.ref = "lottieCompose" }

Next, find a confetti animation on LottieFiles and download it. After downloading, create a “raw” folder under res in your project directory, and save the file there with a simple name like confetti.json.

2. Creating the Animation App Composable

Now, open MainActivity.kt and create a new composable function called ConfettiAnimationApp:

@Composable
fun ConfettiAnimationApp(modifier: Modifier = Modifier) {

    val voucher = "VOUCHER2024"
    var isPlaying by remember { mutableStateOf(false) }
    var isError by remember { mutableStateOf(false) }

    Box(modifier) {
        AnimatedVisibility(visible = isPlaying) {
            ConfettiAnimation(
                modifier = Modifier
                    .fillMaxWidth()
                    .align(Alignment.TopCenter),
                isPlaying = isPlaying
            )
        }
        VoucherForm(
            modifier = Modifier
                .align(Alignment.Center)
                .padding(horizontal = 16.dp),
            onApply = { text ->
                isError = text != voucher
                if (text.isNotEmpty() && text == voucher) {
                    CoroutineScope(Dispatchers.Main).launch {
                        isPlaying = true
                        delay(3000L)
                        isPlaying = false
                    }
                }
            },
            isError = isError
        )
    }
}

Explanation:

• ConfettiAnimationApp sets up the UI with a voucher input form and a confetti animation that plays when the form input matches the correct code.
• AnimatedVisibility helps control whether the ConfettiAnimation is visible or hidden based on the isPlaying variable.
• Finally, we set up VoucherForm to handle user input and validation.

3. Displaying the Lottie Animation

This function is the core of the animation. It’s where we load and play the Lottie file.

@Composable
fun ConfettiAnimation(modifier: Modifier = Modifier, isPlaying: Boolean = false) {
    val composition by rememberLottieComposition(spec = LottieCompositionSpec.RawRes(R.raw.confetti))

    LottieAnimation(
        composition = composition,
        modifier = modifier,
        isPlaying = isPlaying,
    )
}

Explanation:

• The composition variable stores the result of rememberLottieComposition, which loads the animation from R.raw.confetti.
• We then call LottieAnimation, passing in composition and isPlaying to control when the animation starts or stops.

4. Building the Voucher Input Form

The voucher input form handles the text input and checks if the voucher is correct.

@Composable
fun VoucherForm(modifier: Modifier = Modifier, onApply: (value: String) -> Unit = {}, isError: Boolean = false) {

    var text by remember { mutableStateOf(TextFieldValue("")) }

    Row(
        modifier.fillMaxWidth(),
        horizontalArrangement = Arrangement.SpaceBetween,
        verticalAlignment = Alignment.CenterVertically
    ) {
        OutlinedTextField(
            value = text,
            onValueChange = { value -> text = value },
            modifier = Modifier.weight(1f),
            placeholder = {
                Text(text = "Input Voucher")
            },
            isError = isError,
            )
        Spacer(modifier = Modifier.width(8.dp))
        Button(onClick = {
            onApply(text.text)
        }) {
            Text(text = "Apply")
        }
    }
}

Explanation:

• TextFieldValue manages form input.
• isError is set to true when the voucher code doesn’t match.
• A Button with onApply triggers the animation if the voucher is correct.

5. Adding Coroutine and Animation Control Logic

To keep the animation running for only 3 seconds, we use a coroutine to handle timing.

 onApply = { text ->
                isError = text != voucher
                if (text.isNotEmpty() && text == voucher) {
                    CoroutineScope(Dispatchers.Main).launch {
                        isPlaying = true
                        delay(3000L)
                        isPlaying = false
                    }
                }
            },

Using a coroutine here lets us set isPlaying to true for 3 seconds, then automatically set it to false. This gives a smooth transition for showing and hiding the animation.

Conclusion

And there you have it! With just a few lines of code, you’ve integrated a fun, responsive animation into your Jetpack Compose app. This approach can make any app feel more interactive and engaging without a lot of extra overhead. Try experimenting with different animations from LottieFiles or triggering animations based on other user actions for even more interactivity. Happy coding!

Explore:
What is a Lottie animation? — LottieFiles

Stackademic 🎓

Thank you for reading until the end. Before you go:

• Please consider clapping and following the writer! 👏
• Follow us X | LinkedIn | YouTube | Discord | Newsletter | Podcast
• Create a free AI-powered blog on Differ.
• More content at Stackademic.com

How to Add Lottie Animation in Jetpack Compose was originally published in Stackademic on Medium, where people are continuing the conversation by highlighting and responding to this story.

As developers, we need to focus on writing high-quality, efficient code — code that runs faster and makes good use of memory. Today, I want to share some insights into a small but impactful choice: why you should use StringBuilder instead of String for certain types of string manipulation.

Immutable vs Mutable Objects

Let’s start with the basics. In Kotlin (and many other languages), the String class is immutable. That means once a String object is created, its value can’t be changed. Now, while immutability is useful for various reasons (like thread safety), it’s not always efficient when you need to modify a string repeatedly. That’s where StringBuilder comes in—a powerful class in Kotlin and Java that’s designed for mutable string manipulation. Using StringBuilder, you can modify strings without creating a new object each time, which can be a big performance booster.

Comparing String vs StringBuilder: Memory and Performance

To illustrate the difference between String and StringBuilder, let’s look at a quick performance test on memory and speed. Now, of course, the results here are specific to our test case; if you’re only doing light string manipulation, you may not need to worry about the difference between String and StringBuilder. But for heavy-duty string operations, the impact can be significant.

First, let’s create a function that concatenates a string 100.000 times using a String.

@Test
fun measureBuildStringWithString() {
    println(buildStringWithString(loopCount))
}

private fun buildStringWithString(count: Int): String {
    var result = ""
    for (i in 1..count) {
        result += "$i, "
    }
    return result
}

I ran this function in Android Studio and measured the execution time and memory usage. Took 4 sec 545 ms to finish the loop.

Next, let’s try the same operation using StringBuilder:

@Test
fun measureBuildStringWithStringBuilder() {
    println(buildStringWithStringBuilder(loopCount))
}

private fun buildStringWithStringBuilder(count: Int): String {
    val result = StringBuilder()
    for (i in 1..count) {
        result.append(i).append(",")
    }
    return result.toString()
}

The results with StringBuilder show a considerable difference. Finish in just about 67 ms.

To make it clear, I also created functions that measure the time and memory used by both methods so you can see the exact performance gains.

private fun measurePerformance(method: Runnable) {
    val runtime = Runtime.getRuntime()
    runtime.gc()

    val memoryBefore = runtime.totalMemory() - runtime.freeMemory()
    val startTime = System.nanoTime()

    method.run()

    val endTime = System.nanoTime()
    val memoryAfter = runtime.totalMemory() - runtime.freeMemory()

    val memoryUsed = memoryAfter - memoryBefore
    val timeTaken = endTime - startTime

    println("Execution time (ms): " + timeTaken / 1000000)
    println("Memory used (bytes: $memoryUsed")
}

And here is the result:

When and Why to Use StringBuilder

So, when should you use StringBuilder? Here are some practical scenarios where it makes a noticeable difference:

• Constructing long strings in loops: If you’re building up a long string inside a loop, StringBuilder is more efficient.
• Dynamic concatenation: When you’re not sure how many concatenations will be needed, StringBuilder handles these repeated operations better.
• Working with large data: For file operations, logging, or handling large data, StringBuilder minimizes memory usage and improves performance.

Conclusion

In summary, using StringBuilder over String for repeated string manipulation can save a lot on both memory and execution time. String is perfectly fine for single or light concatenations, but once you’re dealing with multiple or complex concatenations, especially in loops, StringBuilder becomes the smarter choice. It’s a small tweak but can have a big impact on your app’s efficiency!

Source:

String — Kotlin Programming Language

StringBuilder — Kotlin Programming Language

performance — StringBuilder vs String concatenation in toString() in Java — Stack Overflow

In this article, I would like to share how to build image slider with custom indicator in Jetpack Compose. It’s very simple and we don’t need external libraries to implement it.

Here is the final result:

1. Create Jetpack Compose project.
2. Create composable function ImagePager .

@Composable
fun ImagePager(
    modifier: Modifier = Modifier,
    pagerState: PagerState,
    navigateBack: () -> Unit = {},
) {

    val images = /* List of images */

    Column(modifier) {
        Box(modifier = Modifier) {
            HorizontalPager(state = pagerState) { page ->
                Image(
                    painter = painterResource(id = images[page]),
                    contentDescription = "Image"
                )
            }
            Indicator(
                dotCount = pagerState.pageCount,
                currentPage = pagerState.currentPage,
                dotSpacing = 4.dp,
                modifier = Modifier
                    .align(Alignment.BottomCenter)
                    .padding(bottom = 8.dp)
                    .height(12.dp)
            )
            IconButton(
                onClick = navigateBack, modifier = Modifier
                    .align(Alignment.TopStart)
                    .padding(8.dp)
            ) {
                Icon(
                    imageVector = Icons.AutoMirrored.Filled.ArrowBack,
                    contentDescription = stringResource(
                        id = R.string.back
                    ),
                    tint = DarkNavy
                )
            }
        }

    }
}

3. Then, we also need to create the Indicator composable function. We can modify the number of the dots, space between the dots, and also the size of the dots.

@Composable
fun Indicator(
    dotCount: Int,
    currentPage: Int,
    modifier: Modifier = Modifier,
    dotSpacing: Dp = 8.dp,
    dotSize: Dp = 10.dp,
) {
    Row(
        horizontalArrangement = Arrangement.spacedBy(dotSpacing),
        verticalAlignment = Alignment.CenterVertically,
        modifier = modifier
    ) {
        for (i in 0 until dotCount) {
            val isActive = currentPage == i
            val color by animateColorAsState(targetValue =  if (isActive) Purple else DotIndicatorDefault,
                label = ""
            )
            val width by animateDpAsState(targetValue = if (isActive) dotSize * 3 else dotSize,
                label = ""
            )
            Box(
                modifier = Modifier
                    .width(width)
                    .height(dotSize)
                    .clip(CircleShape)
                    .background(color)
            )
        }
    }
}

You can start to interact with the ImagePager result by call it inside the Preview annotation function.

@Preview
@Composable
fun ImagePagerPreview() {
    ImagePager(shoeId = 1, pagerState = rememberPagerState {
        3
    })
}

We use the rememberPagerState and pass 3 as its total page numbers that will be shown.

Now, you can create your own image slider with custom indicator.

Follow my social media for more Android tutorial: linktr.ee/notsatria

Hello Folks! While working with Android, especially if we want to improve our User Experience, we usually need to convert or parse the “machine” date format into “human” date format. For example, if you create an instance of a date in kotlin, you may see result just like below.

fun main() {
   val date = Date()
   
   println(date)
}

As a developer, we may not be confused about how to read the default date format, but for other people, it can be confusing. We need to change our mindset and put a little effort so all of user can read the date.

In this article, I hope you will learn these concepts:

• Get to know about SimpleDateFormat in Android.
• How to implement SimpleDateFormat into our app.
• Target a user specific region using Locale.

Let’s get started

What is SimpleDateFormat?

Before we dive into the implementation, we need to understand the concept of SimpleDateFormat (SDF). Basically, SDF is a class that can be used to formatting and parsing dates in Android, and it is locale sensitive. There is a bunch of formats that can be used according to our need (see here). Below here are the examples of SDF that I personally often to use.

How to Implement SDF to Android App

Like I said on above sentences, SDF support locale implementation.

What does it mean?

It means, you can implement date format in a specific region using Locale class. Let’s take a look to the implementation below.

@Composable
fun DateApp(modifier: Modifier = Modifier) {
    val currentDate = Date()
    val formattedDate = DateUtils.formatDate(currentDate, "dd MMMM yyyy")
    Column(
        modifier.fillMaxSize(),
        horizontalAlignment = Alignment.CenterHorizontally,
        verticalArrangement = Arrangement.Center
    ) {
        Text(
            text = "Default date: $currentDate",
            textAlign = TextAlign.Center,
            modifier = Modifier
        )
        Text(
            text = "Formatted date: $formattedDate",
            textAlign = TextAlign.Center,
            modifier = Modifier
        )
    }
}

If you see the code, there is two Text objects inside the column. It represents the default date and the formatted date. The result is shown below.

See right? The formatted date is more readable to user because we only show information that we want. It’s because we convert the currentDate inside the DateUtils.formatDate() function. Let’s take a look to the function.

object DateUtils {

    fun formatDate(date: Date, format: String): String {
        val dateFormat = SimpleDateFormat(format, Locale.getDefault())
        return dateFormat.format(date)
    }
}

The formatDate function has two parameters: date to input the date that we want to convert, and format is the SDF format that we want to show to the user. Like I said, SDF is locale-sensitive, so we also need to pass the Locale instance to the SimpleDateFormat class. And then, the function will return a String of formatted date using the SDF format function.

You can also convert a String formatted date using SDF parse function. But you’ll required to pass the inputFormatand outputFormat like so:

fun String.formatStrDateTo(inputFormat: String, outputFormat: String): String {
        val sdf = SimpleDateFormat(inputFormat, locale)
        val date = sdf.parse(this)
        val newSdf = SimpleDateFormat(outputFormat, locale)
        return newSdf.format(date!!)
    }

Show Region-Specific Date Format Using Locale

Once we successfully convert the “machine” date format to “human” readable format, one problem may appear.

How can I set the date to my specific language? I want the date to be Indonesian!

Okay, the solution is simple. All you need is to add your specific region using Locale. There is a bunch of languages provided by Android that you can use (see here).

I don’t see my language there. What should I do?

You can set your own locale by following this website. Here is the example if you want to use Bahasa Indonesia.

You need to pass the value of language and country in string format. And now you can see the difference👇

Now, you can make your own custom human-readable date format in Android using SimpleDateFormat and Locale class. If you like this article, please follow me! Thank you

Hello Folks! While creating Android projects, one of the most repeated features that I build is Onboarding page. For me, this feature is required because it’s the right time to slightly introduce our app. Today, I would like to give a tutorial how to create your own onboarding page using ViewPager2.

By following this tutorial, I hope you will understand these concepts:

• Understand what ViewPager2 is and why we use it.
• Create custom onboarding page using ViewPager2.
• Create custom indicator using Dot Indicator library.

Without further ado, let’s dive into the tutorial!

Prepare the design

Here is the mockup design that we want to build on our app. But first, we need to understad what ViewPager2 is.

What is ViewPager2?

ViewPager2 is Android library that is used to display views or fragment in swipeable format (read here). The reason why I love using ViewPager2 is also its compatibility to TabLayout (read here) and its ease of use. Here is how you import ViewPager2 to your project:

Add this on your project inside build.gradle.kts (app level)

implementation(libs.androidx.viewpager2)

Also add this on your libs.version.toml file. And then, don’t forget to sync project.

[versions]
viewpager2 = "1.1.0"

[libraries]
androidx-viewpager2 = { module = "androidx.viewpager2:viewpager2", version.ref = "viewpager2" }

Create Onboarding Layout

After we have done with the library, we need to create the onboarding layout by add a fragment named OnBoardingFragment. You can follow the xml code below.

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent">

    <androidx.viewpager2.widget.ViewPager2
        android:id="@+id/vpOnboarding"
        android:layout_width="match_parent"
        android:layout_height="0dp"
        app:layout_constraintBottom_toTopOf="@+id/guideline3"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent" />


    <ImageView
        android:id="@+id/ivOnboarding"
        android:layout_width="0dp"
        android:layout_height="0dp"
        android:scaleType="centerCrop"
        android:contentDescription="@null"
        android:visibility="gone"
        app:layout_constraintBottom_toTopOf="@id/cvOnboarding"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent"
        app:srcCompat="@drawable/il_onboarding_1"
        tools:visibility="visible" />

    <androidx.cardview.widget.CardView
        android:id="@+id/cvOnboarding"
        android:layout_width="match_parent"
        android:layout_height="0dp"
        android:backgroundTint="@color/navy_dark"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="@+id/guideline3">

        <androidx.constraintlayout.widget.ConstraintLayout
            android:layout_width="match_parent"
            android:layout_height="match_parent">

            <com.tbuonomo.viewpagerdotsindicator.DotsIndicator
                android:id="@+id/indicator"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                app:dotsColor="@color/indigo"
                app:dotsCornerRadius="8dp"
                app:dotsSize="12dp"
                app:dotsSpacing="4dp"
                app:dotsWidthFactor="2.5"
                app:layout_constraintBottom_toTopOf="@id/guideline7"
                app:layout_constraintEnd_toEndOf="parent"
                app:layout_constraintStart_toStartOf="parent"
                app:layout_constraintTop_toBottomOf="@id/guideline8"
                app:progressMode="false"
                app:selectedDotColor="@color/text_white" />

            <TextView
                android:id="@+id/tvTitle"
                style="@style/SourceSans.SemiBold"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:layout_marginTop="24dp"
                android:layout_marginBottom="8dp"
                android:text="@string/title_onboarding_1"
                android:textSize="24sp"
                app:layout_constraintBottom_toTopOf="@+id/tvSubtitle"
                app:layout_constraintEnd_toEndOf="parent"
                app:layout_constraintStart_toStartOf="parent"
                app:layout_constraintTop_toBottomOf="@id/indicator"
                app:layout_constraintVertical_chainStyle="packed" />

            <TextView
                android:id="@+id/tvSubtitle"
                style="@style/SourceSans"
                android:layout_width="0dp"
                android:layout_height="wrap_content"
                android:layout_marginStart="24dp"
                android:layout_marginEnd="24dp"
                android:layout_marginBottom="16dp"
                android:text="@string/subtitle_onboarding_1"
                android:textAlignment="center"
                android:textSize="16sp"
                app:layout_constraintBottom_toBottomOf="@+id/materialDivider12"
                app:layout_constraintEnd_toEndOf="parent"
                app:layout_constraintStart_toStartOf="parent"
                app:layout_constraintTop_toBottomOf="@id/tvTitle" />

            <com.google.android.material.divider.MaterialDivider
                android:id="@+id/materialDivider12"
                android:layout_width="match_parent"
                android:layout_height="1dp"
                android:layout_marginHorizontal="16dp"
                android:layout_marginTop="48dp"
                app:dividerColor="@color/divider_color"
                app:layout_constraintEnd_toEndOf="parent"
                app:layout_constraintStart_toStartOf="parent"
                app:layout_constraintTop_toBottomOf="@id/guideline2" />

            <com.google.android.material.button.MaterialButton
                android:id="@+id/btnLoginFull"
                style="@style/Widget.App.Button"
                android:layout_width="0dp"
                android:layout_height="wrap_content"
                android:layout_marginHorizontal="16dp"
                android:layout_marginTop="25dp"
                android:layout_marginBottom="24dp"
                android:layout_weight="1"
                android:orientation="horizontal"
                android:text="@string/enter"
                android:visibility="gone"
                app:layout_constraintEnd_toEndOf="parent"
                app:layout_constraintStart_toStartOf="parent"
                app:layout_constraintTop_toBottomOf="@id/materialDivider12" />

            <LinearLayout
                android:id="@+id/llButton"
                android:layout_width="match_parent"
                android:layout_height="wrap_content"
                android:layout_marginHorizontal="16dp"
                android:layout_marginTop="25dp"
                android:layout_marginBottom="24dp"
                android:orientation="horizontal"
                app:layout_constraintTop_toBottomOf="@id/materialDivider12">

                <com.google.android.material.button.MaterialButton
                    android:id="@+id/btnLogin"
                    style="@style/Widget.App.Button"
                    android:layout_width="0dp"
                    android:layout_height="wrap_content"
                    android:layout_weight="1"
                    android:text="@string/enter" />

                <Button
                    android:id="@+id/btnNext"
                    style="@style/Widget.App.Button.Outlined"
                    android:layout_width="0dp"
                    android:layout_height="wrap_content"
                    android:layout_marginStart="8dp"
                    android:layout_weight="1"
                    android:text="@string/next" />
            </LinearLayout>

            <androidx.constraintlayout.widget.Guideline
                android:id="@+id/guideline7"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:orientation="horizontal"
                app:layout_constraintGuide_begin="56dp" />

            <androidx.constraintlayout.widget.Guideline
                android:id="@+id/guideline8"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:orientation="horizontal"
                app:layout_constraintGuide_end="365dp" />

            <androidx.constraintlayout.widget.Guideline
                android:id="@+id/guideline2"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:orientation="horizontal"
                app:layout_constraintGuide_begin="170dp" />

        </androidx.constraintlayout.widget.ConstraintLayout>
    </androidx.cardview.widget.CardView>

    <androidx.constraintlayout.widget.Guideline
        android:id="@+id/guideline3"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:orientation="horizontal"
        app:layout_constraintGuide_percent="0.59" />


</androidx.constraintlayout.widget.ConstraintLayout>

Create OnBoardingAdapter

Just like RecyclerView, we need to use Adapter to communicate our ViewPager to our layout. Create the OnBoardingAdapter class that inherits from RecyclerView.Adapter You can provide your onboarding image list inside the class.

class OnBoardingAdapter : RecyclerView.Adapter<OnBoardingAdapter.ViewHolder>() {

    private val imageList = listOf(
        R.drawable.il_onboarding_1,
        R.drawable.il_onboarding_2,
        R.drawable.il_onboarding_3
    )

    override fun onCreateViewHolder(
        parent: ViewGroup,
        viewType: Int
    ): ViewHolder {
        return ViewHolder(
            ItemOnboardingBinding.inflate(
                LayoutInflater.from(parent.context),
                parent,
                false
            )
        )
    }

    override fun onBindViewHolder(holder: ViewHolder, position: Int) {
        holder.binding.apply {
            ivOnboarding.setImageResource(imageList[position])
        }
    }

    override fun getItemCount(): Int {
        return imageList.size
    }

    inner class ViewHolder(val binding: ItemOnboardingBinding) :
        RecyclerView.ViewHolder(binding.root)
}

You may see an error in the fragment_onboarding.xml file, especially on this <com.tbuonomo.viewpagerdotsindicator.DotsIndicator It happens because wi didn’t add DotsIndicator library yet.

Why do we need that library?

It’s because we need to create a super-fast indicator that can communicate with our ViewPager without creating it from scratch. But, if you do research more, you can also use TabLayoutMediator. For now, we’ll just use the library.

Integrating Dot Indicator with ViewPager2

I remember when I’m trying to research how to create custom indicator in Android and I found the library on github. It also compatible with the Jetpack Compose. First, we need to add the dependency.

Add this inside the build.gradle.kts (app level) and libs.versions.toml

implementation(libs.dotsindicator)

[versions]
dotsindicator = "5.0"

[libraries]
dotsindicator = { module = "com.tbuonomo:dotsindicator", version.ref = "dotsindicator" }

Combine the ViewPager2 and Dot Indicator

After all of those setups, it’s time to intregating our ViewPager with the Dot Indicator inside our OnBoardingFragment view.

class OnBoardingFragment : Fragment() {
    
    private var _binding: FragmentOnboardingBinding? = null
    private val binding: FragmentOnboardingBinding get() = _binding!!

    override fun onCreateView(
        inflater: LayoutInflater,
        container: ViewGroup?,
        savedInstanceState: Bundle?
    ): View {
        _binding = FragmentOnboardingBinding.inflate(inflater, container, false)
        return binding.root
    }

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        binding.apply { 
            setupViewPager()
        }
    }

    private fun FragmentOnboardingBinding.setupViewPager() {
        val adapter = OnBoardingAdapter()
        vpOnboarding.adapter = adapter

        indicator.attachTo(vpOnboarding)

        vpOnboarding.registerOnPageChangeCallback(object : ViewPager2.OnPageChangeCallback() {
            override fun onPageSelected(position: Int) {
                super.onPageSelected(position)
                btnLoginFull.visibleIf(position == 2)
                llButton.visibleIf(position < 2)

                var title = ""
                var subtitle = ""

                btnLogin.setOnClickListener {
                    startActivity(Intent(requireContext(), MainActivity::class.java))
                    requireActivity().finish()
                }

                when (position) {
                    0 -> {
                        title = getString(R.string.title_onboarding_1)
                        subtitle = getString(R.string.subtitle_onboarding_1)
                        btnNext.setOnClickListener {
                            vpOnboarding.setCurrentItem(1, true)
                        }
                    }

                    1 -> {
                        title = getString(R.string.title_onboarding_2)
                        subtitle = getString(R.string.subtitle_onboarding_2)
                        btnNext.setOnClickListener {
                            vpOnboarding.setCurrentItem(2, true)
                        }
                    }

                    2 -> {
                        title = getString(R.string.title_onboarding_3)
                        subtitle = getString(R.string.subtitle_onboarding_3)
                        btnLoginFull.setOnClickListener {
                            startActivity(Intent(requireContext(), MainActivity::class.java))
                            requireActivity().finish()
                        }

                    }

                }
                tvTitle.text = title
                tvSubtitle.text = subtitle
            }
        })

    }

    override fun onDestroyView() {
        super.onDestroyView()
        _binding = null
    }
}

Focus on the setupViewPager extension function. Here are the explanations:

• Create OnBoardingAdapter instance and assign it to the viewpager.
• Attach the Dot Indicator to ViewPager by using the attachTo(viewPager2: ViewPager2) function,
• Call the ViewPager callback function using the registerOnPageChangeCallback and override the onPageSelected(position: Int) function.
• You can do whatever you want to, inside the callback function. For example, on the code I provided, I’m trying to change the title, subtitle, button visibility, and button functionalities inside.

By following the step-by-step and build the app, the result can be shown below.

And that’s it! Now you can create your own OnBoarding page using ViewPager2 and Dot Indicator.

Follow me for more tips!

Saat awal-awal belajar pemrograman Android, Saya merasa “kelelahan” karena banyak sekali konsep yang harus dipelajari. Salah satunya adalah konsep tentang ViewModel. Bahkan, sebelum mengenal pemrograman Android sekalipun, Saya sering terpapar kata tersebut. Tidak jarang, kata-kata Model View ViewModel (MVVM) juga sering masuk melalui telinga Saya.

Lantas, kenapa sih seakan-akan ViewModel ini sering digaungkan dan terkesan sangat penting? Yuk kita cari tahu!

Dengan membaca artikel ini, diharapkan Anda dapat memahami beberapa hal berikut:

• Memahami apa itu ViewModel
• Melihat contoh kasus yang kerap dialami pemula saat belajar Android pertama kali
• Mencoba mencari solusi dari masalah tersebut menggunakan ViewModel

Sudah siap? Yuk kita mulai!

Apa itu ViewModel?

Dalam perkembangannya, pemrograman Android didesain untuk memisahkan kode sesuai dengan kegunaannya, atau sering disebut sebagai Separation of Concern (SoC). ViewModel adalah sebuah class yang digunakan untuk mengatur business logic dan mempertahankan state pada User Interface (UI) aplikasi kita dari perubahan konfigurasi (Baca di sini). Contohnya adalah ketika terjadi perubahan rotasi atau perubahan bahasa di dalam aplikasi.

Jadi intinya, ViewModel ini “ditugaskan” untuk menjaga state aplikasi supaya tetap bertahan. ViewModel merupakan bagian dari modern Android architecture. ViewModel juga sering kali menjadi “jembatan” antara UI dengan data (misalnya data dari API, Local Database, atau Shared Preferences). Dalam penerapannya, ViewModel kerap didampingi oleh observer seperti LiveData, atau coroutine seperti StateFlow untuk manajemen data.

Masalah yang dihadapi saat mengembangkan aplikasi Android pertama kali

Studi kasus yang kerap kali dihadapi oleh orang yang pertama kali belajar Android adalah mempertahankan state aplikasi ketika terjadi perubahan konfigurasi.

Maksudnya gimana tuh?

Kita ambil contoh pada aplikasi yang pernah kita buat sebelumnya pada artikel saya ini How To Create Custom Currency (Rupiah) TextField in Android. Seperti yang bisa kita lihat, aplikasi tampak berjalan normal, hingga Anda melakukan rotasi seperti di bawah ini.

Lho kok ilang bwang?

Hal ini dapat terjadi karena ketika terjadi perubahan konfigurasi seperti rotasi layar, aplikasi akan membuat instance Activity yang baru. Sehingga aplikasi kita memanggil method onDestroy() kemudian onCreate() yang berakibat pada hilangnya state aplikasi kita. (Baca di sini)

Solusi Menggunakan ViewModel

Masalah yang terjadi di atas tentu menghasilkan User Experience (UX) yang buruk bagi pengguna. Sebagai developer yang baik, Anda harus segera mencari solusi untuk meng-handle state tersebut supaya pengguna tidak segera meng-uninstall aplikasi kita. Untuk kasus ini, kita bisa menggunakan ViewModel sebagai solusi. Implementasinya seperti di bawah ini.

Kita harus membuat class terpisah bernama MainViewModel, nama ini ditentukan dari nama masing-masing view. Android merekomendasikan untuk setiap satu view memiliki satu buah ViewModel.

import androidx.lifecycle.ViewModel

class MainViewModel : ViewModel() {
}

Kita bisa mulai menuliskan business logic dari aplikasi kita. Misalkan pada kasus di atas, kita ingin menyimpan nilai value yang dihasilkan oleh edtPrice. ViewModel biasanya dikombinasikan dengan observer seperti LiveData atau StateFlow.

class MainViewModel : ViewModel() {
    private var _price = MutableLiveData<String>()
    val price: LiveData<String> get() = _price

    fun setPrice(price: String) {
        _price.value = price
    }
}

Untuk memanggil ViewModel ke dalam view, Anda bisa menggunakan beberapa cara. Salah satunya adalah dengan menggunakan delegated properties seperti di bawah ini.

class MainActivity : AppCompatActivity() {

    private val mainViewModel: MainViewModel by viewModels()

}

Kemudian, untuk menerapkan logic yang telah kita buat, bisa dilakukan seperti di bawah ini.

class MainActivity : AppCompatActivity() {

    private val mainViewModel: MainViewModel by viewModels()

    private lateinit var edtPrice: EditText
    private lateinit var tvValue: TextView

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        enableEdgeToEdge()
        setContentView(R.layout.activity_main)

        tvValue = findViewById(R.id.tvValue)
        edtPrice = findViewById(R.id.edtPrice)

        // set on done ime action
        edtPrice.setOnEditorActionListener { _, actionId, _ ->
            if (actionId == EditorInfo.IME_ACTION_DONE) {
                mainViewModel.setPrice(edtPrice.text.toString())
            }
            true
        }

        mainViewModel.price.observe(this) { price ->
            tvValue.text = getString(R.string.value, price)
        }

    }
}

Penyimpanan nilai priceterjadi saat pemanggilan function mainViewModel.setPrice(edtPrice.text.toString())

edtPrice.setOnEditorActionListener { _, actionId, _ ->
            if (actionId == EditorInfo.IME_ACTION_DONE) {
                mainViewModel.setPrice(edtPrice.text.toString())
            }
            true
        }

Kemudian, nilai dari price diakses menggunakan observer bawaan dari LiveData yang menghasilkan nilai return price

mainViewModel.price.observe(this) { price ->
            tvValue.text = getString(R.string.value, price)
        }

Setelah itu, kita coba test aplikasi kita. Apakah hasilnya berubah atau masih sama.

Sekarang Anda bisa membuat UX tetap terjaga dengan baik menggunakan ViewModel.

Kesimpulan

• ViewModel merupakan bagian dari Modern Android Architecture yang bertugas untuk mengatur business logic dan mempertahankan state aplikasi.
• Sebelum menerapkan ViewModel, state aplikasi dapat “terhapus” dengan adanya perubahan konfigurasi seperti rotasi layar.
• ViewModel biasanya diterapkan dengan LiveData atau StateFlow sebagai observer.
• Disarankan untuk menggunakan satu ViewModel untuk setiap view.

Saat mengembangkan aplikasi Android, Anda akan menemukan satu konsep bernama Dependency Injection (DI). Ini adalah sebuah konsep dasar yang harus Anda kuasai dalam mengembangkan aplikasi Android.

Apa itu Dependency Injection?

Secara singkat, konsep ini biasa saya definisikan sebagai “ketergantungan” antara satu class dengan class lain. Seperti contoh yang tertulis pada laman blog resmi Android berikut Dependency injection in Android | Android Developers.

Contoh Kasus

Ketika kita ingin mendefinisikan class Car yang bergantung pada class Engine. Kode yang tidak menerapkan konsep DI, terlihat seperti di bawah ini.

class Car {
  private val engine = Engine()
  
  fun start() {
    engine.start()
  }
}

fun main() {
  val car = Car()
  car.start()   
}

Terlihat seperti tidak ada yang salah, bukan?. Padahal, jika kita perhatikan lebih dalam, kode di atas akan membuat class Car sangat bergantung pada class Engine. Ini akan mempersulit kita saat ingin memisahkan Car menjadi (misalkan) Electric Car dan Gas Car. Padahal, keduanya hanya berbeda pada engine-nya saja.

Lalu, bagaimana solusinya?

Solusinya adalah dengan membuat class Car tidak bergantung secara langsung dengan class Engine, atau dikenal dengan istilah loosely coupled.

class Car(private val engine: Engine) {
  fun start() {
    engine.start()
  }
}

fun main() {
  val engine = Engine()
  val car = Car(engine)
  car.start()
}

Dengan begitu, Anda juga bisa saja membuat Electric Car atau Gas Car secara bebas. Seperti pada contoh di bawah ini.

class ElectricEngine : Engine() {}

class GasEngine : Engine() {}

class Car(private val engine: Engine) {
  fun start() {
    engine.start()
  }
}

fun main() {
  val electricEngine = ElectricEngine()
  val gasEngine = GasEngine()

  val electricCar = Car(electricEngine)
  val gasCar = Car(gasEngine)

  electricCar.start()
  gasCar.start()
}

Contoh Implementasi Manual Dependeny Injection

Implementasi Manual DI akan sering kita temui saat mulai mengimplementasikan beberapa fitur di aplikasi kita, seperti local database, network connection, preferences, dan lain-lain. Contoh penerapan pada local database adalah sebagai berikut.

Database yang saya gunakan adalah Room (baca di sini). Sederhananya, urutannya adalah sebagai berikut:

1. Membuat instance database.
2. Membuat Injection/Service Locator untuk mem-provide instance dari database ke dalam repository.
3. Memanggil Service Locator di dalam ViewModel melalui ViewModelFactory

Membuat instance database melalui function getInstance()

@Database(entities = [TransactionEntity::class], version = 1)
@TypeConverters(Converters::class)
abstract class TransactionDatabase : RoomDatabase() {
    abstract fun dao(): TransactionDao

    companion object {
        @Volatile
        private var INSTANCE: TransactionDatabase? = null

        @JvmStatic
        fun getInstance(context: Context): TransactionDatabase {
            if (INSTANCE == null) {
                synchronized(TransactionDatabase::class.java) {
                    INSTANCE = Room.databaseBuilder(
                        context.applicationContext,
                        TransactionDatabase::class.java,
                        "transaction.db"
                    )
                        .build()
                }
            }
            return INSTANCE as TransactionDatabase
        }
    }
}

Jangan lupa untuk membuat Data Access Object (DAO) beserta Entity-nya.

interface TransactionDao {
    // Some DAO implementations
}

@Entity(tableName = "transaction")
@Parcelize
data class TransactionEntity(
    // Entities property
) : Parcelable

Membuat TransactionRepository

Perlu diperhatikan bahwa di sini saya juga menggunakan AppExecutor yang digunakan untuk meng-eksekusi database pada Thread yang berbeda (Baca di sini).

class TransactionRepository private constructor(
    private val dao: TransactionDao,
    private val appExecutors: AppExecutors
) {
    // Implement logics here

    companion object {
        fun getInstance(
            dao: TransactionDao,
            appExecutors: AppExecutors,
        ): TransactionRepository {
            return TransactionRepository(dao, appExecutors)
        }
    }
}

Buat Injection

Function provideTransactionRepository ini lah yang akan menjadi kunci utama dari manual DI. Inti dari function ini adalah membuat instance TransactionRepository yang akan dibutuhkan nanti.

object Injection {
    fun provideTransactionRepository(context: Context): TransactionRepository {
        val db = TransactionDatabase.getInstance(context)
        val dao = db.dao()
        val appExecutors = AppExecutors()

        return TransactionRepository.getInstance(dao, appExecutors)
    }
}

Menggunakan Injection

KarenaTransactionViewModel membutuhkan instance dari TransactionRepository di sini, kita perlu memanfaatkan penggunaan ViewModelFactory pada kode kita. Hal ini karena proses dependensi yang sedikit berbeda pada ViewModel sehingga diperlukan mekanisme tambahan (Baca di sini).

class TransactionViewModel(private val repository: TransactionRepository) : ViewModel() {
    // Some logics here
}

class ViewModelFactory private constructor(
    private val transactionRepository: TransactionRepository
) : ViewModelProvider.NewInstanceFactory() {
    override fun <T : ViewModel> create(modelClass: Class<T>): T {
        return when (modelClass) {
            TransactionViewModel::class.java -> TransactionViewModel(transactionRepository) 
            else -> throw IllegalArgumentException("Unknown ViewModel class: ${modelClass.name}")
        }
    }

    companion object {
        fun getInstance(context: Context): ViewModelFactory =
            ViewModelFactory(Injection.provideTransactionRepository(context))
    }
}

Jika Anda perhatikan, proses Manual DI terjadi saat pembuatan instance ViewModelFactory di atas (perhatikan pada function getInstance()). Pada constructor ViewModelFactory kita inject dengan function yang kita telah kita buat sebelumnya untuk mem-provide TransactionRepository.

Panggil ViewModel Di Dalam View

Setelahnya, kita dapat memanggil TransactionViewModel dengan bebas di dalam view kita, tanpa “memperhatikan” cara pembuatan instance dari View Model tersebut.

class TransactionFragment : Fragment() {

    private val viewModel by viewModels<TransactionViewModel> {
        ViewModelFactory.getInstance(requireContext())
    }
}

Simple kan?

Penutup

Perlu diperhatikan bahwa cara di atas bukan merupakan cara terbaik dalam menerapkan konsep Dependency Injection (DI). Jika Anda pelajari lebih dalam lagi, Anda akan menemukan cara-cara DI yang lebih advance seperti penggunaan Dagger, Dagger-Hilt, dan Koin sebagai library yang dapat membuat proses DI menjadi jauh lebih mudah. Namun, tulisan saya di atas bisa menjadi acuan Anda untuk mempelajari konsep dan memahami Dependency Injection beserta dengan implementasinya.

Terhubung dengan penulis👇

Satria — Android Developer | Instagram, TikTok | Linktree

Sebagian dari kita pasti tau arti dari Typing Ganteng — Ketikan yang disukai oleh kebanyakan orang zaman sekarang wkwk (Baca tentang typing ganteng). Sebagai pengantar, dulu saya tidak suka dengan Kotlin. Alasannya adalah karena bahasanya yang ribet, susah dimengerti dan banyak fitur yang terlalu canggih😿.

Namun, sekarang saya mencoba untuk mengubah mindset tersebut menjadi “Kotlin bahasa yang ribet dan canggih, kalo Saya bisa menguasainya, artinya saya keren dan ikut canggih”. Benar saja, setelah saya mencoba untuk memahami Kotlin, saya semakin suka (dan benci juga sih) dengan bahasa ini😽.

Salah satu fitur yang ada pada Kotlin adalah Extension Function.

Hah, apaan tuh? Kagak pernah denger sebelumnya.

Jadi, intinya Extension Function adalah fitur yang memungkinkan kita untuk membuat function dari class atau interface yang sudah ada, tanpa memodifikasi atau membuat class baru yang meng-inherit class tersebut (Extension Function).

Coba kita lihat contohnya

Perhatikan pada tulisan saya tentang Custom Radio Button. Jika Anda perhatikan, di sana terdapat function bernama visibleIf yang memungkinkan kita untuk mengatur visibilitas dari satu view berdasarkan kondisi tertentu. Padahal, function tersebut tidak terdapat dalam Kotlin itu sendiri.

Sebelum mengenal Extension Function, saya menulis kode untuk mengatur visibilitas view sebagai berikut.

fun updateVisibility(view: View, isVisible: Boolean) {
    view.visibility = if (isVisible) View.VISIBLE else View.GONE
}

Sebetulnya, tidak ada masalah dengan kode tersebut. Namun, karena kita di sini ingin lebih menjadi tampan, ganteng, dan sigma. Oleh karenanya, kita coba menerapkan Extension Function seperti di bawah ini.

fun View.visibleIf(condition: Boolean) {
    this.visibility = if (condition) View.VISIBLE else View.GONE
}

Terus, perbedaannya ada di mana bwang?

Jadi, letak perbedaannya adalah dari cara kita memanggil function tersebut. Kita lihat seperti di bawah ini.

private val button: Button = findViewById(R.id.button)

// Using normal function
updateVisibility(button, condition)

// Using extension function
button.visibleIf(condition)

Penutup

Jadi, menurut Saya pribadi, memanfaatkan penggunaan extension function dapat meningkatkan readability dari kode kita. Hal ini dapat meningkatkan aura Anda menjadi +99999 dan mendapatkan pujian dari senior Anda, sehingga kelak dapat memiliki gelar “Typing Ganteng” yang sesungguhnya.

Jika Anda suka dengan konten yang saya tulis, Anda bisa menambah aura dan ke-sigmaan dengan mengikuti saya di beberapa media sosial saya berikut Satria — Android Developer | Instagram, TikTok | Linktree.