Java/Kotlin interop result wrapper for use in function overrides between Java and Kotlin. Can be converted to/from kotlin.Result and used in both languages.

SelectionSpanInfo

class SelectionSpanInfo(start: Int, end: Int, startFlags: Int, endFlags: Int) : SpanInfo

SendProducerScope

interface SendProducerScope<T> : ProducerScope<T>

SpanInfo

abstract class SpanInfo(var start: Int, var end: Int)

TaskCancellation

class TaskCancellation : Exception

Reported by await when the task itself was cancelled, as opposed to the coroutine awaiting it.

UriFilter

class UriFilter

Filter helper for filtering uris with (or without) particular requirements, conditions or patterns.

Properties

WhileUiSubscribed

val WhileUiSubscribed: SharingStarted

A SharingStarted meant to be used with a StateFlow to expose data to the UI.

Functions

amb

suspend fun <T> amb(block: suspend AmbBuilder<T>.() -> Unit): T

ambOf

suspend fun <T> ambOf(tasks: List<suspend () -> T>): T

suspend fun <T> ambOf(vararg tasks: suspend () -> T): T

await

suspend fun <T> Task<T>.await(): Result<T>

Awaits this task without ever throwing: success, failure and cancellation all arrive as a Result, the last as a failure carrying TaskCancellation.

awaitCreated

fun LifecycleOwner.awaitCreated(action: () -> Unit): Disposable

awaitDestroyed

fun LifecycleOwner.awaitDestroyed(action: () -> Unit): Disposable

awaitResumed

fun LifecycleOwner.awaitResumed(action: () -> Unit): Disposable

awaitSend

suspend fun <T> ProducerScope<T>.awaitSend(block: suspend SendProducerScope<T>.() -> Unit)

awaitStarted

fun LifecycleOwner.awaitStarted(action: () -> Unit): Disposable

awaitState

fun LifecycleOwner.awaitState(state: Lifecycle.State, action: () -> Unit): Disposable

bindTo

infix fun <State, Value> Flow<Value>.bindTo(update: State.(Value) -> State): MappedDataclassBinding<State, Value>

buildCompletable

fun CoroutineScope.buildCompletable(): Completable

fun CoroutineScope.buildCompletable(action: CompletableBuilder.() -> Unit): Completable

Builds a completable that can be completed, executing all deferred actions in reverse order of their registration.

canLaunch

fun Intent.canLaunch(context: Context): Boolean

capitalize

fun String.capitalize(locale: Locale = Locale.getDefault()): String

checkPermissionInManifest

fun Context.checkPermissionInManifest(vararg id: String): Boolean

checkSelfPermissionCompat

fun Context.checkSelfPermissionCompat(vararg id: String): Boolean

childJobScope

fun CoroutineScope.childJobScope(context: CoroutineContext = EmptyCoroutineContext): CoroutineScope

Creates a new CoroutineScope with a Job that is a child of the current scope's job. This allows for launching coroutines that are cancelled when the parent scope is cancelled.

childSupervisorJobScope

fun CoroutineScope.childSupervisorJobScope(context: CoroutineContext = EmptyCoroutineContext): CoroutineScope

Creates a new CoroutineScope with a SupervisorJob that is a child of the current scope's job. This allows for launching coroutines that can fail independently of the parent scope.

clampedSubList

fun <T> List<T>.clampedSubList(fromIndex: Int, toIndex: Int): List<T>

closeAutoCloseable

fun <T> closeAutoCloseable(data: T)

Closes all AutoCloseable members of the data.

closeAutoCloseableMembers

fun Any.closeAutoCloseableMembers()

Closes all AutoCloseable members of the class.

combine

fun <T1, R> combine(flow: Flow<T1>, transform: suspend (T1) -> R): Flow<R>

fun <T1, T2, T3, T4, T5, T6, R> combine(flow: Flow<T1>, flow2: Flow<T2>, flow3: Flow<T3>, flow4: Flow<T4>, flow5: Flow<T5>, flow6: Flow<T6>, transform: suspend (T1, T2, T3, T4, T5, T6) -> R): Flow<R>

fun <T1, T2, T3, T4, T5, T6, T7, R> combine(flow: Flow<T1>, flow2: Flow<T2>, flow3: Flow<T3>, flow4: Flow<T4>, flow5: Flow<T5>, flow6: Flow<T6>, flow7: Flow<T7>, transform: suspend (T1, T2, T3, T4, T5, T6, T7) -> R): Flow<R>

fun <T1, T2, T3, T4, T5, T6, T7, T8, R> combine(flow: Flow<T1>, flow2: Flow<T2>, flow3: Flow<T3>, flow4: Flow<T4>, flow5: Flow<T5>, flow6: Flow<T6>, flow7: Flow<T7>, flow8: Flow<T8>, transform: suspend (T1, T2, T3, T4, T5, T6, T7, T8) -> R): Flow<R>

fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, R> combine(flow: Flow<T1>, flow2: Flow<T2>, flow3: Flow<T3>, flow4: Flow<T4>, flow5: Flow<T5>, flow6: Flow<T6>, flow7: Flow<T7>, flow8: Flow<T8>, flow9: Flow<T9>, transform: suspend (T1, T2, T3, T4, T5, T6, T7, T8, T9) -> R): Flow<R>

combineFlatten