https://github.com/iamjosephmj/kotlin-flows

https://github.com/iamjosephmj/kotlin-flows

Last synced: 1 day ago
JSON representation

• Host: GitHub
• URL: https://github.com/iamjosephmj/kotlin-flows
• Owner: iamjosephmj
• License: mit
• Created: 2021-08-08T18:21:11.000Z (over 3 years ago)
• Default Branch: main
• Last Pushed: 2021-08-08T21:46:04.000Z (over 3 years ago)
• Last Synced: 2024-01-18T13:27:21.807Z (10 months ago)
• Language: Kotlin
• Size: 4.05 MB
• Stars: 0
• Watchers: 1
• Forks: 0
• Open Issues: 0
• Metadata Files:
  • Readme: README.md
  • License: LICENSE

Awesome Lists containing this project

README

        
# Kotlin-Flows



Kotlin Flow is a new Stream API from the team of jetbrains. This has similarities to 

Livedata and RxJava. They are all a way to utilize the observer pattern in your kotlin code. 

In terms of both complexity and power you can think of kotlin flow is falling somewhere in between 

LiveData and RxJava, In fact Flow looks much more like RxJava APIs containing streams of items that can 

be manipulated by operators as they are processed in the stream. In time, Kotlin Flow may come to rival 

RxJava as the go-to concurrency approach on Android and JVM systems.





A key aspect of Kotlin Flow is that it is build on top of Kotlin Coroutines. The effort that you 

put on learning the concepts and nuance of coroutines will pay off as you are working with flow. 

Coroutines allow you to write asynchronous code in a way that looks very much like normal synchronous code, and

without the need of writing your own thread, or litter your code with callbacks. 

One of the goals of Flow is to provide structural concurrency in your asynchronous code. With 

structured concurrency, you define coroutines within a given scope that may have the limited lifetime and not 

in a global scope.







If the scope the coroutines are running in ends its lifecycle. The coroutines are automatically 

cleaned up, even if they are not finished running. Flows share the same cancellable properties as 

coroutines, and so you don't need to dispose them as you do with RxJava. You can think of Kotlin main.flows as a:




Flow = Cold, asynchronous stream




because it is running within a coroutine. Flows are cold because it does not start the stream until 

it is observed, witch is called collection for a flow. If you are familiar with RxJava, this will be much simpler. 

Here is the link to my repo if you are not familiar with Rx -> [link](https://github.com/iamjosephmj/learn-rx).

Please get an understanding about [marble diagrams](https://rxmarbles.com/) before you start learning Flows