Android में Kotlin Coroutines

import kotlinx.coroutines.*

suspend fun loadNotes(): List<String> {
    delay(1000)                       // pretend database / network work
    return listOf("Maths homework", "Physics notes")
}

fun main() = runBlocking {
    println("1. Start (thread: main)")
    val job = launch {
        val notes = loadNotes()       // suspends, does NOT block the thread
        println("3. Loaded ${notes.size} notes")
    }
    println("2. UI is still free while loading…")
    job.join()
    println("4. Done")
}

import kotlinx.coroutines.*
import kotlin.system.measureTimeMillis

suspend fun getProfile(): String { delay(1000); return "Riya" }
suspend fun getMarks(): Int { delay(1000); return 92 }

fun main() = runBlocking {
    val sequential = measureTimeMillis {
        val p = getProfile(); val m = getMarks()
        println("Sequential: $p $m")
    }
    val parallel = measureTimeMillis {
        val p = async { getProfile() }
        val m = async { getMarks() }
        println("Parallel: ${p.await()} ${m.await()}")
    }
    println("sequential ≈ ${sequential / 1000}s, parallel ≈ ${parallel / 1000}s")
}

import kotlinx.coroutines.*

fun main() = runBlocking {
    val result = withContext(Dispatchers.Default) {     // heavy CPU work off the main thread
        (1..1_000_000).sumOf { it.toLong() }
    }
    println("Sum = $result")

    try {
        withTimeout(500) { delay(2000); println("never printed") }
    } catch (e: TimeoutCancellationException) {
        println("Timed out after 500 ms")
    }

    val job = launch { repeat(10) { i -> println("tick $i"); delay(300) } }
    delay(700)
    job.cancel()                                      // like leaving the screen
    println("Cancelled: ${job.isCancelled}")
}

// ViewModel – cancelled automatically when the ViewModel is cleared
class NoteViewModel(app: Application) : AndroidViewModel(app) {
    fun save(note: Note) = viewModelScope.launch {
        repo.save(note)                 // Room suspend function
    }
}

// Fragment / Activity – cancelled when the lifecycle is destroyed
viewLifecycleOwner.lifecycleScope.launch {
    val note = viewModel.getNote(id)    // suspend
    binding.etTitle.setText(note?.title)
}

// Collect a Flow only while the screen is visible
viewLifecycleOwner.lifecycleScope.launch {
    viewLifecycleOwner.repeatOnLifecycle(Lifecycle.State.STARTED) {
        viewModel.results.collect { adapter.submitList(it) }
    }
}

viewModelScope.launch {
    _tip.value = TipState.Loading
    _tip.value = try {
        val tips = TipsApi.service.getTips().tips          // may throw IOException / HttpException
        TipState.Success(tips.random())
    } catch (e: Exception) {
        TipState.Error(e.message ?: "Network error")
    }
}

// AddEditNoteFragment – copy the picked photo on a background thread
private fun copyImage(uri: Uri) {
    viewLifecycleOwner.lifecycleScope.launch {
        val path = withContext(Dispatchers.IO) {                 // file work → IO thread
            ImageStore.copyToAppStorage(requireContext(), uri)
        }
        if (path == null) toast(R.string.image_error) else { imagePath = path; showImage() }  // back on Main
    }
}

// ReminderWorker – WorkManager's CoroutineWorker runs doWork() as a suspend function
override suspend fun doWork(): Result {
    val note = AppDatabase.get(applicationContext).noteDao().getById(noteId) ?: return Result.success()
    NotificationHelper.show(applicationContext, note.id, note.title, note.subject)
    return Result.success()
}