ferazog

class ViewModelFactory @Inject constructor(
    private val viewModelsMap: Map<Class<out ViewModel>, @JvmSuppressWildcards Provider<ViewModel>>
) : ViewModelProvider.Factory {

    override fun <T : ViewModel?> create(modelClass: Class<T>): T {
        val creator = viewModelsMap[modelClass] ?: viewModelsMap.asIterable().firstOrNull {
            modelClass.isAssignableFrom(it.key)
        }?.value ?: throw IllegalArgumentException("unknown model class $modelClass")

        try {

ferazog

fun main() {
    val coroutineExceptionHandler = CoroutineExceptionHandler { context, error ->
        // Cuando una excepción ocurra este bloque de código será llamado    
        println("Ocurrió un error :( $error")
    }

    // Creación de un contexto usando el pool de hilos IO,
    // incluye un manejador de errores personalizado y
    val miContextPersonalizado: CoroutineContext = Dispatchers.IO + coroutineExceptionHandler

ferazog

fun main() {
    with(GlobalScope) {
        launch(Dispatchers.IO) { // Establece que la coroutine se ejecute en un hilo de IO
            // ...
        } 
        
        GlobalScope.launch(Dispatchers.Main) { // Establece que la coroutine se ejecute en el UI Thread 
            // ...
        }
    }

ferazog

fun ejecutar() {
  // Obteniendo el usuario y la ciudad de forma asíncrona
  val promesaDeUsuario = obtenerUsuarioDeRed()
  val promesaDeCiudad = obtenerCiudadDeRed()
  
  GlobalScope.launch { // creando un coroutine para poder ejecutar await()
    println("hola ${promesaDeUsuario.await()} desde ${promesaDeCiudad.await()}")
  }
  
  Thread.sleep(1_500) // Espera pero menos de dos segundos, tiempo suficiente para que ambos llamados a red se completen

ferazog

fun ejecutarCoroutine() {
  GlobalScope.launch() {
    val user = obtenerUsuarioDesdeRed()
  }
  Thread.sleep(1_000)
}

// Retorna un Usuario modelado es este ejemplo por un String
suspend fun obtenerUsuarioDesdeRed(): String { // Usa la palabra clave suspend para soportar funciones suspendidas
  delay(500) // La función delay es soportada, en caso contrario se mostraría un error en tiempo de codificación 

ferazog

fun ejecutarCoroutine() {
  GlobalScope.launch {
    delay(1_000) // Realiza una pausa en la ejecución de un segundo
    println("fin de la coroutine")
  }
  Thread.sleep(2_000) // Debido al delay de un segundo, la brecha de espera aumenta a dos segundos
}

ferazog

fun ejecutarCoroutine() {
  val jobPadre = GlobalScope.launch {
    while(isActive) {
      println("hola desde la coroutine padre")
    }
  }
  
  GlobalScope.launch(jobPadre) { // Pasando a la coroutine la referencia al job padre
    while(isActive) {
      println("hola desde la coroutine hija")

ferazog

fun ejecutarCoroutine() {
    println("iniciando coroutine")
    GlobalScope.launch {
        /*
        launch es una extensión que permite ejecutar una coroutine,
        en este caso dentro del scope GlobalScope
        */
        println("hola mundo desde una coroutine")
    }
    Thread.sleep(1_000) // El sleep permite una brecha de tiempo para que la coroutine termine su trabajo