findViewsByTag

0.12.14

CHANGELOG.md

@@ -1,5 +1,28 @@
 # Changelog
 
+## 0.12.15
+
+* `Common`:
+    * `applyDiff` will return `Diff` object since this release
+    * `Android`:
+      * New functions/extensions `findViewsByTag` and `findViewsByTagInActivity`
+* `Coroutines`:
+    * Add `Flow` extensions `flatMap`, `flatMapNotNull` and `flatten`
+    * Add `Flow` extensions `takeNotNull` and `filterNotNull`
+
+## 0.12.14
+
+* `Versions`:
+  * `Android CoreKTX`: `1.8.0` -> `1.9.0`
+  * `Android AppCompat`: `1.4.2` -> `1.5.1`
+  * Android Compile SDK: 32 -> 33
+  * Android Build Tools: 32.0.0 -> 33.0.0
+* `Common`:
+  * `Android`:
+    * Add `argumentOrNull`/`argumentOrThrow` delegates for fragments
+* `Coroutines`:
+  * Rewrite `awaitFirstWithDeferred` onto `CompletableDeferred` instead of coroutines suspending
+
 ## 0.12.13
 
 * `Coroutines`:

common/build.gradle

@@ -16,6 +16,7 @@ kotlin {
         androidMain {
             dependencies {
                 api project(":micro_utils.coroutines")
+                api libs.android.fragment
             }
         }
     }

common/src/commonMain/kotlin/dev/inmo/micro_utils/common/DiffUtils.kt

@@ -14,6 +14,14 @@ private inline fun <T> getObject(
 /**
  * Diff object which contains information about differences between two [Iterable]s
  *
+ * See tests for more info
+ *
+ * @param removed The objects which has been presented in the old collection but absent in new one. Index here is the index in the old collection
+ * @param added The object which appear in new collection only. Indexes here show the index in the new collection
+ * @param replaced Pair of old-new changes. First object has been presented in the old collection on its
+ * [IndexedValue.index] place, the second one is the object in new collection. Both have indexes due to the fact that in
+ * case when some value has been replaced after adds or removes in original collection the object index will be changed
+ *
  * @see calculateDiff
  */
 data class Diff<T> internal constructor(
@@ -165,7 +173,7 @@ inline fun <T> Iterable<T>.calculateStrictDiff(
 fun <T> MutableList<T>.applyDiff(
     source: Iterable<T>,
     strictComparison: Boolean = false
-) = calculateDiff(source, strictComparison).let {
+): Diff<T> = calculateDiff(source, strictComparison).also {
     for (i in it.removed.indices.sortedDescending()) {
         removeAt(it.removed[i].index)
     }

common/src/main/kotlin/dev/inmo/micro_utils/common/ArgumentPropertyNullableDelegate.kt

@@ -0,0 +1,76 @@
+package dev.inmo.micro_utils.common
+
+import android.os.Bundle
+import android.os.Parcelable
+import androidx.fragment.app.Fragment
+import java.io.Serializable
+import kotlin.reflect.KProperty
+
+object ArgumentPropertyNullableDelegate {
+    operator fun <T: Any> getValue(thisRef: Fragment, property: KProperty<*>): T? {
+        val arguments = thisRef.arguments ?: return null
+        val key = property.name
+        return when (property.getter.returnType.classifier) {
+            // Scalars
+            String::class -> arguments.getString(key)
+            Boolean::class -> arguments.getBoolean(key)
+            Byte::class -> arguments.getByte(key)
+            Char::class -> arguments.getChar(key)
+            Double::class -> arguments.getDouble(key)
+            Float::class -> arguments.getFloat(key)
+            Int::class -> arguments.getInt(key)
+            Long::class -> arguments.getLong(key)
+            Short::class -> arguments.getShort(key)
+
+            // References
+            Bundle::class -> arguments.getBundle(key)
+            CharSequence::class -> arguments.getCharSequence(key)
+            Parcelable::class -> arguments.getParcelable(key)
+
+            // Scalar arrays
+            BooleanArray::class -> arguments.getBooleanArray(key)
+            ByteArray::class -> arguments.getByteArray(key)
+            CharArray::class -> arguments.getCharArray(key)
+            DoubleArray::class -> arguments.getDoubleArray(key)
+            FloatArray::class -> arguments.getFloatArray(key)
+            IntArray::class -> arguments.getIntArray(key)
+            LongArray::class -> arguments.getLongArray(key)
+            ShortArray::class -> arguments.getShortArray(key)
+            Array::class -> {
+                val componentType = property.returnType.classifier ?.javaClass ?.componentType!!
+                @Suppress("UNCHECKED_CAST") // Checked by reflection.
+                when {
+                    Parcelable::class.java.isAssignableFrom(componentType) -> {
+                        arguments.getParcelableArray(key)
+                    }
+                    String::class.java.isAssignableFrom(componentType) -> {
+                        arguments.getStringArray(key)
+                    }
+                    CharSequence::class.java.isAssignableFrom(componentType) -> {
+                        arguments.getCharSequenceArray(key)
+                    }
+                    Serializable::class.java.isAssignableFrom(componentType) -> {
+                        arguments.getSerializable(key)
+                    }
+                    else -> {
+                        val valueType = componentType.canonicalName
+                        throw IllegalArgumentException(
+                            "Illegal value array type $valueType for key \"$key\""
+                        )
+                    }
+                }
+            }
+            Serializable::class -> arguments.getSerializable(key)
+            else -> null
+        } as? T
+    }
+}
+
+object ArgumentPropertyNonNullableDelegate {
+    operator fun <T: Any> getValue(thisRef: Fragment, property: KProperty<*>): T {
+        return ArgumentPropertyNullableDelegate.getValue<T>(thisRef, property)!!
+    }
+}
+
+fun argumentOrNull() = ArgumentPropertyNullableDelegate
+fun argumentOrThrow() = ArgumentPropertyNonNullableDelegate

common/src/main/kotlin/dev/inmo/micro_utils/common/FindViewsByTag.kt

@@ -0,0 +1,61 @@
+package dev.inmo.micro_utils.common
+
+import android.app.Activity
+import android.view.View
+import android.view.ViewGroup
+import androidx.core.view.children
+import androidx.fragment.app.Fragment
+
+fun findViewsByTag(viewGroup: ViewGroup, tag: Any?): List<View> {
+    return viewGroup.children.flatMap {
+        findViewsByTag(it, tag)
+    }.toList()
+}
+
+fun findViewsByTag(viewGroup: ViewGroup, key: Int, tag: Any?): List<View> {
+    return viewGroup.children.flatMap {
+        findViewsByTag(it, key, tag)
+    }.toList()
+}
+
+fun findViewsByTag(view: View, tag: Any?): List<View> {
+    val result = mutableListOf<View>()
+    if (view.tag == tag) {
+        result.add(view)
+    }
+    if (view is ViewGroup) {
+        result.addAll(findViewsByTag(view, tag))
+    }
+    return result.toList()
+}
+
+fun findViewsByTag(view: View, key: Int, tag: Any?): List<View> {
+    val result = mutableListOf<View>()
+    if (view.getTag(key) == tag) {
+        result.add(view)
+    }
+    if (view is ViewGroup) {
+        result.addAll(findViewsByTag(view, key, tag))
+    }
+    return result.toList()
+}
+
+fun Activity.findViewsByTag(tag: Any?) = rootView ?.let {
+    findViewsByTag(it, tag)
+}
+
+fun Activity.findViewsByTag(key: Int, tag: Any?) = rootView ?.let {
+    findViewsByTag(it, key, tag)
+}
+
+fun Fragment.findViewsByTag(tag: Any?) = view ?.let {
+    findViewsByTag(it, tag)
+}
+
+fun Fragment.findViewsByTag(key: Int, tag: Any?) = view ?.let {
+    findViewsByTag(it, key, tag)
+}
+
+fun Fragment.findViewsByTagInActivity(tag: Any?) = activity ?.findViewsByTag(tag)
+
+fun Fragment.findViewsByTagInActivity(key: Int, tag: Any?) = activity ?.findViewsByTag(key, tag)

common/src/main/kotlin/dev/inmo/micro_utils/common/RootView.kt

@@ -0,0 +1,7 @@
+package dev.inmo.micro_utils.common
+
+import android.app.Activity
+import android.view.View
+
+val Activity.rootView: View?
+    get() = findViewById<View?>(android.R.id.content) ?.rootView ?: window.decorView.findViewById<View?>(android.R.id.content) ?.rootView

coroutines/src/commonMain/kotlin/dev/inmo/micro_utils/coroutines/AwaitFirst.kt

@@ -6,23 +6,19 @@ import kotlin.coroutines.*
 suspend fun <T> Iterable<Deferred<T>>.awaitFirstWithDeferred(
     scope: CoroutineScope,
     cancelOnResult: Boolean = true
-): Pair<Deferred<T>, T> = suspendCoroutine<Pair<Deferred<T>, T>> { continuation ->
-    scope.launch(SupervisorJob()) {
-        val scope = this
-        forEach {
-            scope.launch {
-                continuation.resume(it to it.await())
-                scope.cancel()
-            }
+): Pair<Deferred<T>, T> {
+    val resultDeferred = CompletableDeferred<Pair<Deferred<T>, T>>()
+    val scope = scope.LinkedSupervisorScope()
+    forEach {
+        scope.launch {
+            resultDeferred.complete(it to it.await())
+            scope.cancel()
         }
     }
-}.also {
-    if (cancelOnResult) {
-        forEach {
-            try {
-                it.cancel()
-            } catch (e: IllegalStateException) {
-                e.printStackTrace()
+    return resultDeferred.await().also {
+        if (cancelOnResult) {
+            forEach {
+                runCatchingSafely { it.cancel() }
             }
         }
     }

coroutines/src/commonMain/kotlin/dev/inmo/micro_utils/coroutines/FlowFlatten.kt

@@ -0,0 +1,39 @@
+package dev.inmo.micro_utils.coroutines
+
+import kotlinx.coroutines.flow.*
+import kotlin.js.JsName
+import kotlin.jvm.JvmName
+
+inline fun <T, R> Flow<Flow<T>>.flatMap(
+    crossinline mapper: suspend (T) -> R
+) = flow {
+    collect {
+        it.collect {
+            emit(mapper(it))
+        }
+    }
+}
+
+@JsName("flatMapIterable")
+@JvmName("flatMapIterable")
+inline fun <T, R> Flow<Iterable<T>>.flatMap(
+    crossinline mapper: suspend (T) -> R
+) = map {
+    it.asFlow()
+}.flatMap(mapper)
+
+inline fun <T, R> Flow<Flow<T>>.flatMapNotNull(
+    crossinline mapper: suspend (T) -> R
+) = flatMap(mapper).takeNotNull()
+
+@JsName("flatMapNotNullIterable")
+@JvmName("flatMapNotNullIterable")
+inline fun <T, R> Flow<Iterable<T>>.flatMapNotNull(
+    crossinline mapper: suspend (T) -> R
+) = flatMap(mapper).takeNotNull()
+
+fun <T> Flow<Flow<T>>.flatten() = flatMap { it }
+
+@JsName("flattenIterable")
+@JvmName("flattenIterable")
+fun <T> Flow<Iterable<T>>.flatten() = flatMap { it }

coroutines/src/commonMain/kotlin/dev/inmo/micro_utils/coroutines/FlowNullables.kt

@@ -0,0 +1,6 @@
+package dev.inmo.micro_utils.coroutines
+
+import kotlinx.coroutines.flow.*
+
+fun <T> Flow<T>.takeNotNull() = mapNotNull { it }
+fun <T> Flow<T>.filterNotNull() = takeNotNull()

gradle.properties

@@ -14,5 +14,5 @@ crypto_js_version=4.1.1
 # Project data
 
 group=dev.inmo
-version=0.12.13
-android_code_version=152
+version=0.12.15
+android_code_version=154

gradle/libs.versions.toml

@@ -20,15 +20,16 @@ koin = "3.2.0"
 android-gradle = "7.2.2"
 dexcount = "3.1.0"
 
-android-coreKtx = "1.8.0"
+android-coreKtx = "1.9.0"
 android-recyclerView = "1.2.1"
-android-appCompat = "1.4.2"
+android-appCompat = "1.5.1"
+android-fragment = "1.5.3"
 android-espresso = "3.4.0"
 android-test = "1.1.3"
 
 android-props-minSdk = "21"
-android-props-compileSdk = "32"
-android-props-buildTools = "32.0.0"
+android-props-compileSdk = "33"
+android-props-buildTools = "33.0.0"
 
 [libraries]
 
@@ -71,6 +72,7 @@ jb-exposed = { module = "org.jetbrains.exposed:exposed-core", version.ref = "jb-
 android-coreKtx = { module = "androidx.core:core-ktx", version.ref = "android-coreKtx" }
 android-recyclerView = { module = "androidx.recyclerview:recyclerview", version.ref = "android-recyclerView" }
 android-appCompat-resources = { module = "androidx.appcompat:appcompat-resources", version.ref = "android-appCompat" }
+android-fragment = { module = "androidx.fragment:fragment", version.ref = "android-fragment" }
 android-espresso = { module = "androidx.test.espresso:espresso-core", version.ref = "android-espresso" }
 android-test-junit = { module = "androidx.test.ext:junit", version.ref = "android-test" }