Flow

Позволяет эмиттировать значения в поток, делая его изменяемым.

class MyViewModel: ViewModel() {

    private val _eventFlow = MutableSharedFlow<String>(replay = 1)
    val eventFlow = _eventFlow.asSharedFlow()

    fun sendEvent(event: String) {
        viewModelScope.launch {
            _eventFlow.emit(event) // Эмиттируем событие
        }
    }
}

val sharedFlow = MutableSharedFlow<Int>(
    replay = 1 // Хранит последнее значение для новых подписчиков
)

val sharedFlow = MutableSharedFlow<Int>(
    extraBufferCapacity = 2 // Дополнительно хранит до 2 значений в буфере
)

val sharedFlow = MutableSharedFlow<Int>(
    onBufferOverflow = BufferOverflow.DROP_OLDEST // Удаляет самое старое значение при переполнении
)

Преобразует MutableSharedFlow в неизменяемый SharedFlow, предоставляя доступ только для подписки без возможности эмиссии значений.

private val _eventFlow: MutableSharedFlow<String> = MutableSharedFlow<String>()
val eventFlow: SharedFlow<String> = _eventFlow.asSharedFlow()

Преобразует Flow в SharedFlow, делая его горячим и позволяя вещать значения одновременно нескольким подписчикам.

val sharedFlow: SharedFlow<Int> = flow
    .shareIn(
        scope = viewModelScope,
        started = SharingStarted.Lazily,
        replay = 0
    )

Используется для попытки отправки значения в SharedFlow без блокировки. Возвращает true, если значение успешно отправлено, или false, если подписчик не может принять значение (например, когда поток завершен). Это позволяет избежать выброса исключений при переполнении буфера.

val flow = MutableSharedFlow<String>()

val success = flow.tryEmit("Hello") // Вернет true, если подписчик активен

flow.collect { value ->
    println(value)
}

Позволяет обновлять текущее значение состояния.

class MyViewModel: ViewModel() {
    private val _stateFlow = MutableStateFlow("Начальное состояние")
    val stateFlow: StateFlow<String> = _stateFlow
    
    fun updateState(newState: String) {
        _stateFlow.value = newState
    }
}

class MyViewModel: ViewModel() {
    private val _stateFlow = MutableStateFlow(0)
    val stateFlow: StateFlow<Int> = _stateFlow

    // Увеличивает значение, если текущее значение совпадает с ожидаемым
    fun incrementIfExpected(expected: Int) {
        _stateFlow.compareAndSet(expected, expected + 1)
    }
}

class MyViewModel: ViewModel() {
    private val _clickCount = MutableStateFlow(0)
    val clickCount: StateFlow<Int> = _clickCount

    // Увеличивает счетчик кликов и возвращает обновленное значение
    fun incrementAndGetClickCount(): Int {
        return _clickCount.updateAndGet { current -> current + 1 }
    }
}

class MyViewModel: ViewModel() {
    private val _clickCount = MutableStateFlow(0)
    val clickCount: StateFlow<Int> = _clickCount

    // Увеличивает счетчик и возвращает старое значение
    fun incrementAndGetOldClickCount(): Int {
        return _clickCount.getAndUpdate { current -> current + 1 }
    }
}

class MyViewModel: ViewModel() {
    private val _clickCount = MutableStateFlow(0)
    val clickCount: StateFlow<Int> = _clickCount

    // Увеличивает счетчик кликов
    fun incrementClickCount() {
        _clickCount.update { current -> current + 1 }
    }
}

Преобразует изменяемый MutableStateFlow в неизменяемый StateFlow.

private val _stateFlow: MutableStateFlow<String> = MutableStateFlow("Начальное состояние")
val stateFlow: StateFlow<String> = _stateFlow.asStateFlow()

Преобразует Flow в StateFlow, добавляя к нему текущее состояние. stateIn делает поток горячим, то есть он начинает испускать значения, независимо от подписчиков, и всегда содержит одно актуальное значение, как StateFlow.

val stateFlow: StateFlow<Int> = flow
    .stateIn(
        scope = viewModelScope,
        started = SharingStarted.WhileSubscribed(5_000),
        initialValue = 0
    )

Используется для отправки значений из Flow в его подписчиков. Является suspend-функцией.

val flow = flow {
    emit("Hello")
    emit("World")
}

flow.collect { value ->
    println(value) // Вывод: Hello, World
}

Создает асинхронный поток данных.

val numbersFlow: Flow<Int> = flow {
    for (i in 1..3) {
        delay(1000)
        emit(i)
    }
}

Преобразует коллекции и последовательности в Flow.

val list = listOf(1, 2, 3)
val flowOfList: Flow<Int> = list.asFlow()

Cоздает Flow из одного или нескольких значений.

val numberFlow: Flow<Int> = flowOf(1, 2, 3, 5, 8)

Позволяет создать Flow, используя каналы.

val flow: Flow<String> = channelFlow {
    send("Hello")
    send("World")
}

Создает Flow, который работает с коллбэками. Он оборачивает асинхронные вызовы, позволяя отправлять значения в поток, когда происходят определенные события.

val flow: Flow<Int> = callbackFlow {
    val listener = object: MyListener {
        override fun onValue(value: Int) {
            trySend(value) // Отправляет значение в поток
        }
    }
    registerListener(listener) // Регистрация слушателя
    awaitClose { unregisterListener(listener) } // Удаление слушателя при закрытии
}

Позволяет накапливать элементы в буфере и передавать их потребителю, не ожидая, пока он обработает предыдущие. Это улучшает производительность, предотвращая блокировки.

val flow = flowOf(1, 2, 3)

flow
    .buffer()  // Используем буфер
    .collect { value ->
        delay(100)  // Эмулируем длительную обработку
        println(value)
    }
// Выведет:
// 1
// 2
// 3

Позволяет пропускать промежуточные значения, если предыдущие еще не были обработаны. Это полезно, когда поток генерирует значения быстрее, чем можно их обработать, и нужно избежать задержек.

flowOf(1, 2, 3, 4, 5)
    .conflate()  // Пропускает промежуточные значения
    .collect { value -> 
        delay(100)  // Задержка для имитации обработки
        println(value)
    }
// 1
// 3
// 5

Изменяет контекст выполнения Flow. Используется для переключения на другой CoroutineDispatcher. Например, можно использовать flowOn для выполнения операций, которые требуют более длительного времени, в фоновом потоке, а затем возвращаться к основному потоку для сбора значений.

flow {
    emit("Start")
    delay(1000) // Долгая операция
    emit("End")
}
.flowOn(Dispatchers.IO) // Переключаем на фоновый поток
.collect { value ->
    println(value) // Собираем значения
}

Позволяет игнорировать элементы потока, поступающие быстрее, чем указанный интервал времени.

val flow = flowOf(1, 2, 3, 4, 5)

flow
    .debounce(100)
    .collect { println(it) }
// Выведет последнее значение после паузы в 100 мс между элементами.

Позволяет получать последнее значение потока через определённые интервалы времени.

val flow = flowOf(1, 2, 3, 4, 5)

flow
    .sample(100)
    .collect { println(it) }
// Выведет последнее значение, которое поступило за каждый 100 мс.

Пропускает только уникальные последовательные значения, игнорируя дубликаты.

flowOf(1, 2, 2, 3, 3, 3, 4)
    .distinctUntilChanged()
    .collect { println(it) } // Результат: 1 2 3 4

Позволяет преобразовать элементы потока и эмитировать несколько значений для каждого входного элемента.

val flow = flowOf(1, 2, 3)

flow.transform { value ->
    emit(value * 2) // Эмитирует удвоенное значение
    emit(value + 1) // Эмитирует значение, увеличенное на 1
}.collect { println(it) }
// Вывод:
// 2
// 2
// 4
// 3
// 6
// 4

Выполняет заданное действие перед началом сбора данных из потока.

flowOf(1, 2, 3)
    .onStart { emit(0) } // Добавляет 0 перед остальными элементами
    .collect { println(it) } // Вывод: 0, 1, 2, 3

Выполняет действие, когда поток завершается, независимо от того, завершился он успешно или из-за исключения.

flowOf(1, 2, 3)
    .onCompletion { println("Completed") }
    .collect { println(it) } // Вывод: 1, 2, 3, Completed

Позволяет указать действие, которое выполнится, если поток данных пуст. Часто используется для обработки случаев, когда поток не содержит элементов.

val flow = emptyFlow<Int>()

flow
    .onEmpty { println("Поток пустой") } // Действие при пустом потоке
    .collect { value -> println(value) } // Поток пустой

Перехватывает ошибки в Flow, позволяя продолжить выполнение после их обработки.

flow {
    emit("Loading data")
    throw Exception("Error")
}.catch { e ->
    emit("Error: ${e.message}")
}.collect { value ->
    println(value)
}

Пропускает первые N элементов потока и эмитирует оставшиеся.

val flow = flowOf(1, 2, 3, 4, 5)

val result = flow.drop(3)
result.collect { println(it) }
// 4
// 5

Пропускает элементы потока, пока условие не станет ложным, и эмитирует оставшиеся.

val flow = flowOf(1, 2, 3, 4, 5)

val result = flow.dropWhile { it < 4 }
result.collect { println(it) }
// 4
// 5

Ограничивает поток первым n элементами.

val flow = flowOf(1, 2, 3, 4, 5)

flow.take(3)
    .collect { println(it) }
// 1
// 2
// 3

Берет элементы из потока до тех пор, пока условие выполняется.

val flow = flowOf(1, 2, 3, 4, 5)

flow.takeWhile { it < 4 }
    .collect { println(it) }
// 1
// 2
// 3

Позволяет преобразовывать элементы потока, пока не выполнится заданное условие.

val flow = flowOf(1, 2, 3, 4)

flow.transformWhile { value ->
    emit(value * 2)
    value != 3 // прекращаем преобразование, если значение равно 3
}.collect { println(it) }
// Вывод:
// 2
// 4

Позволяет преобразовать элементы потока в новые потоки, обрабатывая их последовательно, один за другим.

val flow = flowOf(1, 2, 3)

flow
    .flatMapConcat { value ->
        flow {
            emit(value * 2)
        }
    }
    .collect { println(it) }
// Выведет: 2, 4, 6

Позволяет преобразовать элементы потока в новые потоки и сливать их в один поток, обрабатывая параллельно.

val flow = flowOf(1, 2, 3)

flow
    .flatMapMerge { value ->
        flow {
            emit(value * 2)
        }
    }
    .collect { println(it) }
// Выведет: 2, 4, 6

Позволяет преобразовывать элементы потока в новые потоки, при этом отменяя обработку предыдущих, если приходит новый элемент.

val flow = flowOf(1, 2, 3)

flow
    .flatMapLatest { value ->
        flow {
            emit(value * 2)
        }
    }
    .collect { println(it) }
// Выведет: 6

Объединяет несколько потоков, позволяя им испускать значения одновременно, сохраняя порядок их эмиссий.

val flow1 = flowOf(1, 2)
val flow2 = flowOf(3, 4)

merge(flow1, flow2).collect { println(it) } // Вывод: 1, 2, 3, 4 (порядок зависит от исполнения)

Преобразует значения, пропуская результаты предыдущих преобразований, если поступает новое значение.

flowOf(1, 2, 3)
    .mapLatest { value ->
        delay(100) // Длительная операция
        "Transformed $value"
    }
    .collect { println(it) } // Вывод: Transformed 3 (1 и 2 прерываются)

Позволяет преобразовывать элементы потока, при этом если приходит новый элемент, предыдущая операция отменяется.

val flow = flowOf(1, 2, 3)

flow.transformLatest { value ->
    emit(value * 2)
    delay(100) // имитация долгой работы
    emit(value + 1)
}.collect { println(it) }
// Вывод:
// 2
// 3
// 6

Пропускает элементы потока, не удовлетворяющие заданному условию, и эмитирует только те, которые удовлетворяют.

val flow = flowOf(1, 2, 3, 4, 5)

val result = flow.filter { it % 2 == 0 }
result.collect { println(it) }
// 2
// 4

Пропускает элементы потока, которые удовлетворяют заданному условию, и эмитирует только те, которые ему не соответствуют.

val flow = flowOf(1, 2, 3, 4, 5)

val result = flow.filterNot { it % 2 == 0 }
result.collect { println(it) }
// 1
// 3
// 5

Фильтрует элементы потока, оставляя только те, которые могут быть приведены к указанному типу.

val flow = flowOf("Hello", 1, "World", 2)

val result = flow.filterIsInstance<String>()
result.collect { println(it) }
// Hello
// World

Отфильтровывает все элементы, которые равны null, и эмитирует только ненулевые значения.

val flow = flowOf(1, null, 2, null, 3)

val result = flow.filterNotNull()
result.collect { println(it) }
// 1
// 2
// 3

Применяет заданную функцию к каждому элементу потока и возвращает новый поток с результатами.

val flow = flowOf(1, 2, 3)

val result = flow.map { it * 2 }
result.collect { println(it) }
// 2
// 4
// 6

Применяет функцию к каждому элементу потока и фильтрует null значения из результата.

val flow = flowOf("1", "2", "a", "4")

val result = flow.mapNotNull { it.toIntOrNull() }
result.collect { println(it) }
// 1
// 2
// 4

Добавляет индекс к каждому элементу потока, превращая его в IndexedValue.

flowOf("a", "b", "c")
    .withIndex()
    .collect { println("Index: ${it.index}, Value: ${it.value}") }
// Вывод:
// Index: 0, Value: a
// Index: 1, Value: b
// Index: 2, Value: c

Применяет функцию к каждому элементу потока, но не изменяет сам поток. Возвращает тот же поток для дальнейших операций.

val flow = flowOf(1, 2, 3)

flow.onEach { println("Value: $it") }
    .collect()
// Value: 1
// Value: 2
// Value: 3

Накапливает значения, начиная с начального состояния, и эмитирует каждый промежуточный результат.

flowOf(1, 2, 3)
    .scan(0) { accumulator, value -> accumulator + value }
    .collect { println(it) }
// Вывод:
// 0 (начальное значение)
// 1 (0 + 1)
// 3 (1 + 2)
// 6 (3 + 3)

Накапливает значения, эмитируя промежуточные результаты, но без начального значения.

flowOf(1, 2, 3)
    .runningReduce { accumulator, value -> accumulator + value }
    .collect { println(it) }
// Вывод:
// 1
// 3 (1 + 2)
// 6 (3 + 3)

Накапливает значения, начиная с заданного начального значения, и эмитирует каждый промежуточный результат.

flowOf(1, 2, 3)
    .runningFold(0) { accumulator, value -> accumulator + value }
    .collect { println(it) }
// Вывод:
// 0 (начальное значение)
// 1 (0 + 1)
// 3 (1 + 2)
// 6 (3 + 3)

Разбивает заданный поток на поток непересекающихся списков, каждый из которых не превышает заданный размер, но никогда не бывает пустым. Последний эмитируемый список может содержать меньше элементов, чем заданный размер.

flowOf("a", "b", "c", "d", "e")
    .chunked(2) // ["a", "b"], ["c", "d"], ["e"]
    .map { it.joinToString(separator = "") }
    .collect {
        println(it) // Prints "ab", "cd", e"
    }

Комбинирует несколько потоков, эмитируя новые элементы, каждый раз, когда хотя бы один из потоков эмитирует новое значение.

val flow1 = flowOf(1, 2, 3)
val flow2 = flowOf(10, 20, 30)

val result = flow1.combine(flow2) { a, b -> a + b }
result.collect { println(it) }
// 11
// 22
// 33

Комбинирует несколько потоков и позволяет трансформировать их значения, эмитируя новые элементы на основе комбинации данных из всех потоков.

val flow1 = flowOf(1, 2, 3)
val flow2 = flowOf(10, 20, 30)

val result = flow1.combineTransform(flow2) { a, b ->
    emit(a + b) // Можно применить любую логику трансформации
}
result.collect { println(it) }
// 11
// 22
// 33

Позволяет комбинировать два потока, соединяя элементы в пары.

val flow1 = flowOf(1, 2, 3)
val flow2 = flowOf("A", "B", "C")

flow1.zip(flow2) { a, b -> "$a$b" }
    .collect { println(it) }
// Вывод:
// 1A
// 2B
// 3C

Используется для сбора значений, эмитируемых потоком. Запускает сбор значений и выполняет заданное действие для каждого полученного значения.

• Блокирует текущий поток до тех пор, пока все данные не будут собраны или поток не завершится.

val flow = flowOf(1, 2, 3)

flow.collect { value ->
    println(value)
}

Собирает значения из Flow и предоставляет индекс каждого элемента в коллекторе.

flowOf("a", "b", "c")
    .collectIndexed { index, value ->
        println("Index: $index, Value: $value")
    }

Cобирает значения, но отменяет обработку предыдущего значения, если новое значение приходит до завершения обработки. Это полезно для случаев, когда только последние значения имеют значение, например, в UI, где пользователь может вводить текст.

val flow = flow {
    emit("First")
    delay(100) // Имитация задержки
    emit("Second")
}

flow.collectLatest { value ->
    println(value) // Напечатает только "Second"
}

Собирает данные из Flow или StateFlow и превращает их в State. Обновляет UI автоматически, когда поток отправляет новые данные.

class MyViewModel: ViewModel() {
    private val _stateFlow = MutableStateFlow("Hello, Compose!")
    val stateFlow: StateFlow<String> = _numberFlow.asStateFlow()
}

@Composable
fun ExampleScreen(viewModel: MyViewModel) {
    val uiState by viewModel.stateFlow.collectAsState()
    Text(text = "State: $uiState")
}

Собирает данные из Flow или StateFlow, учитывая жизненный цикл Composable. Автоматически приостанавливает сбор, когда UI неактивен, и возобновляет, когда UI снова в фокусе.

class MyViewModel: ViewModel() {
    private val _stateFlow = MutableStateFlow("Hello, Compose!")
    val stateFlow = _stateFlow.asStateFlow()
}

@Composable
fun ExampleScreen(viewModel: MyViewModel) {
    val uiState by viewModel.stateFlow.collectAsStateWithLifecycle()
    Text(text = "State: $uiState")
}

Преобразует элементы Flow в список List.

val numbersFlow: Flow<Int> = flowOf(1, 2, 3, 4, 5)

runBlocking {
    val numbersList: List<Int> = numbersFlow.toList()
    println(numbersList) // [1, 2, 3, 4, 5]
}

Преобразует элементы Flow в Set, собирая уникальные значения из потока. Игнорирует дубликаты.

val numbersFlow: Flow<Int> = flowOf(1, 2, 2, 3, 4, 5, 5)

runBlocking {
    val numbersSet: Set<Int> = numbersFlow.toSet()
    println(numbersSet) // [1, 2, 3, 4, 5]
}

Преобразует элементы Flow в заданную коллекцию, например, ArrayList или LinkedList. Позволяет настраивать тип коллекции, в которую будут собираться элементы.

val numbersFlow: Flow<Int> = flowOf(1, 2, 3, 4)

runBlocking {
    val numbersList: ArrayList<Int> = numbersFlow.toCollection(ArrayList())
    println(numbersList) // [1, 2, 3, 4]
}

Применяет операцию к каждому элементу потока, аккумулируя результат.

val result = flowOf(1, 2, 3).reduce { acc, value -> acc + value }
println(result) // 6

Применяет операцию к каждому элементу потока, начиная с начального значения, и возвращает накопленный результат.

val result = flowOf(1, 2, 3).fold(0) { acc, value -> acc + value }
println(result) // 6

Возвращает единственный элемент из потока, либо бросает исключение, если элементов больше одного или поток пуст.

val result = flowOf(1).single()
println(result) // 1

Возвращает единственный элемент из потока или null, если поток пуст или содержит больше одного элемента.

val result = flowOf(1).singleOrNull()
println(result) // 1

val resultEmpty = flowOf<Int>().singleOrNull()
println(resultEmpty) // null

val resultMultiple = flowOf(1, 2).singleOrNull()
println(resultMultiple) // null

Возвращает первый элемент из потока, либо бросает исключение, если поток пуст.

val result = flowOf(1, 2, 3).first()
println(result) // 1

Возвращает первый элемент из потока или null, если поток пуст.

val result = flowOf<Int>().firstOrNull()
println(result) // null

Возвращает последний элемент из потока, либо бросает исключение, если поток пуст.

val result = flowOf(1, 2, 3).last()
println(result) // 3

Возвращает последний элемент из потока или null, если поток пуст.

val result = flowOf<Int>().lastOrNull()
println(result) // null

Возвращает количество элементов в потоке.

val result = flowOf(1, 2, 3).count()
println(result) // 3