Why are updates to Kotlin, Compose, and KSP such a hassle?

In Android development, you're constantly dealing with the same set of three: Kotlin, the Compose Compiler, and KSP.

They seem like a friendly group, but their update schedules are always completely different! You upgrade Kotlin, and the Compose Compiler isn't compatible. You change something, and KSP throws a build error because of an internal API change...

To better manage this "dependency triangle" situation, the main idea is to use Renovate's configuration to treat them as a single unit. The simple plan is: "Raise all Kotlin ecosystem dependencies at the same time!"

 

🧑🏻‍💻 Brief overview of the renovate.json file


{
  "$schema": "https://docs.renovatebot.com/renovate-schema.json",
  "extends": [
    "config:base",
    "group:all",
    ":dependencyDashboard",
    "schedule:daily"
  ],
  "baseBranches": ["main"],
  "commitMessageExtra": "{{{currentValue}}} to {{#if isPinDigest}}{{{newDigestShort}}}{{else}}{{#if isMajor}}{{prettyNewMajor}}{{else}}{{#if isSingleVersion}}{{prettyNewVersion}}{{else}}{{#if newValue}}{{{newValue}}}{{else}}{{{newDigestShort}}}{{/if}}{{/if}}{{/if}}{{/if}}",
  "packageRules": [
    {
      "matchPackagePatterns": ["androidx.compose.compiler:compiler"],
      "groupName": "kotlin"
    },
    {
      "matchPackagePatterns": ["org.jetbrains.kotlin.*"],
      "groupName": "kotlin"
    },
    {
      "matchPackagePatterns": ["com.google.devtools.ksp"],
      "groupName": "kotlin"
    }
  ]
}

👉 architecture-samples/renovate.json at main · android/architecture-samples

Roughly summarized, here are the key points:

  • groupName: "kotlin" to bundle dependencies This setting specifies that the three elements—the Compose Compiler, Kotlin, and KSP—should be treated as belonging to the "same group." This allows Renovate to update them all together at once.
  • schedule: daily for a calm update pace This checks for updates once a day. You'll receive pull requests (PRs) on a daily basis, preventing a huge influx of dependency updates all at once, which makes things much easier to manage.
  • commitMessageExtra to see changes at a glance The version difference, like "2.0.10 → 2.0.20," is automatically added to the PR title. It's a small tweak, but surprisingly useful.

Setting up your configuration this way significantly reduces the tragedy of "Kotlin got updated, but Compose broke..."

 

🧑🏻‍💻 What We Found While Using It

Once this setup is in place, you can feel much more confident testing updates for everything Kotlin-related. Renovate diligently checks daily, automatically creating a PR whenever a new version drops.

But there's one small warning:

The Compose Compiler sometimes takes a little extra time to catch up to the latest Kotlin version. So, don't just merge the PR when you see it—it's highly recommended to verify the CI status first.

KSP is similar; because it depends on Kotlin's internal workings, it's safer to update it along with Kotlin and run your tests together.

 

🧑🏻‍💻 Summary: Teach Renovate that "These Three Are a Set"

The configuration we discussed treats the trio of Kotlin, the Compose Compiler, and KSP as a single group.

  • Bundle all Kotlin-related dependencies for simultaneous updates.
  • Check for updates at a manageable daily pace.
  • See version differences directly in the PR title.

Just implementing this significantly reduces the problems caused by versions getting out of sync and breaking your build.

💡 Key Takeaway: Use Renovate less as an "automatic update tool" and more as a "dependency rulebook."

We simply need to tell Kotlin, Compose, and KSP to cooperate and "work together."

👉 Kotlin・Compose・KSP の更新、どうしてこんなに面倒なの?

[AI Coding] The Essence of Asynchronous Processing! Mastering Compose with LaunchedEffect and produceState

I used to rely heavily on LaunchedEffect for handling asynchronous operations in Compose,but lately, I’ve realized that produceState might allow for a cleaner and more concise implementation.

So, I asked several AI assistants for their opinions and compared their responses.

 

🤔 GitHub Copilot

  • LaunchedEffect: Suitable for asynchronous operations that modify externally managed states (e.g., ViewModel).
  • produceState: Best for generating and managing asynchronous data directly within Compose.
  • Choose LaunchedEffect for externally managed state, and produceState for internally managed state.


@Composable
fun ExampleScreen(viewModel: MyViewModel = viewModel()) {
    // LaunchedEffect: Update externally managed state asynchronously
    val externalState by viewModel.uiState.collectAsState()
    LaunchedEffect(Unit) {
        viewModel.loadData() // Update external state asynchronously
    }

    // produceState: Generate and manage asynchronous data inside Compose
    val internalState by produceState(initialValue = "Loading...", key1 = viewModel) {
        value = viewModel.loadDataSync() // Assign result to internal state
    }

    Column {
        Text("LaunchedEffect State: $externalState")
        Text("ProduceState State: $internalState")
    }
}

 

🤔 ChatGPT

  • Use LaunchedEffect when updating existing state through side effects.
  • Use produceState when treating the result of an async operation as a state itself.
  • “Generate” with produceState, “manipulate” with LaunchedEffect.



@Composable
fun UserScreen(userId: String) {
    var user by remember { mutableStateOf<User?>(null) }
    LaunchedEffect(userId) { user = api.fetchUser(userId) } // Update existing state

    val userState by produceState<User?>(initialValue = null, key1 = userId) {
        value = api.fetchUser(userId) // Convert async result directly to state
    }

    Text("Launched: ${user?.name ?: "Loading..."}")
    Text("Produced: ${userState?.name ?: "Loading..."}")
}

 

🤔 Gemini

  • produceState: Ideal for exposing results of suspend functions or external data sources as reactive State for the UI.
  • LaunchedEffect: Tied to the composable’s lifecycle, suited for one-time async actions or UI event triggers (e.g., showing a snackbar).
  • State management: produceState handles state automatically, while LaunchedEffect requires manual updates via mutableStateOf.


@Composable
fun UserDataState(userId: String): State<User?> = produceState<User?>(
    initialValue = null,
    key1 = userId // Automatically restarts when key changes
) {
    value = fetchUserFromApi(userId)
}

@Composable
fun EventSnackbar(viewModel: MyViewModel) {
    val scope = rememberCoroutineScope() // Scope for showing snackbar
    LaunchedEffect(Unit) { // Runs once on first composition
        viewModel.uiEvents.collect { event ->
            // Receive UI event and trigger a side effect (e.g., show snackbar)
            scope.launch { SnackbarHostState.showSnackbar("Received event!") }
        }
    }
}

 

🤔 Summary

  • LaunchedEffect: Used when updating externally managed states (e.g., ViewModel) through asynchronous operations.
  • produceState: Used when generating and managing the result of asynchronous processing directly as state within Compose.
  • If the state is managed externally, use LaunchedEffect; if it’s internally generated, use produceState.
  • LaunchedEffect requires manual state updates, while produceState automatically manages state.
  • Use LaunchedEffect to update external state, and produceState to generate internal state.
  • LaunchedEffect manipulates existing state through side effects.
  • produceState creates new state from asynchronous results.
  • Operate state = LaunchedEffect / Generate state = produceState
  • produceState: Ideal for exposing asynchronous results as automatically managed State objects for the UI.
  • LaunchedEffect: Used to manually update existing states (e.g., ViewModel’s state) or trigger side effects such as showing a snackbar.
  • Where the state is managed: If it’s generated within Compose → use produceState.
  • Where the state is managed: If it’s controlled outside Compose (e.g., ViewModel) → use LaunchedEffect.

👉 【AIコーディング】非同期処理の極意！LaunchEffect と produceState の使い分けで Jetpack Compose を制す

Activity x Compose Lifecycle: The Complete Visual Guide 🚀

 

👨‍💻 Activity Lifecycle


Activity.onCreate() <- Activity is created

↓

Activity.onStart() <- Preparing to become visible on screen

↓

Activity.onResume() <- Foreground state (interactive)

↓

Activity.onPause() <- Partially visible

↓

Activity.onStop() <- No longer visible

↓

Activity.onDestroy() <- Activity is destroyed

 

👨‍💻 Compose Lifecycle


[First Composition]
  - Composable is evaluated, Compose tree is built
  - LaunchedEffect -> Runs once after the commit
  - SideEffect -> Runs after every commit
  - DisposableEffect -> onDispose is called upon disposal

↓

[Recomposition]
  - UI is re-evaluated in response to state or data changes
  - Only the necessary parts are recomposed (efficient update)
  - SideEffect and DisposableEffect are also re-evaluated during recomposition

↓

[Dispose]
  - Depends on the ComposeView's disposal condition
  - DisposableEffect's onDispose is executed
  - Disposal timing is determined by the ViewCompositionStrategy

 

👨‍💻 Activity x Compose Lifecycle


Activity.onCreate() setContent { ... } <- Sets the ComposeView

↓

[First Composition]
  - Evaluates Composables and builds the UI
  - LaunchedEffect -> Runs once after commit
  - SideEffect -> Runs after each commit
  - DisposableEffect -> Defines onDispose

↓

Activity.onStart()

↓

Activity.onResume()

↓

[Recomposition]
  - Re-evaluates necessary parts in response to state changes
  - LaunchedEffect is not re-executed (only if its key changes)
  - SideEffect / DisposableEffect are re-evaluated

↓

Activity.onPause()

↓

(ComposeView is retained)
  - UI becomes partially obscured
  - State is maintained within the Composition

↓

Activity.onStop()

↓

[Preparing for Dispose (Detection)]
  - ViewCompositionStrategy monitors disposal conditions

↓

Activity.onDestroy()

↓

[Dispose]
  - ComposeView is destroyed
  - DisposableEffect.onDispose() is executed

This is the general flow.

Here are the notes for each item:

Activity.onCreate() A lifecycle method called when an Android app's Activity is created.

    setContent { ... }: Sets the UI using Jetpack Compose. This sets a ComposeView as the Activity's content view. The Compose lifecycle begins.

  • First Composition The Composable functions set in setContent are evaluated for the first time, and the UI is built.

LaunchedEffect: An Effect used for asynchronous processing. Runs only once after the first composition.

SideEffect: Runs after every composition commit (the timing when UI changes are applied).

DisposableEffect: An Effect used for resource cleanup. The logic defined in onDispose is executed when the Composition is disposed.

Activity.onStart() A lifecycle method called just before the Activity becomes visible to the user.

Activity.onResume() The Activity moves to the foreground and becomes fully interactive with the user.

  • Recomposition Only the necessary Composable functions are re-evaluated in response to changes in State.

LaunchedEffect: It is not re-executed during recomposition. However, it will be re-executed if its key changes.

SideEffect: It is re-evaluated on every recomposition.

DisposableEffect: It is re-evaluated on recomposition, and the cleanup logic (onDispose) from the old Effect is called.

Activity.onPause() The Activity enters a paused state and becomes partially obscured.

ComposeView Retention: The UI is not destroyed; it is retained. The state is also maintained within the Composition, allowing it to be reused upon re-display.

Activity.onStop() The Activity is no longer visible. A time to prepare for cleaning up state and resources.

Preparing for Dispose (Detection) ViewCompositionStrategy: A mechanism that monitors the conditions under which the ComposeView should be disposed. It triggers the Composition's disposal based on the View's lifecycle.

Activity.onDestroy() The timing when the Activity is completely destroyed.

  • Dispose The ComposeView is destroyed: The UI and state are completely released.
  • DisposableEffect.onDispose(): The resource cleanup logic is called.

 

👨‍💻 Summary

The Jetpack Compose and Activity lifecycles are closely linked, with specific processes occurring at each stage, from UI initialization (setContent) to disposal (Dispose).

It is especially important to understand the differences between effects like LaunchedEffect, SideEffect, and DisposableEffect, and to manage them appropriately.

Furthermore, by efficiently reusing the UI in response to Activity state changes (like onResume or onPause) and cleaning up resources as needed, you can achieve stable application behavior.