RBusarow

object Dispatchers {  
    val Default: CoroutineDispatcher = createDefaultDispatcher()  
    val Main: MainCoroutineDispatcher get() = MainDispatcherLoader.dispatcher  
    val Unconfined: CoroutineDispatcher = kotlinx.coroutines.Unconfined  
    val IO: CoroutineDispatcher = DefaultScheduler.IO  
} 

RBusarow

@Module  
object CoroutineScopeModule {  

  @Provides  
  fun provideDefaultCoroutineScope(): DefaultCoroutineScope = DefaultCoroutineScope()  
  
  @Provides  
  fun provideIOCoroutineScope(): IOCoroutineScope = IOCoroutineScope()  
  
  @Provides  

RBusarow

@Suppress("UNCHECKED_CAST")
class MutableLiveData2<T>(value: T) : LiveData<T>(value) {

  override fun getValue(): T = super.getValue() as T
  public override fun setValue(value: T) = super.setValue(value)
  public override fun postValue(value: T) = super.postValue(value)
}

RBusarow

package androidx.lifecycle;

public class MutableLiveData<T> extends LiveData<T> {
  ...

  @Override
  public void setValue(T value) {
    super.setValue(value);
  }
}

RBusarow

val someLiveData = MutableLiveData<String>()

// this compiles!!
someLiveData.value = null

RBusarow

package androidx.lifecycle;

@Nullable
public T getValue() {
  Object data = mData;
  if (data != NOT_SET) {
    return (T) data;
  }
  return null;
}

RBusarow

val someLiveData = MutableLiveData<String>()

val currentValue = someLiveData.value

println(currentValue)  // null

RBusarow

val someLiveData : LiveData<String> = ...

viewModel.someLiveData.observe(this) { someString: String ->
                                      
  // the value from this lambda is inferred as non-nullable
  stringWhichIsNotNull = message
}

RBusarow

val someLiveData : LiveData<String> = ...

someLiveData.observe(this, Observer { someString: String? ->

  // the value from the callback is always nullable
  stringWhichIsNotNull = someString ?: "placeholder message"
}

RBusarow

import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.channels.BroadcastChannel
import kotlinx.coroutines.flow.*
import kotlinx.coroutines.sync.Mutex
import kotlinx.coroutines.sync.withLock

fun <T> Flow<T>.shareIn(
        scope: CoroutineScope
): Flow<T> = SharedFlow(
        BroadcastManager(