android-sdd 1.0.0

package/skills/Build System/Version Catalog/SKILL.md

@@ -0,0 +1,304 @@
+---
+name: version-catalog
+description: >
+  Gradle Version Catalog setup and usage for Android projects.
+  Load this skill when managing dependency versions centrally,
+  adding new dependencies, or organizing libs.versions.toml.
+---
+
+# Version Catalog
+
+## Overview
+Gradle Version Catalog (`libs.versions.toml`) is the standard way to centralize all dependency versions in one file. It provides type-safe accessors in build scripts, prevents version conflicts, and makes upgrades visible in a single diff.
+
+---
+
+## Core Principles
+
+- **All dependencies** go through Version Catalog — no inline versions anywhere
+- Group related libraries under the same version alias when possible
+- Use **bundles** for sets of dependencies that always go together
+- Keep `libs.versions.toml` the **single source of truth** for all versions
+- Separate **plugin versions** from library versions clearly
+
+---
+
+## File Structure
+
+```toml
+# gradle/libs.versions.toml
+
+[versions]
+# SDK
+android-compileSdk = "35"
+android-minSdk = "24"
+android-targetSdk = "35"
+
+# Core
+kotlin = "2.0.0"
+ksp = "2.0.0-1.0.21"
+agp = "8.7.0"
+
+# AndroidX
+androidx-core = "1.13.1"
+androidx-lifecycle = "2.8.6"
+androidx-navigation = "2.8.3"
+androidx-room = "2.6.1"
+androidx-datastore = "1.1.1"
+androidx-paging = "3.3.2"
+androidx-work = "2.9.1"
+
+# Compose
+compose-bom = "2024.10.01"
+compose-compiler = "1.5.14"
+
+# Network
+retrofit = "2.11.0"
+okhttp = "4.12.0"
+ktor = "2.3.12"
+
+# DI
+hilt = "2.51.1"
+hilt-navigation = "1.2.0"
+
+# Firebase
+firebase-bom = "33.5.1"
+google-services = "4.4.2"
+firebase-crashlytics-plugin = "3.0.2"
+
+# Serialization
+kotlinx-serialization = "1.7.3"
+kotlinx-coroutines = "1.9.0"
+
+# Media
+media3 = "1.4.0"
+camerax = "1.3.4"
+
+# Testing
+junit = "4.13.2"
+junit5 = "5.10.2"
+mockk = "1.13.12"
+turbine = "1.1.0"
+androidx-test-runner = "1.6.2"
+espresso = "3.6.1"
+
+# Quality
+detekt = "1.23.7"
+ktlint = "12.1.1"
+
+
+[libraries]
+# AndroidX Core
+androidx-core-ktx = { module = "androidx.core:core-ktx", version.ref = "androidx-core" }
+androidx-appcompat = { module = "androidx.appcompat:appcompat", version = "1.7.0" }
+androidx-activity-compose = { module = "androidx.activity:activity-compose", version = "1.9.2" }
+
+# Lifecycle
+androidx-lifecycle-viewmodel = { module = "androidx.lifecycle:lifecycle-viewmodel-ktx", version.ref = "androidx-lifecycle" }
+androidx-lifecycle-runtime = { module = "androidx.lifecycle:lifecycle-runtime-ktx", version.ref = "androidx-lifecycle" }
+androidx-lifecycle-runtime-compose = { module = "androidx.lifecycle:lifecycle-runtime-compose", version.ref = "androidx-lifecycle" }
+
+# Compose
+compose-bom = { module = "androidx.compose:compose-bom", version.ref = "compose-bom" }
+compose-ui = { module = "androidx.compose.ui:ui" }
+compose-ui-tooling = { module = "androidx.compose.ui:ui-tooling" }
+compose-ui-tooling-preview = { module = "androidx.compose.ui:ui-tooling-preview" }
+compose-foundation = { module = "androidx.compose.foundation:foundation" }
+compose-material3 = { module = "androidx.compose.material3:material3" }
+compose-material-icons = { module = "androidx.compose.material:material-icons-extended" }
+compose-ui-test-manifest = { module = "androidx.compose.ui:ui-test-manifest" }
+compose-ui-test-junit4 = { module = "androidx.compose.ui:ui-test-junit4" }
+
+# Navigation
+androidx-navigation-compose = { module = "androidx.navigation:navigation-compose", version.ref = "androidx-navigation" }
+
+# Room
+androidx-room-runtime = { module = "androidx.room:room-runtime", version.ref = "androidx-room" }
+androidx-room-ktx = { module = "androidx.room:room-ktx", version.ref = "androidx-room" }
+androidx-room-compiler = { module = "androidx.room:room-compiler", version.ref = "androidx-room" }
+androidx-room-paging = { module = "androidx.room:room-paging", version.ref = "androidx-room" }
+androidx-room-testing = { module = "androidx.room:room-testing", version.ref = "androidx-room" }
+
+# DataStore
+androidx-datastore-preferences = { module = "androidx.datastore:datastore-preferences", version.ref = "androidx-datastore" }
+androidx-datastore-proto = { module = "androidx.datastore:datastore", version.ref = "androidx-datastore" }
+
+# Paging
+androidx-paging-runtime = { module = "androidx.paging:paging-runtime", version.ref = "androidx-paging" }
+androidx-paging-compose = { module = "androidx.paging:paging-compose", version.ref = "androidx-paging" }
+
+# WorkManager
+androidx-work-runtime = { module = "androidx.work:work-runtime-ktx", version.ref = "androidx-work" }
+androidx-work-hilt = { module = "androidx.hilt:hilt-work", version = "1.2.0" }
+androidx-work-testing = { module = "androidx.work:work-testing", version.ref = "androidx-work" }
+
+# Network
+retrofit = { module = "com.squareup.retrofit2:retrofit", version.ref = "retrofit" }
+retrofit-kotlinx-serialization = { module = "com.squareup.retrofit2:converter-kotlinx-serialization", version.ref = "retrofit" }
+okhttp = { module = "com.squareup.okhttp3:okhttp", version.ref = "okhttp" }
+okhttp-logging = { module = "com.squareup.okhttp3:logging-interceptor", version.ref = "okhttp" }
+ktor-client-core = { module = "io.ktor:ktor-client-core", version.ref = "ktor" }
+ktor-client-okhttp = { module = "io.ktor:ktor-client-okhttp", version.ref = "ktor" }
+ktor-client-content-negotiation = { module = "io.ktor:ktor-client-content-negotiation", version.ref = "ktor" }
+ktor-serialization-json = { module = "io.ktor:ktor-serialization-kotlinx-json", version.ref = "ktor" }
+
+# DI — Hilt
+hilt-android = { module = "com.google.dagger:hilt-android", version.ref = "hilt" }
+hilt-compiler = { module = "com.google.dagger:hilt-compiler", version.ref = "hilt" }
+hilt-navigation-compose = { module = "androidx.hilt:hilt-navigation-compose", version.ref = "hilt-navigation" }
+hilt-testing = { module = "com.google.dagger:hilt-android-testing", version.ref = "hilt" }
+
+# Serialization / Coroutines
+kotlinx-serialization-json = { module = "org.jetbrains.kotlinx:kotlinx-serialization-json", version.ref = "kotlinx-serialization" }
+kotlinx-coroutines-core = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-core", version.ref = "kotlinx-coroutines" }
+kotlinx-coroutines-android = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-android", version.ref = "kotlinx-coroutines" }
+kotlinx-coroutines-test = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-test", version.ref = "kotlinx-coroutines" }
+
+# Firebase
+firebase-bom = { module = "com.google.firebase:firebase-bom", version.ref = "firebase-bom" }
+firebase-analytics = { module = "com.google.firebase:firebase-analytics-ktx" }
+firebase-crashlytics = { module = "com.google.firebase:firebase-crashlytics-ktx" }
+firebase-messaging = { module = "com.google.firebase:firebase-messaging-ktx" }
+firebase-config = { module = "com.google.firebase:firebase-config-ktx" }
+firebase-auth = { module = "com.google.firebase:firebase-auth-ktx" }
+
+# Media
+media3-exoplayer = { module = "androidx.media3:media3-exoplayer", version.ref = "media3" }
+media3-exoplayer-hls = { module = "androidx.media3:media3-exoplayer-hls", version.ref = "media3" }
+media3-ui = { module = "androidx.media3:media3-ui", version.ref = "media3" }
+media3-session = { module = "androidx.media3:media3-session", version.ref = "media3" }
+camerax-core = { module = "androidx.camera:camera-core", version.ref = "camerax" }
+camerax-camera2 = { module = "androidx.camera:camera-camera2", version.ref = "camerax" }
+camerax-lifecycle = { module = "androidx.camera:camera-lifecycle", version.ref = "camerax" }
+camerax-video = { module = "androidx.camera:camera-video", version.ref = "camerax" }
+camerax-view = { module = "androidx.camera:camera-view", version.ref = "camerax" }
+
+# Security
+androidx-security-crypto = { module = "androidx.security:security-crypto", version = "1.1.0-alpha06" }
+
+# Testing
+junit = { module = "junit:junit", version.ref = "junit" }
+mockk = { module = "io.mockk:mockk", version.ref = "mockk" }
+mockk-android = { module = "io.mockk:mockk-android", version.ref = "mockk" }
+turbine = { module = "app.cash.turbine:turbine", version.ref = "turbine" }
+androidx-test-runner = { module = "androidx.test:runner", version.ref = "androidx-test-runner" }
+espresso-core = { module = "androidx.test.espresso:espresso-core", version.ref = "espresso" }
+androidx-junit = { module = "androidx.test.ext:junit", version = "1.2.1" }
+
+# Quality
+detekt-formatting = { module = "io.gitlab.arturbosch.detekt:detekt-formatting", version.ref = "detekt" }
+
+
+[bundles]
+# ✅ Bundles — groups of always-used-together dependencies
+compose = [
+    "compose-ui",
+    "compose-foundation",
+    "compose-material3",
+    "compose-ui-tooling-preview",
+    "compose-material-icons"
+]
+
+lifecycle = [
+    "androidx-lifecycle-viewmodel",
+    "androidx-lifecycle-runtime",
+    "androidx-lifecycle-runtime-compose"
+]
+
+room = [
+    "androidx-room-runtime",
+    "androidx-room-ktx"
+]
+
+network = [
+    "retrofit",
+    "retrofit-kotlinx-serialization",
+    "okhttp",
+    "okhttp-logging"
+]
+
+coroutines = [
+    "kotlinx-coroutines-core",
+    "kotlinx-coroutines-android"
+]
+
+testing-unit = [
+    "junit",
+    "mockk",
+    "kotlinx-coroutines-test",
+    "turbine"
+]
+
+testing-android = [
+    "androidx-test-runner",
+    "androidx-junit",
+    "espresso-core"
+]
+
+
+[plugins]
+android-application = { id = "com.android.application", version.ref = "agp" }
+android-library = { id = "com.android.library", version.ref = "agp" }
+kotlin-android = { id = "org.jetbrains.kotlin.android", version.ref = "kotlin" }
+kotlin-serialization = { id = "org.jetbrains.kotlin.plugin.serialization", version.ref = "kotlin" }
+kotlin-multiplatform = { id = "org.jetbrains.kotlin.multiplatform", version.ref = "kotlin" }
+compose-compiler = { id = "org.jetbrains.kotlin.plugin.compose", version.ref = "kotlin" }
+ksp = { id = "com.google.devtools.ksp", version.ref = "ksp" }
+hilt = { id = "com.google.dagger.hilt.android", version.ref = "hilt" }
+google-services = { id = "com.google.gms.google-services", version.ref = "google-services" }
+firebase-crashlytics = { id = "com.google.firebase.crashlytics", version.ref = "firebase-crashlytics-plugin" }
+detekt = { id = "io.gitlab.arturbosch.detekt", version.ref = "detekt" }
+ktlint = { id = "org.jlleitschuh.gradle.ktlint", version.ref = "ktlint" }
+```
+
+---
+
+## Using in build.gradle.kts
+
+```kotlin
+// ✅ Reference via type-safe accessors
+dependencies {
+    // Single library
+    implementation(libs.androidx.core.ktx)
+    implementation(libs.hilt.android)
+    ksp(libs.hilt.compiler)
+
+    // Bundle
+    implementation(libs.bundles.compose)
+    implementation(libs.bundles.room)
+    ksp(libs.androidx.room.compiler)
+
+    // BOM
+    implementation(platform(libs.firebase.bom))
+    implementation(libs.firebase.analytics)
+
+    // Test
+    testImplementation(libs.bundles.testing.unit)
+    androidTestImplementation(libs.bundles.testing.android)
+}
+
+plugins {
+    alias(libs.plugins.android.application)
+    alias(libs.plugins.kotlin.android)
+    alias(libs.plugins.hilt)
+    alias(libs.plugins.ksp)
+}
+```
+
+---
+
+## Anti-Patterns
+
+- Inline versions in `build.gradle.kts` — `implementation("com.example:lib:1.0.0")`
+- Duplicate version definitions across modules
+- Not using bundles for frequently co-used dependencies
+- Mixing BOM and explicit versions for same library group
+- Not keeping catalog alphabetically sorted — hard to find entries
+
+---
+
+## Related Skills
+- `gradle` — Gradle build configuration
+- `convention-plugin` — using catalog in shared build logic
+- `dependency-management` — resolving conflicts with catalog
+- `build-variant` — applying different deps per variant

package/skills/Concurrency/Background Processing/SKILL.md

@@ -0,0 +1,185 @@
+---
+name: background-processing
+description: >
+  Background processing strategies in Android.
+  Load this skill when choosing between WorkManager, coroutines, and
+  foreground services for background work, scheduling deferred tasks,
+  handling doze mode, or running work that must survive app death.
+---
+
+# Background Processing
+
+## Overview
+
+Android restricts background processing to preserve battery and memory. The correct tool depends on whether the work must survive app death, needs to be scheduled, or must run immediately. WorkManager is the standard for deferrable, guaranteed work. Coroutines handle in-process background work. Foreground Services handle long-running user-visible work.
+
+---
+
+## Core Principles
+
+- Use **WorkManager** for deferrable work that must survive app death or device restart
+- Use **coroutines** (`Dispatchers.IO`) for in-process background work tied to app lifetime
+- Use **ForegroundService** for long-running work that the user is aware of (music, upload)
+- Never use `AsyncTask`, `HandlerThread`, or bare `Thread` — use coroutines
+- Respect **Doze mode** — only WorkManager and ForegroundService work reliably in Doze
+
+---
+
+## Decision Matrix
+
+| Work Type                 | Survives App Death | User Visible | Use                        |
+| ------------------------- | ------------------ | ------------ | -------------------------- |
+| Short async (network, DB) | ❌                  | ❌            | Coroutine                  |
+| Deferred, guaranteed      | ✅                  | ❌            | WorkManager                |
+| Periodic background sync  | ✅                  | ❌            | WorkManager                |
+| Long-running, user-aware  | ✅                  | ✅            | ForegroundService          |
+| Immediate, in-process     | ❌                  | ❌            | Coroutine + Dispatchers.IO |
+
+---
+
+## WorkManager — Deferrable Work
+
+```kotlin
+// ✅ Define a Worker
+class SyncWorker(
+    context: Context,
+    params: WorkerParameters
+) : CoroutineWorker(context, params) {
+
+    override suspend fun doWork(): Result {
+        return try {
+            val userId = inputData.getString("user_id") ?: return Result.failure()
+            syncRepository.syncUser(userId)
+            Result.success()
+        } catch (e: Exception) {
+            if (runAttemptCount < 3) Result.retry()
+            else Result.failure()
+        }
+    }
+}
+
+// ✅ Schedule one-time work
+val request = OneTimeWorkRequestBuilder<SyncWorker>()
+    .setInputData(workDataOf("user_id" to userId))
+    .setConstraints(
+        Constraints.Builder()
+            .setRequiredNetworkType(NetworkType.CONNECTED)
+            .build()
+    )
+    .setBackoffCriteria(BackoffPolicy.EXPONENTIAL, 15, TimeUnit.MINUTES)
+    .build()
+
+WorkManager.getInstance(context).enqueueUniqueWork(
+    "sync_user_$userId",
+    ExistingWorkPolicy.KEEP,
+    request
+)
+
+// ✅ Schedule periodic work
+val periodicRequest = PeriodicWorkRequestBuilder<SyncWorker>(1, TimeUnit.HOURS)
+    .setConstraints(
+        Constraints.Builder()
+            .setRequiredNetworkType(NetworkType.CONNECTED)
+            .setRequiresBatteryNotLow(true)
+            .build()
+    )
+    .build()
+
+WorkManager.getInstance(context).enqueueUniquePeriodicWork(
+    "periodic_sync",
+    ExistingPeriodicWorkPolicy.KEEP,
+    periodicRequest
+)
+```
+
+---
+
+## Coroutine Background Work
+
+```kotlin
+// ✅ Short background work — in-process only
+class DataRepository @Inject constructor(
+    private val api: DataApi,
+    private val dao: DataDao
+) {
+    suspend fun refreshData() = withContext(Dispatchers.IO) {
+        val data = api.getData()
+        dao.insertAll(data)
+    }
+}
+
+// ✅ Long-running in-process work with custom scope
+@Singleton
+class PollingManager @Inject constructor(
+    private val repository: DataRepository
+) {
+    private val scope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
+
+    fun startPolling() {
+        scope.launch {
+            while (isActive) {
+                runCatching { repository.refreshData() }
+                delay(30_000)
+            }
+        }
+    }
+
+    fun stopPolling() = scope.cancel()
+}
+```
+
+---
+
+## Observing WorkManager Progress
+
+```kotlin
+// ✅ Observe work state in ViewModel
+class SyncViewModel @Inject constructor(
+    private val workManager: WorkManager
+) : ViewModel() {
+
+    val syncState: LiveData<WorkInfo> = workManager
+        .getWorkInfosForUniqueWorkLiveData("periodic_sync")
+        .map { workInfos -> workInfos.firstOrNull() }
+        .filterNotNull()
+
+    // Or as Flow
+    val syncStateFlow: Flow<WorkInfo?> = workManager
+        .getWorkInfosForUniqueWorkFlow("periodic_sync")
+        .map { it.firstOrNull() }
+}
+```
+
+---
+
+## Chaining Work
+
+```kotlin
+// ✅ Chain workers sequentially
+WorkManager.getInstance(context)
+    .beginUniqueWork("upload_chain", ExistingWorkPolicy.REPLACE,
+        OneTimeWorkRequestBuilder<CompressWorker>().build()
+    )
+    .then(OneTimeWorkRequestBuilder<UploadWorker>().build())
+    .then(OneTimeWorkRequestBuilder<NotifyWorker>().build())
+    .enqueue()
+```
+
+---
+
+## Anti-Patterns
+
+- Using `GlobalScope` for work that should survive — use WorkManager instead
+- Running network calls in a bare `Thread` — use coroutines with Dispatchers.IO
+- Using `AlarmManager` for periodic work — WorkManager handles this better
+- Starting a ForegroundService for short work — use WorkManager
+- Not setting constraints on WorkManager — work runs even on metered network or low battery
+
+---
+
+## Related Skills
+
+- `workmanager` — detailed WorkManager patterns
+- `foreground-service` — long-running user-visible work
+- `coroutine` — coroutine fundamentals and dispatcher selection
+- `structured-concurrency` — managing coroutine lifecycle

package/skills/Concurrency/Channel/SKILL.md

@@ -0,0 +1,207 @@
+---
+name: channel
+description: >
+  Kotlin Channel for guaranteed single-consumer message delivery in Android.
+  Load this skill when implementing one-time UI events with delivery guarantee,
+  building producer-consumer pipelines, handling work queues,
+  or choosing between Channel and SharedFlow for event delivery.
+---
+
+# Channel
+
+## Overview
+
+`Channel` is a coroutine primitive for communication between coroutines. Unlike `SharedFlow`, a `Channel` guarantees delivery to exactly one consumer and buffers messages when the consumer is not active. On Android, `Channel` is the preferred mechanism for one-time ViewModel events (navigation, toasts) where delivery must be guaranteed.
+
+---
+
+## Core Principles
+
+- Use `Channel` when delivery must be **guaranteed** — events must not be dropped or missed
+- Use `SharedFlow` when **broadcasting** to multiple collectors is needed
+- Always expose `Channel` as `receiveAsFlow()` — never expose the raw `Channel`
+- Use `Channel.BUFFERED` capacity — prevents suspension when collector is temporarily inactive
+- One `Channel` per event type, or a sealed class `Channel` for all events from one ViewModel
+
+---
+
+## Basic Channel for UI Events
+
+```kotlin
+// ✅ Standard ViewModel event channel
+class UserViewModel : ViewModel() {
+
+    private val _events = Channel<UserEvent>(Channel.BUFFERED)
+    val events: Flow<UserEvent> = _events.receiveAsFlow()
+
+    fun onSaveSuccess() {
+        viewModelScope.launch {
+            _events.send(UserEvent.NavigateBack)
+        }
+    }
+
+    fun onError(message: String) {
+        viewModelScope.launch {
+            _events.send(UserEvent.ShowSnackbar(message))
+        }
+    }
+}
+
+sealed interface UserEvent {
+    data object NavigateBack : UserEvent
+    data class ShowSnackbar(val message: String) : UserEvent
+    data class NavigateToDetail(val userId: String) : UserEvent
+}
+```
+
+---
+
+## Collecting in Compose
+
+```kotlin
+// ✅ Collect channel events in LaunchedEffect
+@Composable
+fun UserScreen(
+    onNavigateBack: () -> Unit,
+    onNavigateToDetail: (String) -> Unit,
+    viewModel: UserViewModel = hiltViewModel()
+) {
+    val snackbarHostState = remember { SnackbarHostState() }
+
+    LaunchedEffect(Unit) {
+        viewModel.events.collect { event ->
+            when (event) {
+                is UserEvent.NavigateBack            -> onNavigateBack()
+                is UserEvent.ShowSnackbar            -> snackbarHostState.showSnackbar(event.message)
+                is UserEvent.NavigateToDetail        -> onNavigateToDetail(event.userId)
+            }
+        }
+    }
+
+    Scaffold(snackbarHost = { SnackbarHost(snackbarHostState) }) { padding ->
+        // screen content
+    }
+}
+```
+
+---
+
+## Channel Capacity Options
+
+```kotlin
+// ✅ BUFFERED — default buffer (64 elements), send never suspends unless full
+Channel<Event>(Channel.BUFFERED)
+
+// ✅ UNLIMITED — unbounded buffer, send never suspends
+Channel<Event>(Channel.UNLIMITED)
+
+// ✅ RENDEZVOUS — no buffer, send suspends until receive
+Channel<Event>(Channel.RENDEZVOUS)
+
+// ✅ CONFLATED — keeps only the latest, old values dropped
+Channel<Event>(Channel.CONFLATED)
+
+// ✅ Custom capacity
+Channel<Event>(capacity = 32)
+```
+
+---
+
+## Producer-Consumer Pipeline
+
+```kotlin
+// ✅ Work queue with Channel
+class ImageProcessingQueue @Inject constructor() {
+    private val queue = Channel<ImageTask>(capacity = 32)
+
+    suspend fun enqueue(task: ImageTask) {
+        queue.send(task)
+    }
+
+    fun startProcessing(scope: CoroutineScope) {
+        scope.launch(Dispatchers.Default) {
+            for (task in queue) {   // ✅ for loop — processes until channel is closed
+                processImage(task)
+            }
+        }
+    }
+
+    fun close() {
+        queue.close()
+    }
+}
+```
+
+---
+
+## Channel vs SharedFlow
+
+|               | Channel                 | SharedFlow                     |
+| ------------- | ----------------------- | ------------------------------ |
+| Consumers     | Single                  | Multiple                       |
+| Delivery      | Guaranteed (buffered)   | Not guaranteed (can miss)      |
+| Replay        | No                      | Configurable                   |
+| Best for      | UI events, work queues  | Broadcast events, status       |
+| Missed events | Buffered until consumed | Dropped if no active collector |
+
+---
+
+## trySend vs send
+
+```kotlin
+// ✅ send — suspends if buffer full (use inside coroutines)
+viewModelScope.launch {
+    _events.send(UserEvent.NavigateBack)
+}
+
+// ✅ trySend — returns ChannelResult, non-suspending (use outside coroutines)
+val result = _events.trySend(UserEvent.NavigateBack)
+if (result.isFailure) Timber.w("Event could not be sent — channel full or closed")
+```
+
+---
+
+## Closing a Channel
+
+```kotlin
+// ✅ Close channel when done producing — consumer loop ends
+class DataProducer {
+    private val channel = Channel<Data>(Channel.BUFFERED)
+
+    suspend fun produce() {
+        try {
+            dataList.forEach { channel.send(it) }
+        } finally {
+            channel.close()  // ✅ always close in finally
+        }
+    }
+
+    fun consume(scope: CoroutineScope) {
+        scope.launch {
+            for (data in channel) {  // ends when channel is closed
+                process(data)
+            }
+        }
+    }
+}
+```
+
+---
+
+## Anti-Patterns
+
+- Exposing raw `MutableSharedFlow` or `Channel` — external code can send/close
+- Not using `receiveAsFlow()` — exposes Channel API to consumers
+- Using `Channel.RENDEZVOUS` for UI events — send suspends if UI isn't collecting
+- Using `SharedFlow` when you need guaranteed single delivery — events can be missed
+- Forgetting to close the channel in producer — consumer loop hangs forever
+
+---
+
+## Related Skills
+
+- `sharedflow` — broadcast to multiple collectors
+- `stateflow` — persistent UI state
+- `flow` — cold stream fundamentals
+- `coroutine` — structured concurrency and scopes
+- `mvvm` — event pattern in ViewModel