# sharedflow Published articles for sharedflow. This is one page of public article previews, not the complete archive. Follow Next page to continue. Summaries are not the original full articles. ## Bridging Compose and View: Seamless Interop Communication with CompositionLocal DevFeed: [Bridging Compose and View: Seamless Interop Communication with CompositionLocal]() Original publisher: [Read original article]() Author: Julien Salvi Published: 2025-03-05T13:42:13Z Content type: tutorial Language: en Sources: [Stories by Julien Salvi on Medium]() Topics: [Compose](), [interoperability](), [Dependency injection](), [ui]() Tags: [android](), [android-development](), [androiddev](), [bridge](), [compose](), [dependency-injection](), [interface-implementation](), [interoperability](), [jetpack-compose](), [sharedflow](), [stateflow](), [ui](), [viewmodel]() ### AI overview This tutorial explains how to bridge Jetpack Compose and traditional Android Views using CompositionLocal. It shows how to provide a FeedbackMessageInterop implementation so composables can trigger View-based feedback, and describes the reverse direction through an interface and reactive streams such as StateFlow or SharedFlow. ### Source excerpt Migrating to Compose exposed the team to several interoperability challenges as we integrated new Composables into our existing codebase. One key hurdle was figuring out how to trigger events from Compose and dispatch them to the main View holder, such as a Fragment or Activity. After some exploration, we found an efficient solution using CompositionLocal. Here's how we made it work! 🚀 What is a CompositionLocal? Think of CompositionLocal as a localized dependency injection system built directly into Compose's composition model. You create a CompositionLocal instance, which acts as a key for a specific type of data. Then, using the CompositionLocalProvider, you define a scope within your UI tree and associate a value with that CompositionLocal key. Any composable within that scope can then access the provided value using the CompositionLocal.current property, without needing to know where the value originated. This not only simplifies code but also makes it more maintainable and reusable. Furthermore, CompositionLocal values can be dynamic, triggering recomposition when they change, and they are thread-safe, making them a powerful tool for managing shared state within your Compose UI. Interop Communication with CompositionLocal In the following code, LocalFeedbackInterop is a staticCompositionLocalOf that will hold an implementation of the FeedbackMessageInterop interface. This interface defines the methods for showing feedback alerts, and the staticCompositionLocalOf ensures that the implementation is unlikely to change as it cannot be re-provided. This allows any composable within the scope to access the FeedbackMessageInterop implementation and trigger feedback messages without explicit dependencies. import androidx.compose.runtime.ProvidableCompositionLocal import androidx.compose.runtime.staticCompositionLocalOf val LocalFeedbackInterop: ProvidableCompositionLocal = staticCompositionLocalOf { null } interface FeedbackMessageInterop { fu ## Representing ViewModel events with StateFlow vs. SharedFlow vs. Channel DevFeed: [Representing ViewModel events with StateFlow vs. SharedFlow vs. Channel]() Original publisher: [Read original article]() Published: 2024-11-18T00:00:00Z Content type: tutorial Language: en Sources: [Kt. Academy]() Topics: [Kotlin](), [Android](), [Coroutines]() Tags: [android](), [channel](), [coroutines](), [kotlin](), [navigation](), [sharedflow](), [stateflow](), [toast](), [viewmodel](), [workshop-learning-programming]() ### AI overview This article compares StateFlow, SharedFlow, and Channel for representing events in an Android ViewModel. It explains why StateFlow can lose events, notes SharedFlow's behavior when no UI observer is present, and discusses using an unlimited-capacity Channel as an event queue. ### Source excerpt What is the best way to represent ViewModel events in Kotlin? ## SharedFlow vs StateFlow DevFeed: [SharedFlow vs StateFlow]() Original publisher: [Read original article]() Published: 2024-06-27T00:00:00Z Content type: tutorial Language: en Sources: [Kt. Academy]() Topics: [Kotlin](), [LineageOS](), [Back end](), [WebSocket]() Tags: [android](), [backend](), [exceptions](), [kotlin](), [messages](), [parameter](), [progress](), [service](), [sharedflow](), [state](), [stateflow](), [users](), [value](), [websocket](), [workshop-learning-programming]() ### AI overview This tutorial explains the distinction between Kotlin's StateFlow and SharedFlow. StateFlow represents observable application state, while SharedFlow broadcasts events to observers. It discusses replay, required initial values, distinct updates, conflation, and examples for Android and backend services. ### Source excerpt When to use SharedFlow and when to use StateFlow. ## Strategies for automatically refreshing data on Android using Kotlin Flow DevFeed: [Strategies for automatically refreshing data on Android using Kotlin Flow]() Original publisher: [Read original article]() Author: Christophe Beyls Published: 2023-10-06T17:27:03Z Content type: tutorial Language: en Sources: [Stories by Christophe Beyls on Medium]() Topics: [kotlin-flow](), [Kotlin](), [Android](), [RxJava](), [ui]() Tags: [android](), [android-app-development](), [androiddev](), [api](), [coroutine](), [flow](), [kotlin](), [kotlin-flow](), [rxjava](), [sharedflow](), [ui]() ### AI overview This tutorial explains how to periodically refresh data in Android user interfaces with Kotlin Flow. It compares sequential map() processing with concurrent, cancellation-aware mapLatest() processing and discusses lifecycle-aware refreshing and caching considerations. ### Source excerpt Making timers lifecycle-aware This is the third part of a series of articles discussing the usage of Kotlin Flow to efficiently load data in Android applications. It's a direct follow-up to part 2: "Smarter Shared Kotlin Flows", as it reuses the same concepts to cover another use case: automatic periodic refresh of the user interface. Simple periodic refresh When it's not possible to determine precisely when a data set displayed by the UI has changed, or when it changes too frequently, a common strategy is to reload the data periodically at a fixed interval while the screen is visible. One of the simplest ways to achieve this is to create a Flow from an infinite loop calling delay() between emissions: fun tickerFlow(period: Duration): Flow = flow { while (true) { emit(Unit) // Tick delay(period) } } This is equivalent to the Observable.interval() operator in RxJava with a fixed emitted value (Unit) and an initial delay of 0. Then, transform this Flow using the map() or mapLatest() operator to perform the loading action on each "tick" of the timer and return the result: tickerFlow(REFRESH_INTERVAL) .map { repository.loadSomeData() } Note the subtle difference in behavior between the two operators: With map() the entire Flow will be executed in sequence within a single coroutine, meaning delay() will only start running after the loading operation completes. As a result, each loading operation will be delayed by the amount of time it took to perform the previous loading operation, plus the fixed interval. With mapLatest() the main coroutine will collect the upstream values of tickerFlow() while a child coroutine will be created to perform the loading operation concurrently and collect the result without suspending the main coroutine. This means that delay() will start running immediately after the previous tick and each loading operation will start precisely according to schedule. This also means that the interval must be longer than the typical loading time beca ## StateFlow and SharedFlow in ViewModels DevFeed: [StateFlow and SharedFlow in ViewModels]() Original publisher: [Read original article]() Author: James Shvarts Published: 2022-12-28T19:21:19Z Content type: tutorial Language: en Sources: [Android Blog - Mobile Dev Notes]() Topics: [Kotlin](), [Android](), [Code](), [Unit testing](), [Compose]() Tags: [android](), [compose](), [kotlin](), [sharedflow](), [stateflow](), [unit-testing](), [viewmodel]() ### AI overview A practical guide to choosing between StateFlow and SharedFlow in Android ViewModels. It covers lifecycle-aware collection, exposing flows as UI state in view-based apps and Compose, and unit testing ViewModels that convert flows into state or shared events. ### Source excerpt Collecting State and Shared Flows from ViewModels while respecting lifecycle of the collector views ## Smarter Shared Kotlin Flows DevFeed: [Smarter Shared Kotlin Flows]() Original publisher: [Read original article]() Author: Christophe Beyls Published: 2022-06-06T16:44:02Z Content type: tutorial Language: en Sources: [Stories by Christophe Beyls on Medium]() Topics: [kotlin-flow](), [Kotlin](), [Android]() Tags: [android](), [android-app-development](), [androiddev](), [database](), [efficiency](), [flow](), [kotlin](), [kotlin-flow](), [livedata](), [sharedflow]() ### AI overview This second article in a Kotlin Flow on Android series explains how SharedFlow and StateFlow using SharingStarted.WhileSubscribed() can restart upstream work when a lifecycle becomes active again. It compares this behavior with lifecycle-aware LiveData and proposes designing a Flow operator that propagates lifecycle state upstream to avoid unnecessary network requests or database queries. ### Source excerpt Make the lifecycle available to the upstream Flow to skip unnecessary work This is the second part of a series of articles about using Kotlin Flow on Android. In the first part, we described the main limitation of Kotlin Flow when used inside ViewModel classes: When a SharedFlow or StateFlow using the SharingStarted.WhileSubscribed() strategy is collected again after the user navigates back to an Activity or Fragment, its source upstream Flow will always restart from scratch, sometimes resulting in unnecessary work being performed when the previously cached data was still valid. val results: StateFlow = queryFlow.mapLatest { query -> repository.search(query) }.stateIn( scope = viewModelScope, started = SharingStarted.WhileSubscribed(5000L), initialValue = SearchResult.EMPTY ) In the above example, repository.search() will be executed again even if the latest value of queryFlow didn't change in the meantime. This means a potential unnecessary network request or database query. LiveData doesn't suffer from this issue because its observers don't need to unsubscribe when they become inactive: LiveData is lifecycle-aware and will postpone the delivery of new results until it becomes active, while also ensuring that the same result will never be delivered to the same observer twice (even when it becomes active again). For more details I invite you to read the full article. At the end of this first part, we concluded that there was no simple and correct way to avoid performing this unnecessary work when relying only on the standard shareIn() or stateIn() operators. In this second part, we are going to solve that efficiency problem by designing a new Flow operator that will allow SharedFlows to integrate better with the lifecycle. Synchronizing with the LifecycleLiveData The core reason why LiveData deals with lifecycles better than Flow is because the lifecycle state is automatically propagated upstream through all the LiveData instances so they can all pause ## Kotlin Flow Notes: Producers, Consumers, Operators, and Hot and Cold Flows DevFeed: [Kotlin Flow Notes: Producers, Consumers, Operators, and Hot and Cold Flows]() Original publisher: [Read original article]() Published: 2022-04-27T16:16:06Z Content type: tutorial Language: en Sources: [maiatoday]() Topics: [kotlin-flow](), [Kotlin](), [Coroutines](), [Large Screen](), [Streams]() Tags: [android](), [article](), [asynchronous](), [cheat-sheet](), [code](), [coroutine](), [coroutines](), [coroutines-flow](), [flow](), [kotlin](), [kotlin-coroutines](), [kotlin-flow](), [sharedflow](), [sketch-note](), [stateflow](), [streams]() ### AI overview A set of companion sketch notes about Kotlin Flow, covering suspend functions, streams of multiple values, producers and consumers, terminal and transform operators, execution contexts, hot and cold flows, and Android usage. ### Source excerpt This post is my companion sketch notes for all the resources I consumed on the topic of flows. It is not meant to replace the info that I found on the internet but rather supplement it. Nor is it complete or should it be a standalone guide. In fact you can find an excellent list of my favourite resources at the end of the article. It is a document that helps me make sense of the topic. With that disclaimer out of the way... Let's take a step back and look at the suspend function. If your coroutine knowledge is rusty, freshen that up first. What if we want to provide multiple values? A stream of values that can be observed? Enter flows. At their most basic, flows have a producer and a consumer. The interface looks like this (spoiler it's just suspend functions under the hood) The consumer gets the multiple values by using a terminal operator. If I need to change the produced values along the way before consuming them, there are transform operators. How do I switch from main to io context? What's with the hot and cold flows? How do I remember which is which? Some practical hot flows. Flows on Android References Kotlin Coroutines Flow in a nutshell Kotlin Flows ~ an Android cheat sheet Kotlin Flows in Android summary Android flow Asynchronous Flow | Kotlin Flow under the hood: how does it really work KotlinConf 2019: Asynchronous Data Streams with Kotlin Flow by Roman Elizarov Kotlin Flows in a Nutshell FlowMarbles Android StateFlow and SharedFlow If you are reading this far I will reward you with an Android portait. ## SharedFlow and StateFlow DevFeed: [SharedFlow and StateFlow]() Original publisher: [Read original article]() Published: 2022-02-21T00:00:00Z Content type: tutorial Language: en Sources: [Kt. Academy]() Topics: [Coroutines](), [Kotlin](), [Android](), [RxJava]() Tags: [channel](), [coroutines](), [flow](), [interfaces](), [kotlin](), [livedata](), [rxjava](), [scope](), [sharedflow](), [stateflow](), [value](), [values](), [workshop-learning-programming]() ### AI overview A tutorial explaining Kotlin's SharedFlow and StateFlow for broadcasting and observing values among multiple coroutines. It covers replayed values, cancellation, interfaces for collecting and emitting, and converting a Flow with shareIn. ### Source excerpt Known as a replacement for Subject, LiveData, and many more. SharedFlow and StateFlow are powerful coroutines classes, every Kotlin developer should know. ## Converting LiveData to Flow: More lessons learned DevFeed: [Converting LiveData to Flow: More lessons learned]() Original publisher: [Read original article]() Author: Chao Zhang Published: 2021-06-23T06:52:18Z Content type: tutorial Language: en Sources: [Stories by Chao Zhang on Medium]() Topics: [kotlin-coroutines](), [Kotlin](), [Android](), [test]() Tags: [android](), [android-app-development](), [androiddev](), [cancellation](), [coroutine](), [coroutines](), [flow](), [kotlin](), [kotlin-coroutines](), [livedata](), [sharedflow](), [stateflow](), [unit-tests]() ### AI overview This continuation explains lessons from converting between Kotlin Flow and LiveData in Android. It covers unfinished hot-flow coroutines during unit tests, why asLiveData cancellation occurs after a timeout on Dispatchers.Main, and how values are replayed when LiveData becomes active again. ### Source excerpt Photo: Buzz Andersen from Unsplash Android KTX provides opinionated methods facilitating using Kotlin Coroutines in Android Architecture Components. For instance, Flow.asLiveData() is quite helpful to migrate your apps using LiveData towards coroutine. Make sure to understand their behaviors underneath before using them! This story is a continuation of the previous one. Lesson III: Unfinished coroutines during unit testshttps://medium.com/media/41979239402051494c1002bb4d9e57dc/href When converting from Flow to LiveData, the source stream might be a hot StateFlow like above. Running the test will actually end up with the following error: kotlinx.coroutines.test.UncompletedCoroutinesError: Unfinished coroutines during teardown. Ensure all coroutines are completed or cancelled by your test. We know a hot Flow like SharedFlow never completes, so this error appears reasonable. A common way to test hot flow is to cancel the coroutine that the hot flow is executed on. In this case, we may want to pass a custom coroutineContext to asLiveData(context = ...)and cancel the job when the assertions are done: https://medium.com/media/129968c37bf50ac019a25755e3c56411/href However, it does not work! Let's take a step back and consult the documentation of Flow.asLiveData : If the LiveData becomes inactive (LiveData.onInactive) while the flow has not completed, the flow collection will be cancelled after timeoutInMs milliseconds unless the LiveData becomes active again before that timeout (to gracefully handle cases like Activity rotation). Since we are converting a hot flow to LiveData, we will always meet the condition. The flow collection will be canceled after timeoutInMs (default is 5 seconds). After digging it a bit more into the source code, we find that the cancellation is implemented as a delay() call on Dispatchers.Main : https://medium.com/media/154954407331c372f002028c8353a843/href The reason why cancel()runs on Dispatchers.Main is because it is invoked byLiveData.onI