compose 1.5.5, polish sample

Author: hoc081098

.github/workflows/sample.yml

@@ -0,0 +1,62 @@
+name: Build sample
+
+on:
+  push:
+    branches: [ master ]
+    paths-ignore: [ '**.md', '**.MD' ]
+    tags-ignore:
+      - '**'
+  pull_request:
+    branches: [ master ]
+    paths-ignore: [ '**.md', '**.MD' ]
+  workflow_dispatch:
+
+env:
+  GRADLE_OPTS: "-Dorg.gradle.jvmargs=-Xmx4g -Dorg.gradle.daemon=false -Dkotlin.incremental=false -XX:+UseParallelGC -XX:+HeapDumpOnOutOfMemoryError -Dfile.encoding=UTF-8"
+
+jobs:
+  android:
+    strategy:
+      matrix:
+        os: [ linux-latest ]
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Set up JDK
+        uses: actions/setup-java@v3
+        with:
+          distribution: 'zulu'
+          java-version: '17'
+
+      - name: Cache gradle, wrapper and buildSrc
+        uses: actions/cache@v3
+        with:
+          path: |
+            ~/.gradle/caches
+            ~/.gradle/wrapper
+          key: ${{ matrix.os }}-gradle-${{ hashFiles('**/*.gradle*') }}-${{ hashFiles('**/gradle/wrapper/gradle-wrapper.properties') }}-${{ hashFiles('**/buildSrc/**/*.kt') }}
+          restore-keys: |
+            ${{ matrix.os }}-gradle-
+      - name: Cache konan
+        uses: actions/cache@v3
+        with:
+          path: |
+            ~/.konan/cache
+            ~/.konan/dependencies
+            ~/.konan/kotlin-native-macos*
+            ~/.konan/kotlin-native-mingw*
+            ~/.konan/kotlin-native-windows*
+            ~/.konan/kotlin-native-linux*
+            ~/.konan/kotlin-native-prebuilt-macos*
+            ~/.konan/kotlin-native-prebuilt-mingw*
+            ~/.konan/kotlin-native-prebuilt-windows*
+            ~/.konan/kotlin-native-prebuilt-linux*
+          key: ${{ matrix.os }}-konan-${{ hashFiles('**/*.gradle*') }}
+          restore-keys: |
+            ${{ matrix.os }}-konan-
+      - name: Make gradlew executable
+        run: chmod +x ./gradlew
+
+      - name: Build
+        run: ./gradlew :sample:app:assembleDebug --stacktrace

gradle/libs.versions.toml

@@ -36,7 +36,7 @@ compose-rules-detekt = "0.3.5"
 androidx-lifecycle = "2.6.2"
 androidx-annotation = "1.7.0"
 androidx-activity = "1.8.1"
-androidx-compose-compiler = "1.5.5-dev-k1.9.21-163bb051fe5"
+androidx-compose-compiler = "1.5.5"
 androidx-navigation = "2.7.5"
 timber = "5.0.1"
 

sample/app/src/main/java/com/hoc081098/channeleventbus/sample/android/common/CollectWithLifecycleEffect.kt

@@ -1,6 +1,7 @@
 package com.hoc081098.channeleventbus.sample.android.common
 
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.NonRestartableComposable
 import androidx.compose.runtime.RememberObserver
 import androidx.compose.runtime.getValue
@@ -18,24 +19,41 @@ import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.launch
 
 /**
- * Collect the given [Flow] in a Effect that runs in the [Dispatchers.Main.immediate] coroutine,
- * when [LifecycleOwner.lifecycle] is at least at [minActiveState].
+ * Collect the given [Flow] in an effect that runs when [LifecycleOwner.lifecycle] is at least at [minActiveState].
+ *
+ * If [inImmediateMain] is `true`, the effect will run in [Dispatchers.Main.immediate][kotlinx.coroutines.MainCoroutineDispatcher.immediate],
+ * otherwise it will run in [androidx.compose.runtime.Composer.applyCoroutineContext].
+ *
+ * @param keys Keys to be used to [remember] the effect.
+ * @param lifecycleOwner The [LifecycleOwner] to be used to [repeatOnLifecycle].
+ * @param minActiveState The minimum [Lifecycle.State] to be used to [repeatOnLifecycle].
+ * @param inImmediateMain Whether the effect should run in [Dispatchers.Main.immediate][kotlinx.coroutines.MainCoroutineDispatcher.immediate].
+ * @param collector The collector to be used to collect the [Flow].
+ *
+ * @see [LaunchedEffect]
  */
 @Composable
 fun <T> Flow<T>.CollectWithLifecycleEffect(
   vararg keys: Any?,
   lifecycleOwner: LifecycleOwner = LocalLifecycleOwner.current,
   minActiveState: Lifecycle.State = Lifecycle.State.STARTED,
+  inImmediateMain: Boolean = true,
   collector: (T) -> Unit,
 ) {
   val flow = this
   val currentCollector by rememberUpdatedState(collector)
 
-  LaunchedEffectInImmediateMain(flow, lifecycleOwner, minActiveState, *keys) {
+  val block: suspend CoroutineScope.() -> Unit = {
     lifecycleOwner.repeatOnLifecycle(minActiveState) {
-      flow.collect { currentCollector(it) }
+      flow.collect(currentCollector)
     }
   }
+
+  if (inImmediateMain) {
+    LaunchedEffectInImmediateMain(flow, lifecycleOwner, minActiveState, *keys, block = block)
+  } else {
+    LaunchedEffect(flow, lifecycleOwner, minActiveState, *keys, block = block)
+  }
 }
 
 @Composable

sample/app/src/main/java/com/hoc081098/channeleventbus/sample/android/common/SingleEventChannel.kt

@@ -20,6 +20,8 @@ interface HasSingleEventFlow<E> {
   /**
    * Must collect in [Dispatchers.Main.immediate][kotlinx.coroutines.MainCoroutineDispatcher.immediate].
    * Safe to call in the coroutines launched by [androidx.lifecycle.lifecycleScope].
+   *
+   * In Compose, we can use [CollectWithLifecycleEffect] with `inImmediateMain = true`.
    */
   val singleEventFlow: Flow<E>
 }
@@ -34,7 +36,7 @@ sealed interface SingleEventFlowSender<E> {
 }
 
 @MainThread
-class SingleEventChannel<E> constructor() :
+class SingleEventChannel<E> :
   Closeable,
   HasSingleEventFlow<E>,
   SingleEventFlowSender<E> {

sample/app/src/main/java/com/hoc081098/channeleventbus/sample/android/ui/home/detail/DetailVM.kt

@@ -6,6 +6,7 @@ import com.hoc081098.channeleventbus.ChannelEventBus
 import com.hoc081098.channeleventbus.sample.android.common.SafeSavedStateHandle
 import com.hoc081098.channeleventbus.sample.android.common.SavedStateHandleKey
 import com.hoc081098.channeleventbus.sample.android.ui.home.DetailResultToHomeEvent
+import com.hoc081098.channeleventbus.sample.android.utils.NonBlankString.Companion.toNonBlankString
 import kotlinx.coroutines.flow.StateFlow
 
 class DetailVM(
@@ -21,8 +22,10 @@ class DetailVM(
   }
 
   internal fun sendResultToHome() {
-    val value = textStateFlow.value.takeIf { it.isNotBlank() } ?: return
-    channelEventBus.send(DetailResultToHomeEvent(value))
+    textStateFlow.value
+      .toNonBlankString()
+      .map(::DetailResultToHomeEvent)
+      .onSuccess(channelEventBus::send)
   }
 
   private companion object {

sample/app/src/main/java/com/hoc081098/channeleventbus/sample/android/ui/home/events.kt

@@ -2,8 +2,9 @@ package com.hoc081098.channeleventbus.sample.android.ui.home
 
 import com.hoc081098.channeleventbus.ChannelEvent
 import com.hoc081098.channeleventbus.ChannelEventKey
+import com.hoc081098.channeleventbus.sample.android.utils.NonBlankString
 
-internal data class DetailResultToHomeEvent(val value: String) : ChannelEvent<DetailResultToHomeEvent> {
+internal data class DetailResultToHomeEvent(val value: NonBlankString) : ChannelEvent<DetailResultToHomeEvent> {
   override val key get() = Key
 
   companion object Key : ChannelEventKey<DetailResultToHomeEvent>(DetailResultToHomeEvent::class)

sample/app/src/main/java/com/hoc081098/channeleventbus/sample/android/ui/home/home/HomeScreen.kt

@@ -8,7 +8,7 @@ import androidx.compose.foundation.layout.Spacer
 import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.height
 import androidx.compose.foundation.lazy.LazyColumn
-import androidx.compose.foundation.lazy.itemsIndexed
+import androidx.compose.foundation.lazy.items
 import androidx.compose.material3.ElevatedButton
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Text
@@ -58,24 +58,21 @@ fun HomeScreen(
       LazyColumn(
         modifier = Modifier.weight(1f),
         contentPadding = PaddingValues(all = 16.dp),
+        verticalArrangement = Arrangement.spacedBy(8.dp),
       ) {
-        itemsIndexed(
+        items(
           items = detailResults,
-          key = { _, item -> item },
-          contentType = { _, _ -> "DetailResult" },
-        ) { index, result ->
+          key = { it.asString() },
+          contentType = { "DetailResult" },
+        ) { result ->
           Text(
             modifier = Modifier.fillParentMaxWidth(),
-            text = result,
+            text = result.asString(),
             style = MaterialTheme.typography.bodyMedium,
             textAlign = TextAlign.Start,
             maxLines = 2,
             overflow = TextOverflow.Ellipsis,
           )
-
-          if (index != detailResults.lastIndex) {
-            Spacer(modifier = Modifier.height(8.dp))
-          }
         }
       }
     }

sample/app/src/main/java/com/hoc081098/channeleventbus/sample/android/ui/home/home/HomeVM.kt

@@ -4,33 +4,34 @@ import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
 import com.hoc081098.channeleventbus.ChannelEventBus
 import com.hoc081098.channeleventbus.sample.android.ui.home.DetailResultToHomeEvent
+import com.hoc081098.channeleventbus.sample.android.utils.NonBlankString
 import kotlinx.collections.immutable.PersistentList
 import kotlinx.collections.immutable.persistentListOf
 import kotlinx.collections.immutable.plus
 import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.flow.SharingStarted
 import kotlinx.coroutines.flow.StateFlow
-import kotlinx.coroutines.flow.mapNotNull
+import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.flow.onCompletion
 import kotlinx.coroutines.flow.scan
 import kotlinx.coroutines.flow.stateIn
 
 class HomeVM(
   channelEventBus: ChannelEventBus,
 ) : ViewModel() {
-  internal val detailResultsStateFlow: StateFlow<PersistentList<String>> = channelEventBus
+  internal val detailResultsStateFlow: StateFlow<PersistentList<NonBlankString>> = channelEventBus
     .receiveAsFlow(DetailResultToHomeEvent)
     .onCompletion {
       check(it is CancellationException) { "Expected CancellationException but was $it" }
       // Close the bus when this ViewModel is cleared.
       channelEventBus.closeKey(DetailResultToHomeEvent)
     }
-    .mapNotNull { it.value.takeIf(String::isNotBlank) }
-    .scan(persistentListOf<String>()) { acc, e ->
-      if (e in acc) {
+    .map { it.value }
+    .scan(persistentListOf<NonBlankString>()) { acc, value ->
+      if (value in acc) {
         acc
       } else {
-        acc + e
+        acc + value
       }
     }
     .stateIn(

sample/app/src/main/java/com/hoc081098/channeleventbus/sample/android/utils/NonBlankString.kt

@@ -0,0 +1,42 @@
+package com.hoc081098.channeleventbus.sample.android.utils
+
+/**
+ * Representation of strings that have at least one character, excluding
+ * whitespaces.
+ */
+@JvmInline
+value class NonBlankString private constructor(private val value: String) : Comparable<NonBlankString> {
+  init {
+    require(value.isNotBlank()) { NotBlankStringException.message }
+  }
+
+  /**
+   * Compares this string alphabetically with the [other] one for order.
+   * Returns zero if this string equals the [other] one, a negative number if
+   * it's less than the [other] one, or a positive number if it's greater than
+   * the [other] one.
+   */
+  override infix fun compareTo(other: NonBlankString): Int = value.compareTo(other.value)
+
+  /** Returns this string as a [String]. */
+  override fun toString(): String = value
+
+  fun asString(): String = value
+
+  /** Returns the length of this string. */
+  val length: Int get() = value.length
+
+  companion object {
+    /**
+     * Returns this string as an encapsulated [NonBlankString],
+     * or returns an encapsulated [IllegalArgumentException] if this string is
+     * [blank][String.isBlank].
+     */
+    fun String.toNonBlankString(): Result<NonBlankString> =
+      runCatching { NonBlankString(this) }
+  }
+}
+
+internal object NotBlankStringException : IllegalArgumentException() {
+  override val message: String = "Given string shouldn't be blank."
+}