runBlockingTest

java.lang.IllegalStateException: This job has not completed yet

actor { }

value

StateFlow<Map<Id, T>>

T

String

onTextChanged(id, text)

map[id] = text

StateFlow

supervisorScope

fun simpleChannelTest() {
    val channel = Channel<String>(capacity = Channel.Factory.UNLIMITED)

    val backgroundProcessor = MainScope().launch {
        for (str in channel) {
            println("$str has been processed")
        }
    }

    runBlocking(Dispatchers.Default) {
        val producers = launch {
            repeat(100) {
                launch {
                    channel.send("str$it")
                }
            }
        }

        println("producers have been created")
        producers.join()
        println("producers have done their work")
        channel.close()
        println("channel has been closed")
        backgroundProcessor.join() // ********************* I"M STUCK HERE
        println("backgroundProcessor coroutine has done its job") // ***************** UNREACHABLE
    }

class Store {
  private val channel = Channel<Action>()

  suspend func dispatch(action: Action) {
    channel.send(action)
  }

  init {
    GlobalScope.launch {
      for (action in channel) {
        reduce(action)
        notifyObservers()
      }
    }
  }
}

notifyObservers

Props

ViewModel

override suspend fun getMovieDetails(movieId: Int): LiveData<MovieEntity> {
        GlobalScope.launch {
            async {
                try {
                    val movieData = mService.getMovieDetails(movieId)
                    mCache.updateMovie(movieData)
                    Rose.error("done") // *(2)*
                } catch (e: Exception) {
                    e.printStackTrace()
                }
            }

        }

        Rose.error("run first") // *(1)*
        return Transformations.map(mCache.getMovie(movieId)) {
            return@map MovieEntity(....)
        }
    }

yield()

yield

launch {
  try {
    myCoroutine() // throws exception when executed
  } catch (e: Exception) {
    println("caught $e")
  }
}

runCatching { myCoroutine() }.exceptionOrNull()?.let { println("caught $e") }

myCoroutine

continuation.resumeWithException()

try/catch

combineLatest

I am new to kotlin flows and trying to add Flows to one of my project and facing an issue while converting list of objects of one type to another as shown below. Basically, am not sure which operator to be used for this.

//Repository - method return type is  Flow<List<HistoryEvent>>
fun getHistoryEvents(): Flow<List<HistoryEvent>>

//ViewModel - calling repository method and trying to convert data to List<AccessoryEvent>

val accessoryEvents : LiveData<List<AccessoryEvent>>=  liveData{
                                                      repository.getHistoryEvents()
                                                       
                                                  // what operator to be used to convert from List<HistoryEvent> to List<AccessoryEvent>
                                                           
                                                        .collect()
                                                      }

native-mt

withTimeout(20000) {
    try{
        while (true) {
            // read input from socket and exit while block when exception is thrown 
            // or expected data has been received   
        }
    }catch(e: Exception) {
        // Handle the exception here
    }
}

val scope: CoroutineScope = CoroutineScope(Job() + <http://Dispatchers.IO|Dispatchers.IO>)
withTimeout(20000){
    suspendCancellableCoroutine<String>{ continuation ->

        continuation.invokeOnCancellation {
            // Handle my exception here
        }
        
        scope.launch {
            while (true) {
                // read input from socket and exit while block when exception is thrown 
                // or expected data has been received   
            }
        }
    }
}

CoroutineLiveData

ContinuationImpl

fun main() = runBlocking {
    repeat(50) {
        launch(<http://Dispatchers.IO|Dispatchers.IO>) {
            delay(5000L * it)
            println("Done $it")
        }
    }
}

every { presenter.scope } returns TestCoroutineScope()

Unresolved reference: newSingleThreadContext

viewModelScope.launch {
customerRepo.customer(customerUid) // Returns a `Flow<Customer>`
  .combine(controllerRepo.controllersForCustomer(customerUid)) { customer, controllers ->
    CustomerWithControllers(customer, controllers)
  }
  .collect { customerWithControllers ->
    internalState.value = State.Loaded(customerWithControllers)
  }
}

customer

controllers

CustomerWithControllers

customer

Flow

Job

launch

Job

Room

Empty