Add some more playground files

Author: LukasLechnerDev

app/src/main/java/com/lukaslechner/coroutineusecasesonandroid/playground/channels/1-ChannelBasics.kt

@@ -0,0 +1,28 @@
+package com.lukaslechner.coroutineusecasesonandroid.playground.channels
+
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.GlobalScope
+import kotlinx.coroutines.channels.consumeEach
+import kotlinx.coroutines.channels.produce
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
+import kotlin.random.Random
+
+
+fun main() {
+    GlobalScope.launch {
+        produceRandom().consumeEach { println(it) }
+        println("All values consumed")
+    }
+
+    println("main() finished")
+    Thread.sleep(1000)
+}
+
+// whereas flow() is a top level function => produce is defined on CoroutineScope
+private fun CoroutineScope.produceRandom() = produce {
+    repeat(5) {
+        delay(100)
+        send(Random.nextInt())
+    }
+}

app/src/main/java/com/lukaslechner/coroutineusecasesonandroid/playground/channels/2-Offer.kt

@@ -0,0 +1,33 @@
+package com.lukaslechner.coroutineusecasesonandroid.playground.channels
+
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.channels.consumeEach
+import kotlinx.coroutines.channels.produce
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.runBlocking
+import kotlin.random.Random
+
+fun main() = runBlocking {
+
+    val getRandomIntsChannel = generateRandom()
+
+    delay(500)
+
+    getRandomIntsChannel.consumeEach {
+        // with offer, we will only consume 5-6 offered items
+        println("Random number $it consumed")
+    }
+
+    println("Done!")
+}
+
+// Return Type is ReceiveChannel
+private fun CoroutineScope.generateRandom() = produce {
+    repeat(10) {
+        delay(100)
+
+        // emit in flows or send in channels will suspend until someone can receive the item
+        // send(Random.nextInt())
+        offer(Random.nextInt())
+    }
+}

app/src/main/java/com/lukaslechner/coroutineusecasesonandroid/playground/channels/3-Channel().kt

@@ -0,0 +1,31 @@
+package com.lukaslechner.coroutineusecasesonandroid.playground.channels
+
+import kotlinx.coroutines.*
+import kotlinx.coroutines.channels.Channel
+import kotlinx.coroutines.channels.consumeEach
+import kotlin.random.Random
+
+
+fun main() = runBlocking {
+
+    // Buffer of a default size of 64 elements
+    val channel = Channel<Int>(Channel.BUFFERED)
+
+    val job1 = GlobalScope.launch(Dispatchers.Default) {
+        repeat(3) {
+            delay(500)
+            channel.send(Random.nextInt(1, 100))
+        }
+
+        channel.close()
+    }
+
+    val job2 = GlobalScope.launch() {
+        channel.consumeEach {
+            println(it)
+            println("Consumed")
+        }
+    }
+
+    joinAll(job1, job2)
+}

app/src/main/java/com/lukaslechner/coroutineusecasesonandroid/playground/flow/1-Simple-Flows.kt

@@ -10,13 +10,16 @@ import kotlinx.coroutines.runBlocking
 // Sequence for synchronously computed values
 // Flow for asynchronously computed values
 
+// flow() sets up a coroutine for you to use, so you do not need to worry about doing that yourself
 private fun simple(): Flow<Int> = flow { // flow builder
     for (i in 1..3) {
         delay(100) // pretend we are doing something useful here
         emit(i) // emit next value
     }
 }
 
+// when you exit the lambda expression, the flow is considered to be closed.
+
 fun main() = runBlocking<Unit> {
     // Launch a concurrent coroutine to check if the main thread is blocked
     launch {

app/src/main/java/com/lukaslechner/coroutineusecasesonandroid/playground/flow/12-FlowOn-operator.kt

@@ -19,6 +19,12 @@ private fun simple(): Flow<Int> = flow {
 
 // flowOn creates another coroutine for an upstream flow when it has to change the CoroutineDispatcher in its context
 
+// Notice how flow{} works in the background thread, while collection happens in the main thread.
+
+// Another thing to observe here is that the flowOn operator has changed the default sequential nature of the flow.
+// Now, collection happens in one coroutine, and emission happens in another coroutine that is running in another thread concurrently with
+// the collecting coroutine
+
 fun main() = runBlocking<Unit> {
     simple().collect { value ->
         log("Collected $value")

app/src/main/java/com/lukaslechner/coroutineusecasesonandroid/playground/flow/7-Size-limiting-operators.kt

@@ -12,6 +12,8 @@ fun numbers(): Flow<Int> = flow {
         emit(2)
         println("This line will not execute")
         emit(3)
+    } catch (e: Exception) {
+        println(e) // kotlinx.coroutines.flow.internal.AbortFlowException: Flow was aborted, no more elements needed
     } finally {
         println("Finally in numbers")
     }

app/src/main/java/com/lukaslechner/coroutineusecasesonandroid/playground/flow/8-Terminal-flow-operators.kt

@@ -5,7 +5,9 @@ import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.flow.reduce
 import kotlinx.coroutines.runBlocking
 
-
+/**
+ * All terminal operators are suspend functions
+ */
 fun main() = runBlocking {
     val sum = (1..5).asFlow()
         .map { it * it } // squares of numbers from 1 to 5
@@ -14,6 +16,7 @@ fun main() = runBlocking {
 }
 
 // Other Terminal operators
-// * toList(), toSet()
-// * first()
-// * reduce(), flow
+// * toList(), toSet() => collects all of the objects emitted by the Flow and returns them in a List or a Set; works for bounded flows, but not for flows that emit object indefinitely
+// * reduce(), flow
+// * single() => returns first object emitted by the Flow, throws exception if more items are emmited
+// * first() => returns one object of the flow and then stops consuming; safe to use with a Flow that might return more than one value

app/src/main/java/com/lukaslechner/coroutineusecasesonandroid/playground/flow/exceptionhandling/X-Exception-Handling-LaunchIn.kt

@@ -0,0 +1,34 @@
+package com.lukaslechner.coroutineusecasesonandroid.playground.flow.exceptionhandling
+
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.flow.flow
+import kotlinx.coroutines.flow.launchIn
+import kotlinx.coroutines.flow.onEach
+import kotlinx.coroutines.runBlocking
+
+fun main() = runBlocking<Unit> {
+
+    val someScope = CoroutineScope(Dispatchers.Default)
+
+    var job: Job? = null
+
+    try {
+        job = someFlow.onEach {
+            println("onEach: $it")
+        }.launchIn(someScope)
+    } catch (exception: Exception) {
+        println("Caught: $exception")
+    }
+
+    // launchIn creates a new coroutine, so we can't use try-catch to handle exceptions
+
+    job?.join()
+}
+
+private val someFlow = flow<Int> {
+    emit(1)
+    emit(2)
+    throw IllegalStateException()
+}

app/src/main/java/com/lukaslechner/coroutineusecasesonandroid/playground/flow/operators/1-Sample.kt

@@ -0,0 +1,24 @@
+package com.lukaslechner.coroutineusecasesonandroid.playground.flow.operators
+
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.collect
+import kotlinx.coroutines.flow.flow
+import kotlinx.coroutines.flow.sample
+import kotlinx.coroutines.runBlocking
+
+private val fastEmittingFlow = flow {
+    repeat(10) {
+        emit(it)
+        delay(110)
+    }
+}
+
+fun main() = runBlocking {
+    fastEmittingFlow.sample(200).collect {
+        println("$it")
+    }
+
+    // Returns a flow that emits only the latest value emitted by the original flow during the given sampling period.
+
+    // prints: 1,3,5,6,7
+}

app/src/main/java/com/lukaslechner/coroutineusecasesonandroid/playground/flow/retry/1-SimpleRetry.kt

@@ -0,0 +1,25 @@
+package com.lukaslechner.coroutineusecasesonandroid.playground.flow.retry
+
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.collect
+import kotlinx.coroutines.flow.flow
+import kotlinx.coroutines.flow.retry
+import kotlinx.coroutines.runBlocking
+import kotlin.random.Random
+
+fun main() = runBlocking {
+    getRandom()
+        .retry(3)
+        .collect {
+            // 4 emissions, 1 initial and 3 retries
+            println("Collected: $it")
+        }
+}
+
+private fun getRandom() = flow {
+    repeat(3) {
+        delay(100)
+        emit(Random.nextInt())
+        check(it < 0)
+    }
+}