NikolaDespotoski

import androidx.camera.core.CameraSelector
import androidx.camera.view.CameraController
import androidx.camera.view.LifecycleCameraController
import androidx.compose.runtime.Composable
import androidx.compose.runtime.CompositionLocalProvider
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.compositionLocalOf
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember

NikolaDespotoski

/**
 * Converts [MlKitAnalyzer.Result] into [kotlin.Result]
 * @param detector Any [Detector]
 * @returns [kotlin.Result] 
 */
fun <T> MlKitAnalyzer.Result.toResult(detector: Detector<T>): Result<T> =
    kotlin.runCatching {
        val value = getValue(detector) ?: throw getThrowable(detector)!!
        value
    }

NikolaDespotoski

/**
 * Cancels current flow when the predicate is matched, throws [CancellationException] up in 
 * current coroutine. 
 * @param cause class that will be used as cause for [CancellationException]
 * @param predicate if result of this function is [true] then the flow is stopped
 */
inline fun <T> Flow<T>.cancelWhen(
    cause: KClass<out Throwable>? = null,
    crossinline predicate: (T) -> Boolean
): Flow<T> = transform {

NikolaDespotoski

import com.google.devtools.ksp.getClassDeclarationByName
import com.google.devtools.ksp.processing.Resolver
import com.google.devtools.ksp.symbol.*

/**
 * Reified function to check if receiver [KSType] is assignable from [T] class
 */
inline fun <reified T> KSType.isAssignableFrom(resolver: Resolver): Boolean {
    val classDeclaration = requireNotNull(resolver.getClassDeclarationByName<T>()) {
        "Unable to resolve ${KSClassDeclaration::class.simpleName} for type ${T::class.simpleName}"

NikolaDespotoski

/*
 * Copyright (C) 2020 Nikola Despotoski
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software

NikolaDespotoski

suspend fun <T, R : Iterable<T>> Flow<Iterable<T>>.filterIterable(predicate: suspend (T) -> Boolean): Flow<R> =
    transform {
        flow {
            val emitted = arrayListOf<T>()
            for (item in it) {
                if (predicate(item)) {
                    emitted.add(item)
                }
            }
            emit(emitted)

NikolaDespotoski

suspend fun <TResult> Task<TResult>.awaitTask() =
    suspendCancellableCoroutine<Task<TResult>> { continuation ->
        addOnCompleteListener {
            continuation.resume(it)
        }
    }

suspend fun <TResult> Task<TResult>.awaitTaskResult() =
    suspendCancellableCoroutine<TResult> { continuation ->
        addOnCanceledListener {

NikolaDespotoski

data class AnimationListenerChain(val animation: Animation, val listener: Animation.AnimationListener = object : Animation.AnimationListener() {
    override fun onAnimationStart(animation: Animation?) {}

    override fun onAnimationEnd(animation: Animation?) {}

    override fun onAnimationRepeat(animation: Animation?) {}
})

inline fun Animation.doOnStart(crossinline onStart: () -> Unit): AnimationListenerChain {
    val chain = AnimationListenerChain(this)

NikolaDespotoski

operator fun <O> ActivityResultCallback<O>.plus(another: ActivityResultCallback<O>) = ActivityResultCallback<O> {
    this@plus.onActivityResult(it)
    another.onActivityResult(it)
}

NikolaDespotoski

suspend fun <F : Fragment> FragmentManager.awaitFragmentById(idRes: Int) =
    suspendCancellableCoroutine<F> {
        val backStackListener = object : FragmentManager.OnBackStackChangedListener {
            override fun onBackStackChanged() {
                val f = findFragmentById(idRes) as F?
                if (f != null) {
                    removeOnBackStackChangedListener(this)
                    it.resume(f)
                }
            }