​​StateFlow
#kotlin #flow

Уже многие используют в своих проектах Flow вместо RxJava, но всё ещё остаётся LiveData. В качестве альтернативы, есть StateFlow, который приходит на замену ConflatedBroadcastChannel.

По принципам работы, StateFlow очень похож на LiveData. Чтобы помочь вам в его использовании, нашёл несколько статей.

В этой автор решил использовать StateFlow для класса SingleLiveEvent, который бывает полезен при публикации каких-то действий нашим слушателям. Также описана разница между методами launch и launchWhenStarted.

Тут описан неплохой пример того, как использовать StateFlow вместо LiveData.

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

​​Бесконечный список с Paging Library и Flow
#flow #jetpack

Сегодня вышел релиз coroutines 1.4.0, где было много классных изменений, связанных с Flow.
Мне кажется, что сегодня Flow довольно стабилен, и нет смысла не использовать его в production-проектах, тем более, когда стабильными стали StateFlow и SharedFlow.

Хочу поделиться статьёй, где автор рассказывает о создании бесконечного списка с помощью объединения Flow и Paging Library.

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

​​Kotlin Flow
#flow #kotlin #documentation

Совсем недавно Google добавили в раздел документации информацию про Kotlin Flow. Давайте посмотрим подробнее, что там есть.

Вначале описывается то, что из себя представляет Flow: по сути, это тип, который похож на Iterator, который также отдаёт последовательность данных, но при этом использует suspend-функции для работы. Работа любого Flow делится на этапы создания, обработки и получения данных.

Для создания Flow можно использовать специальный builder, в котором можно вызвать функцию emit для публикации данных во Flow. Есть также две особенности работы Flow, о которых надо помнить:
🔹Flow последователен, поэтому все вызываемые suspend-функции ждут результата выполнения друг друга.
🔹flow builder не может «емиттить» данные через другой CoroutineContext.
Описан также хороший пример для понимая работы Flow.

Дальше есть пример использования оператора map — как пример изменения данных, формируемых Flow.
Сразу за ним — использование оператора collect для получения данных.

📌Важно обратить внимание на использование оператора flowOn, так как он распространяет своё действие на операторы, написанные выше.

Не забыли упомянуть и про обработку исключений, используя оператор catch.

Подробнее можно почитать тут. Как по мне, получилась хорошая документация, описывающая базу для работы с Flow. Годно.✌🏻

​​Миграция с LiveData на StateFlow
#livedata #flow #jetpack

LiveData — классный инструмент, который позволяет получать данные не думая о жизненном цикле компонента. Он удобен, но есть недостатки:

🔹разработчики используют его повсюду, в том числе и в репозиториях, где его главная функциональность не нужна. Кроме того, репозиторий должен знать о минимальном количестве компонентов Android, а в лучшем случае вообще не знать;
🔹есть методы setValue() и postValue(), которые используются в зависимости от потока. И вам постоянно нужно помнить об этой разнице, когда вы делаете их вызов. В случае вызова setValue() не из UI-потока, вы получить Exception, а использование postValue() по всех случаях грозит проблемами. Отлично рассказали о разнице между этими методами тут.
🔹дополнительная зависимость в приложении. Меньшая из проблем, однако это лишняя библиотека, которую вам нужно затянуть в приложение.
🔹нет поддержки KMM.

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

Я уже начал мигрировать свой текущий проект на StateFlow и отмечу пару недостатков:

🔸нет привязки к жизненному циклу по умолчанию. Необходимо использовать методы типа lifecycleScope.launchWhenResumed() для обеспечания привязки.
🔸важно указывать значение при инициализации в отличии от LiveData. Решение для меня: если такого значения нет — указать null, а при подписке сделать фильтрацию на «не null». Просто один лишний оператор filterNotNull().

В остальном — шикарное решение, которое работает из коробки. Детальный гад по миграции и особенностям можно найти тут.

А вы уже переехали на Flow? Есть ли какие-то недостатки?

​​Новое API для Flow и UI-слоя
#flow #jetpack

Пару дней назад Google выпустили обновление для API Flow, где заметно улучшили его взаимодействие с UI-слоем.

Если говорить о текущем состоянии, то, в целом, мы уже можем использовать Flow и отказаться от LiveData. Правда, есть одно замечание: может быть не безопасно подписываться в UI-слое на холодный Flow, если мы вручную не можем отменить задачу, которая им выполняется. В качестве примера в статье приводится обновление локации пользователя и возможное текущее решение.

Теперь у нас есть три новых метода:
🔸 LifecycleOwner.addRepeatingJob — принимает Lifecycle.State в качестве параметра и используется для автоматического создания и старта новой корутины и отменяет её, когда состояние достигнет противоположного значения.

🔸Lifecycle.repeatOnLifecycle — аналогичная функция, но только для Lifecycle.

🔸Flow.flowWithLifecycle — этот API использует предыдущую функцию под капотом и также закрывает «продьюсера» в момент противоположного состояния жизненного цикла. Кроме этого, данную фукнцию можно встроить напрямую в целочку вызова Flow, что делает вызов более лаконичным. Важно помнить, что эта функция работает по аналогии с Flow.flowOn, которая затрагивает только цепочку, которая выше неё и добавляет буфер для предотвращения backpressure.

В целом, в статье упоминается то, что теперь можно полностью эмитировать поведение LiveData и использовать Flow в приложениях, где вы хотите использовать только Kotlin API. Это здорово, но пока API находится в alpha-версии и стоит тащить его к себе аккуратно.

Кроме этого, если вам это нужно, добавили поддержку data binding для Flow. Детали тут.

​​Kotlin Flows — шпаргалка
#flow

Многие на своих проектах уже давно используют Flow в связке с Coroutines. На канале также было несколько постов о том, как лучше использовать эту связку и на что стоит обратить внимание.

Вот вам ещё одна небольшая заметка про Flow, где автор собрал в одну таблицу краткую информацию о них и о всех существующих типах Flow: в чём их разница, какие есть эквиваленты в RxJava, ссылки на документацию, примеры кода, где лучше применить их в Android.

Для тех, кто хочет шпаргалку сразу в pdf — вот ссылка, а сама статья с описание тут.

​​Операторы shareIn и stateIn
#kotlin #flow

Операторы позволяют конвертировать cold flow в hot flow: они могут передавать информацию, которая приходит от потока и транслировать её нескольким подписчикам.
Эти операторы используются, если требуется улучшить производительность, добавить буфер, если нет подписчиков, ну или добавить механизм кэширования.

Между shareIn и stateIn по сути, существует только одна разница: первый преобразует Flow в SharedFlow, а второй — в StateFlow.

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

Главное запомнить, что никогда не стоит использовать эти операторы при возвращении Flow из функции: в этом случае у вас будет создаваться новый SharedFlow или StateFlow при каждом вызове функции, и он будет оставаться в памяти до тех пор, пока не очистится Scope или GB не уберёт его при отсутствии ссылок. В любом случае, это поведение неверное.

​​Ещё про миграцию с LiveData на Flow
#flow #livedata

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

Ну и как всегда, описывается, что такое SharedFlow и StateFlow, то, какие параметры там есть, и что они значат. Есть отличные примеры стратегий у Flow и то, когда какая подойдёт для использования.

В общем, рекомендую статью для всех, кто ещё думает о переезде или хочет лучше понять использование Flow в реальных проектах.

​​Серия статей Flows и Channels
#flow #kotlin

Крутая серия статей, которая посвящена более глубокой проработке вопроса, связанного с Flow и Channel.

Автор начинает рассказ с общего понятия потоков, cold и hot streams, их разницы и кейсов применения. Так что это всё подойдёт тем, кто совсем не в теме и хочет детально с этим разобраться.

Серия состоит из 5 частей и охватывает большинство кейсов. Ссылка на первую часть тут.
А вот и пример, где автор применяет полученные знания на практике.

​​Kotlin callbackFlow — пример использования
#kotlin #flow

Flow в Kotlin — очень крутой API, который, по мнению Google, является рекомендуемым подходом для передачи данных между слоями архитектуры в приложении наряду с suspend-функциями.
Спорить не буду, так как сам давно использую Flow на всех уровнях приложения, постепенно вытесняя LiveData из проекта.

Одной из реализаций Flow является callbackFlow, который позвляет делать обёртки для данных, поставляемых через callback. Это очень удобно: например, можно оборачивать различные функции из Firebase или же встроенные в Adroid сервисы.

Автор статьи описал реализацию callbackFlow с обёрткой над получением информации о геолокации пользователя. Вышло более чем хорошо: пользователю данного сервиса остаётся лишь подписаться на изменения Flow и не заботиться о работе того, что находится под капотом.
Кроме того, автор коснулся вопросов, связанных с «шэрингом» этого Flow между разными пользователями без дублирования подписок.

Рекомендую статью, если хотите сделать свой код ещё более качественным с Flow.💪

​​Kotlin Flows in Android summary
#android #flow

Тут есть отличная статья, которая рассказывает об использовании Flow в Android. Некий краткий summary о том, что нужно знать с самого начала их использования.

Тут и про то, как их создавать, какие типы есть, о различных типах Dispatcher, всевозможных операторах, исключениях и т.д.

В общем, крайне рекомендую, можно сохранить в закладки.

​​Flow под капотом
#flow

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

Автор утверждает, что сама концепция Flow — проще, чем многие разработчики думают: под капотом описано много простых механизмов, которые после объединения и выдают то, что мы привыкли видеть при использовании Flow.

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