The

OnBackPressedDispatcher

controls how Back button events are dispatched to one or more

OnBackPressedCallback

objects.

https://developer.android.com/reference/androidx/activity/OnBackPressedCallback

In Kotlin a "receiver" is the instance on which an extension function is defined, or the type for a lambda with receiver.

https://kotlinlang.org/docs/reference/annotations.html

If you want to iterate over all the entries of a known enum class, you can use the ‘.values()’ function. If you are working with generic enums, you can use the ‘enumValues()’ function instead.

JetPack Compose has a very strange
way of describing columns and rows.

The calls to StartScreen, MiddleScreen, and EndScreen might happen in any order.

This means you can't, for example, have StartScreen() set some global variable (a side-effect) and have MiddleScreen() take advantage of that change.

Instead, each of those functions needs to be self-contained.

We are finally getting the ability to animate Lazy list's item position changes in #JetpackCompose just like we did with DiffUtil 🎉

The Modifier API called `Modifier.animateItemPlacement()` was implemented and merged and will probably be released in an upcoming Compose version.

Ktor client now provides first-class support for retries.

Optimizer for ConstraintLayout

The Dispatchers.Unconfined coroutine dispatcher starts a coroutine in the caller thread, but only until the first suspension point.

After suspension it resumes the coroutine in the thread that is fully determined by the suspending function that was invoked.

Explain the difference between Cold Flow and Hot Flow with an example.

Cold Flow 🥶

➡️ A cold flow is a data flow that produces values only when there is an active collector.

➡️ Each collector receives the emitted values independently, and they start receiving emissions from the beginning when they subscribe.

➡️ If we subscribe to a cold flow, we will receive all of the emitted values, even if the flow has already completed emitting values.

✅ When to use?

➡️ Cold flows are typically used for tasks that need to be performed only once, such as loading data from a database or fetching data from a remote server.

➡️ Example

Flow (itself)

Hot Flow 🔥

➡️ A hot flow is a data flow that emits values regardless of whether there are active collectors. It can produce values even if there are no subscribers.

➡️ New collectors joining a hot flow might miss emissions that occurred before they started listening.

➡️ If we subscribe to a hot flow, we will start receiving emissions from the point where the flow is currently at. If the flow has already completed emitting values, we will not receive any emissions.

✅ When to use?

➡️ Hot flows are typically used for tasks that need to be performed continuously, such as updating a Ul with real-time data.

✅ Example

StateFlow and SharedFlow