Что возвращает launch?

Launch - запуск корутин

launch - это функция, которая запускает новую корутину и возвращает объект Job. Это одна из самых частых функций при работе с coroutines в Kotlin.

Синтаксис

val job: Job = viewModelScope.launch {
    // код корутины
    val data = loadData()
    updateUI(data)
}

// Job - это результат запуска корутины

Что возвращает launch

launch возвращает объект типа Job:

fun launch(
    context: CoroutineContext = EmptyCoroutineContext,
    start: CoroutineStart = CoroutineStart.DEFAULT,
    block: suspend () -> Unit
): Job

// Возвращаемое значение Job
val job = viewModelScope.launch {
    delay(1000)
    println("Done")
}

println(job)  // Job(coroutine#1)
println(job.isActive)  // true

Что такое Job?

Job - это объект, который представляет запущенную корутину. Через Job можно:

• Отменить корутину
• Проверить статус (active, completed)
• Дождаться завершения
• Обработать исключения

data class Job {
    // Отмена корутины
    fun cancel()
    
    // Статус
    val isActive: Boolean
    val isCompleted: Boolean
    val isCancelled: Boolean
    
    // Ожидание завершения
    suspend fun join()
    
    // Обработка завершения
    fun invokeOnCompletion(handler: (cause: Throwable?) -> Unit)
}

Примеры использования Job

1. Отмена корутины

val job = viewModelScope.launch {
    repeat(100) { i ->
        println("Iteration $i")
        delay(1000)
    }
}

// Позже отменяем
job.cancel()
// Корутина сразу остановится

2. Ожидание завершения

val job = viewModelScope.launch {
    val data = loadDataFromNetwork()
    updateUI(data)
}

// Ждём завершения (только в другой корутине)
launch {
    job.join()  // ждёт пока job завершится
    println("Job completed")
}

3. Проверка статуса

val job = viewModelScope.launch {
    delay(5000)
}

println(job.isActive)  // true
println(job.isCompleted)  // false

job.join()

println(job.isActive)  // false
println(job.isCompleted)  // true

4. Обработка завершения

val job = viewModelScope.launch {
    try {
        val data = loadData()
        updateUI(data)
    } catch (e: Exception) {
        showError(e.message)
    }
}

job.invokeOnCompletion { cause ->
    if (cause == null) {
        println("Job completed successfully")
    } else {
        println("Job failed: ${cause.message}")
    }
}

Launch vs Async

// launch - не возвращает результат
val job: Job = viewModelScope.launch {
    val data = loadData()
    updateUI(data)  // результат обрабатываем внутри
}

// async - возвращает результат через await()
val deferred: Deferred<String> = viewModelScope.async {
    return@async loadData()
}

launch {
    val result = deferred.await()  // получаем результат
    updateUI(result)
}

Практические примеры

1. Загрузка данных в ViewModel

class UserViewModel : ViewModel() {
    private val _user = MutableLiveData<User?>()
    val user: LiveData<User?> = _user
    
    fun loadUser(id: Int) {
        viewModelScope.launch {
            try {
                val userData = repository.getUser(id)
                _user.value = userData
            } catch (e: Exception) {
                _user.value = null
            }
        }
    }
    
    // Job автоматически отменяется когда ViewModel очищается
}

2. Отмена при уничтожении Activity

class MainActivity : AppCompatActivity() {
    private var searchJob: Job? = null
    
    fun searchUsers(query: String) {
        searchJob?.cancel()  // отменяем старый поиск
        
        searchJob = viewModelScope.launch {
            val results = repository.search(query)
            displayResults(results)
        }
    }
    
    override fun onDestroy() {
        super.onDestroy()
        searchJob?.cancel()  // отменяем при уничтожении
    }
}

3. Параллельная работа с несколькими Job

launch {
    val job1 = launch {
        loadUserData()
    }
    
    val job2 = launch {
        loadSettings()
    }
    
    job1.join()  // ждём первую
    job2.join()  // ждём вторую
    
    updateUI()  // обновляем когда обе завершены
}

4. Контроль жизненного цикла

class MyService : Service() {
    private val jobs = mutableListOf<Job>()
    
    fun startWork() {
        val job = lifecycleScope.launch {
            while (isActive) {  // продолжаем пока корутина активна
                doWork()
                delay(1000)
            }
        }
        jobs.add(job)
    }
    
    override fun onDestroy() {
        super.onDestroy()
 n        jobs.forEach { it.cancel() }  // отменяем все
    }
}

5. Обработка исключений в Job

val job = viewModelScope.launch {
    try {
        val data = loadData()
        updateUI(data)
    } catch (e: IOException) {
        showNetworkError()
    } catch (e: Exception) {
        showGenericError(e)
    }
}

job.invokeOnCompletion { exception ->
    if (exception != null) {
        Log.e("Job", "Error: ", exception)
    }
}

Job иерархия (Parent-Child)

// viewModelScope имеет Job
val parentJob = viewModelScope.coroutineContext[Job]!!

val childJob = viewModelScope.launch {
    println("Child job")
}

// Если отменить родителя, отменятся все дети
parentJob.cancel()  // отменяет все launch в viewModelScope

Вывод

launch возвращает Job - объект для управления корутиной:

• cancel() - отмена
• isActive - проверка активности
• join() - ожидание завершения
• invokeOnCompletion() - обработка завершения

Job - это главный способ контролировать жизненный цикл корутин в Android.