<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Ugurcan Yildirim on Medium]]></title>
        <description><![CDATA[Stories by Ugurcan Yildirim on Medium]]></description>
        <link>https://medium.com/@ugurcany?source=rss-f06f421b6c52------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*QTJSVO8t2_lPJfHWtwWhXw.jpeg</url>
            <title>Stories by Ugurcan Yildirim on Medium</title>
            <link>https://medium.com/@ugurcany?source=rss-f06f421b6c52------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 12:07:26 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@ugurcany/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Paging in Android Jetpack Compose: From Caching Data with Room to Displaying in LazyColumn]]></title>
            <link>https://proandroiddev.com/paging-in-android-jetpack-compose-from-caching-data-with-room-to-displaying-in-lazycolumn-a018f0b6cb2?source=rss-f06f421b6c52------2</link>
            <guid isPermaLink="false">https://medium.com/p/a018f0b6cb2</guid>
            <category><![CDATA[android]]></category>
            <category><![CDATA[kotlin]]></category>
            <category><![CDATA[caching]]></category>
            <category><![CDATA[pagination]]></category>
            <category><![CDATA[jetpack-compose]]></category>
            <dc:creator><![CDATA[Ugurcan Yildirim]]></dc:creator>
            <pubDate>Tue, 27 Jun 2023 20:47:23 GMT</pubDate>
            <atom:updated>2025-05-26T21:17:31.406Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0DqVerO5Y3gIiWgDfA9uJQ.png" /></figure><p>In almost any kind of mobile project, we, mobile developers, find ourselves dealing with paginated data at some point. It’s a necessity if the list of data is too much to retrieve from server in one call. Therefore, our backend colleagues provide us with an endpoint that returns the list of data in pages, and expect us to know how to deal with it on the client side.</p><p>In this article, we will focus on how to fetch, cache, and display paginated data using the latest methods recommended by Android, as of June 2023. We will go through the following steps:</p><ul><li>Fetch the list of Pokemon data in pages from a <a href="https://graphql-pokeapi.graphcdn.app/graphql">public GraphQL API</a></li><li>Cache the fetched data in local database using <a href="https://developer.android.com/training/data-storage/room"><strong>Room</strong></a></li><li>Use the latest <a href="https://developer.android.com/topic/libraries/architecture/paging/v3-overview"><strong>Paging library</strong></a> components to handle pagination</li><li>Display page items smartly (rendering only what is being visible) using <a href="https://developer.android.com/jetpack/compose/lists"><strong>LazyColumn</strong></a></li></ul><p>For the sample project, of which I will share the GitHub repository at the end of the article, we will utilize <a href="https://developer.android.com/training/dependency-injection/hilt-android"><strong>Hilt</strong></a> as our dependency injection library and use <a href="https://blog.cleancoder.com/uncle-bob/2012/08/13/the-clean-architecture.html"><strong>Clean Architecture</strong></a> (presentation → domain ← data). So, I will explain things starting from the data layer, then move to the domain layer, and conclude with the presentation layer.</p><h3>Data Layer</h3><p>This layer is where by far most of the stuff is going on about pagination and caching. So, if you can make it through this section, you will be mostly done with it.</p><h4>Remote Data Source</h4><p>As the remote data source, we will use a <a href="https://graphql-pokeapi.graphcdn.app/graphql">public GraphQL Pokemon API</a>. As opposed to Retrofit, which is what we use to interact with REST APIs, we use <strong>Apollo</strong>’s <a href="https://www.apollographql.com/docs/kotlin/">Kotlin client</a> for GraphQL APIs. It allows us to execute GraphQL queries and automatically generates Kotlin models from requests and responses.</p><p>First, we need to add the following lines to our module level build.gradle file:</p><pre>plugins {<br>    // ...<br>    id &quot;com.apollographql.apollo3&quot; version &quot;$apollo_version&quot;<br>}<br><br>apollo {<br>    service(&quot;pokemon&quot;) {<br>        packageName.set(&quot;dev.thunderbolt.pokemonpager.data&quot;)<br>    }<br>}<br><br>dependencies {<br>    // ...<br>    implementation &quot;com.apollographql.apollo3:apollo-runtime:$apollo_version&quot;<br>}</pre><p>Here in the apollo block, we set the configuration of the Apollo library. It provides many settings, all of which you can check through its <a href="https://www.apollographql.com/docs/kotlin/advanced/plugin-configuration/">documentation</a>. For now, we just need to set the package name to dev.thunderbolt.pokemonpager.data so that the generated Kotlin files will be under the correct package, which is the data layer.</p><p>Then, we need to download the server’s schema, so the library will be able to generate models and we will be able to write queries with autocomplete. In order to download the schema, we use the following command provided by Apollo:</p><pre>./gradlew :app:downloadApolloSchema --endpoint=&#39;https://graphql-pokeapi.graphcdn.app/graphql&#39; --schema=app/src/main/graphql/schema.graphqls</pre><p>This will download the server’s schema in the directory of app/src/main/graphql/schema.graphqls.</p><p>Now, it’s time to write our query in a file named pokemon.graphql which we created in the same folder as the schema file.</p><pre>query PokemonList(<br>    $offset: Int!<br>    $limit: Int!<br>) {<br>    pokemons(<br>        offset: $offset,<br>        limit: $limit<br>    ) {<br>        nextOffset<br>        results {<br>            id<br>            name<br>            image<br>        }<br>    }<br>}</pre><p>When we build our project, Apollo Kotlin will generate the models for this query by automatically running a Gradle task named generateApolloSources.</p><p>Going back to the Kotlin world, we will define our PokemonApi class to encapsulate all of our interactions with the GraphQL, as follows:</p><pre>class PokemonApi {<br><br>    private val BASE_URL = &quot;https://graphql-pokeapi.graphcdn.app/graphql&quot;<br><br>    private val apolloClient = ApolloClient.Builder()<br>        .serverUrl(BASE_URL)<br>        .addHttpInterceptor(LoggingInterceptor())<br>        .build()<br><br>    suspend fun getPokemonList(offset: Int, limit: Int): PokemonListQuery.Pokemons? {<br>        val response = apolloClient.query(<br>            PokemonListQuery(<br>                offset = offset,<br>                limit = limit,<br>            )<br>        ).execute()<br>        // IF RESPONSE HAS ERRORS OR DATA IS NULL, THROW EXCEPTION<br>        if (response.hasErrors() || response.data == null) {<br>            throw ApolloException(response.errors.toString())<br>        }<br>        return response.data!!.pokemons<br>    }<br>}</pre><p>Here, we initialize our <strong>Apollo Client</strong> instance with required configuration, and implement our function to execute the generated Kotlin version of the query which we wrote in the pokemon.graphql file. This function basically gets offset and limit parameters, executes the query, and if everything goes well, returns the response of the query, which is again auto-generated by Apollo.</p><h4>Local Data Source/Storage</h4><p>To store relational data locally and create an offline-first app, we will depend on <a href="https://developer.android.com/training/data-storage/room"><strong>Room</strong></a>, which is an Android persistence library written over SQLite.</p><p>First, we need to add the Room dependencies to our build.gradle file:</p><pre>dependencies {<br>    // ...<br>    implementation &quot;androidx.room:room-ktx:$room_version&quot;<br>    kapt &quot;androidx.room:room-compiler:$room_version&quot;<br>    implementation &quot;androidx.room:room-paging:$room_version&quot;<br>}</pre><p>Then, we will define two <strong>entity</strong> classes, one for storing Pokemon data in our database, and another to keep track of the number of the page to be fetched next.</p><pre>@Entity(&quot;pokemon&quot;)<br>data class PokemonEntity(<br>    @PrimaryKey val id: Int,<br>    val name: String,<br>    val imageUrl: String,<br>)<br><br>@Entity(&quot;remote_key&quot;)<br>data class RemoteKeyEntity(<br>    @PrimaryKey val id: String,<br>    val nextOffset: Int,<br>)</pre><p>In relation to these, we also need two <strong>DAO</strong> (Data Access Object) classes to define all of our database interactions in them.</p><pre>@Dao<br>interface PokemonDao {<br>    @Insert(onConflict = OnConflictStrategy.REPLACE)<br>    suspend fun insertAll(items: List&lt;PokemonEntity&gt;)<br><br>    @Query(&quot;SELECT * FROM pokemon&quot;)<br>    fun pagingSource(): PagingSource&lt;Int, PokemonEntity&gt;<br><br>    @Query(&quot;DELETE FROM pokemon&quot;)<br>    suspend fun clearAll()<br>}<br><br>@Dao<br>interface RemoteKeyDao {<br>    @Insert(onConflict = OnConflictStrategy.REPLACE)<br>    suspend fun insert(item: RemoteKeyEntity)<br><br>    @Query(&quot;SELECT * FROM remote_key WHERE id = :id&quot;)<br>    suspend fun getById(id: String): RemoteKeyEntity?<br><br>    @Query(&quot;DELETE FROM remote_key WHERE id = :id&quot;)<br>    suspend fun deleteById(id: String)<br>}</pre><p>Here, the critical function we need to pay attention to is the pagingSource() one. Room is able to return list of data as PagingSource, so that our Pager object (which we will create later) will use it as the single source to generate a flow of PagingData.</p><p>Finally, we need to have a <a href="https://developer.android.com/reference/androidx/room/RoomDatabase"><strong>RoomDatabase</strong></a> class that creates tables for these entities in the local database and provides the DAOs to interact with the tables.</p><pre>@Database(<br>    entities = [PokemonEntity::class, RemoteKeyEntity::class],<br>    version = 1,<br>)<br>abstract class PokemonDatabase : RoomDatabase() {<br>    abstract val pokemonDao: PokemonDao<br>    abstract val remoteKeyDao: RemoteKeyDao<br>}</pre><p>Both of this PokemonDatabase and previously defined PokemonApi classes are instantiated and provided as singleton instances by the Hilt module of our data layer.</p><pre>@Module<br>@InstallIn(SingletonComponent::class)<br>class DataModule {<br><br>    @Provides<br>    @Singleton<br>    fun providePokemonDatabase(@ApplicationContext context: Context): PokemonDatabase {<br>        return Room.databaseBuilder(<br>            context,<br>            PokemonDatabase::class.java,<br>            &quot;pokemon.db&quot;,<br>        ).fallbackToDestructiveMigration().build()<br>    }<br><br>    @Provides<br>    @Singleton<br>    fun providePokemonApi(): PokemonApi {<br>        return PokemonApi()<br>    }<br><br>    // ...<br>}</pre><h4>Remote Mediator</h4><p>Now, it’s time to implement our <strong>RemoteMediator</strong> class, which will be responsible for loading paginated data from the remote API into the local database whenever needed. It’s important to note that remote mediator does not provide data directly to the UI. If paginated data gets exhausted, Paging library triggers remote mediator’s load(…) method to fetch and store more data locally. Therefore, our local database can always remain the <strong>single source of truth</strong>.</p><pre>class PokemonRemoteMediator @Inject constructor(<br>    private val pokemonDatabase: PokemonDatabase,<br>    private val pokemonApi: PokemonApi,<br>) : RemoteMediator&lt;Int, PokemonEntity&gt;() {<br><br>    private val REMOTE_KEY_ID = &quot;pokemon&quot;<br><br>    override suspend fun load(<br>        loadType: LoadType,<br>        state: PagingState&lt;Int, PokemonEntity&gt;,<br>    ): MediatorResult {<br>        return try {<br>            val offset = when (loadType) {<br>                LoadType.REFRESH -&gt; 0<br>                LoadType.PREPEND -&gt; return MediatorResult.Success(endOfPaginationReached = true)<br>                LoadType.APPEND -&gt; {<br>                    // RETRIEVE NEXT OFFSET FROM DATABASE<br>                    val remoteKey = pokemonDatabase.remoteKeyDao.getById(REMOTE_KEY_ID)<br>                    if (remoteKey == null || remoteKey.nextOffset == 0) // END OF PAGINATION REACHED<br>                        return MediatorResult.Success(endOfPaginationReached = true)<br>                    remoteKey.nextOffset<br>                }<br>            }<br>            // MAKE API CALL<br>            val apiResponse = pokemonApi.getPokemonList(<br>                offset = offset,<br>                limit = state.config.pageSize,<br>            )<br>            val results = apiResponse?.results ?: emptyList()<br>            val nextOffset = apiResponse?.nextOffset ?: 0<br>            // SAVE RESULTS AND NEXT OFFSET TO DATABASE<br>            pokemonDatabase.withTransaction {<br>                if (loadType == LoadType.REFRESH) {<br>                    // IF REFRESHING, CLEAR DATABASE FIRST<br>                    pokemonDatabase.pokemonDao.clearAll()<br>                    pokemonDatabase.remoteKeyDao.deleteById(REMOTE_KEY_ID)<br>                }<br>                pokemonDatabase.pokemonDao.insertAll(<br>                    results.mapNotNull { it?.toPokemonEntity() }<br>                )<br>                pokemonDatabase.remoteKeyDao.insert(<br>                    RemoteKeyEntity(<br>                        id = REMOTE_KEY_ID,<br>                        nextOffset = nextOffset,<br>                    )<br>                )<br>            }<br>            // CHECK IF END OF PAGINATION REACHED<br>            MediatorResult.Success(endOfPaginationReached = results.size &lt; state.config.pageSize)<br>        } catch (e: ApolloException) {<br>            MediatorResult.Error(e)<br>        }<br>    }<br>}</pre><p>In the load(…) function, we first need to check which type of load we are dealing with. If <strong>LoadType</strong> is…</p><ul><li>REFRESH, it means that we are either at the initial load, or data somehow got invalidated and we need to fetch data from scratch. So, if this is the case, we set our offset value to “0” as we would like to fetch the first page of data.</li><li>PREPEND, we need to fetch the page of data that comes before the current page. This is not needed in the scope of this example as we don’t want to fetch anything while scrolling to the top. Therefore, we simply return MediatorResult.Success(endOfPaginationReached = true) to indicate that data loading should not occur anymore.</li><li>APPEND, we need to fetch the page of data that comes after the current page. In this case, we go and fetch the remote key object which should be already stored in our local database by the previous data load. If there is none or its nextOffset value is “0”, this means that there is no more data to be loaded and appended. This is how this API works, by the way. Your API might indicate the end of data differently, so you need to write your APPEND logic accordingly.</li></ul><p>After we decided the correct value of offset, now it’s time to make API call using this offset and also the pageSize provided in the config. We will set the page size when we create our Pager object in the next step.</p><p>If the API call successfully returns a new page of data, we store the items and also the next offset value in our database using corresponding DAO functions. Here, we need to execute all database interactions within a transaction block, so that if any interaction fails, no change will be made to the database.</p><p>Finally, if everything goes well after database calls, we return a MediatorResult.Success checking if we’ve reached the end of pagination by comparing the number of items returned by the latest load with the page size we will define in the config.</p><h4>Pager</h4><p>Now, we’re going back to our data layer’s Hilt module again and we will create our <strong>Pager</strong> object. This object will bring all we’ve defined up until now together, and work as the constructor for the PagingData flow.</p><pre>@Module<br>@InstallIn(SingletonComponent::class)<br>class DataModule {<br><br>    // ...<br><br>    @Provides<br>    @Singleton<br>    fun providePokemonPager(<br>        pokemonDatabase: PokemonDatabase,<br>        pokemonApi: PokemonApi,<br>    ): Pager&lt;Int, PokemonEntity&gt; {<br>        return Pager(<br>            config = PagingConfig(pageSize = 20),<br>            remoteMediator = PokemonRemoteMediator(<br>                pokemonDatabase = pokemonDatabase,<br>                pokemonApi = pokemonApi,<br>            ),<br>            pagingSourceFactory = {<br>                pokemonDatabase.pokemonDao.pagingSource()<br>            },<br>        )<br>    }<br>}</pre><p>Here, we provide three things to the constructor of Pager. First, we set a PagingConfig with a desired page size, as I mentioned before. Second, we provide our remote mediator instance. And third, we set the paging source provided by Room as the single source of data for our Pager.</p><h4>Repository</h4><p>As we’ve done much of the work in our remote mediator, our <strong>repository implementation</strong> will be quite simple.</p><pre>class PokemonRepositoryImpl @Inject constructor(<br>    private val pokemonPager: Pager&lt;Int, PokemonEntity&gt;<br>) : PokemonRepository {<br><br>    override fun getPokemonList(): Flow&lt;PagingData&lt;Pokemon&gt;&gt; {<br>        return pokemonPager.flow.map { pagingData -&gt;<br>            pagingData.map { it.toPokemon() }<br>        }<br>    }<br>}</pre><p>Using our Pager instance, we simply return its flow of PagingData to consumers. However before doing that, we also need to map PokemonEntity to domain’s Pokemon model. It’s because our domain layer does not know anything about data or presentation layers as the basis of Clean Architecture, so we should not carry our data models to domain layer.</p><h3>Domain Layer</h3><p>In this pure Kotlin layer, nothing much is going on actually. Here, we have our <strong>Pokemon</strong> model, our <strong>repository interface</strong>, and a simple <strong>use case</strong> class that interacts with this repository.</p><pre>// REPOSITORY INTERFACE<br>interface PokemonRepository {<br>    fun getPokemonList(): Flow&lt;PagingData&lt;Pokemon&gt;&gt;<br>}<br><br>// USE CASE<br>class GetPokemonList @Inject constructor(<br>    private val pokemonRepository: PokemonRepository<br>) {<br>    operator fun invoke(): Flow&lt;PagingData&lt;Pokemon&gt;&gt; {<br>        return pokemonRepository.getPokemonList()<br>            .flowOn(Dispatchers.IO)<br>    }<br>}<br><br>// MODEL<br>data class Pokemon(<br>    val id: Int,<br>    val name: String,<br>    val imageUrl: String,<br>)</pre><p>Here, one question you might have in your mind can be how to use PagingData in a pure Kotlin layer where we have no dependency on any Android component. It’s actually simple: There is a specific dependency provided by the Paging library for non-Android modules, so that we can access all simple Paging components like PagingSource, PagingData, Pager, and even RemoteMediator.</p><pre>dependencies {<br>    // ...<br>    implementation &quot;androidx.paging:paging-common:$paging_version&quot;<br>}</pre><h3>Presentation Layer</h3><p>After this quick coverage of the domain layer, let’s jump directly into the presentation layer, where the rest of the critical stuff is going on. But first, we need to add the following Paging dependencies to our build.gradle file:</p><pre>dependencies {<br>    // ...<br>    implementation &quot;androidx.paging:paging-runtime-ktx:$paging_version&quot;<br>    implementation &quot;androidx.paging:paging-compose:$paging_version&quot;<br>}</pre><p>Other than the runtime-ktx dependency, the compose dependency is also required here since it provides some intermediaries between our paging data flow and UI.</p><h4>ViewModel</h4><p>This is again one of the simple classes of this article, where we simply get the flow provided by the use case (to which it was already provided by the repository), and store it in a value.</p><pre>@HiltViewModel<br>class PokemonListViewModel @Inject constructor(<br>    private val getPokemonList: GetPokemonList<br>) : ViewModel() {<br><br>    val pokemonPagingDataFlow: Flow&lt;PagingData&lt;Pokemon&gt;&gt; = getPokemonList()<br>        .cachedIn(viewModelScope)<br>}</pre><p>We store the flow by calling cachedIn(viewModelScope) so that it’s kept active as long as the lifetime of our ViewModel. Besides that, it survives configuration changes like screen rotation, so that you get the same existing data rather than fetching it from scratch.</p><p>This method also keeps our cold flow as it is and does not turn it into a hot flow (StateFlow) as the stateIn(…) method would do. This means that if the flow is not being collected, no unnecessary code will be executed.</p><h4>Screen (UI)</h4><p>Now, we are at the final step of our pagination, where we will display our paging items in a <strong>LazyColumn</strong>. There are no RecylerViews or adapters anymore in Jetpack Compose. All these are now handled underneath and our large number of items are still laid out smartly, without causing any performance issues.</p><pre>@Composable<br>fun PokemonListScreen(<br>    snackbarHostState: SnackbarHostState<br>) {<br>    val viewModel = hiltViewModel&lt;PokemonListViewModel&gt;()<br>    val pokemonPagingItems = viewModel.pokemonPagingDataFlow.collectAsLazyPagingItems()<br><br>    if (pokemonPagingItems.loadState.refresh is LoadState.Error) {<br>        LaunchedEffect(key1 = snackbarHostState) {<br>            snackbarHostState.showSnackbar(<br>                (pokemonPagingItems.loadState.refresh as LoadState.Error).error.message ?: &quot;&quot;<br>            )<br>        }<br>    }<br><br>    Box(modifier = Modifier.fillMaxSize()) {<br>        if (pokemonPagingItems.loadState.refresh is LoadState.Loading) {<br>            CircularProgressIndicator(modifier = Modifier.align(Alignment.Center))<br>        } else {<br>            LazyColumn(<br>                modifier = Modifier.fillMaxSize(),<br>                horizontalAlignment = Alignment.CenterHorizontally,<br>            ) {<br>                items(<br>                    count = pokemonPagingItems.itemCount,<br>                    key = pokemonPagingItems.itemKey { it.id },<br>                ) { index -&gt;<br>                    val pokemon = pokemonPagingItems[index]<br>                    if (pokemon != null) {<br>                        PokemonItem(<br>                            pokemon,<br>                            modifier = Modifier.fillMaxWidth(),<br>                        )<br>                    }<br>                }<br>                item {<br>                    if (pokemonPagingItems.loadState.append is LoadState.Loading) {<br>                        CircularProgressIndicator(modifier = Modifier.padding(16.dp))<br>                    }<br>                }<br>            }<br>        }<br>    }<br>}</pre><p>The first thing to do in our composable screen is to create our ViewModel instance and collect the paging data flow stored in it using the helper function collectAsLazyPagingItems(). This converts the cold flow into a LazyPagingItems instance. Through this instance, we can access the items that are already loaded, as well as different load states to change UI accordingly. In addition to these, we can even trigger data refresh or retry of a previously failed load using this instance.</p><p>In a Box layout, if the “refresh” load state of LazyPagingItems is Loading, then we know that we are at the initial load and there are no items to show yet. Therefore, we show a progress indicator. Otherwise, we display a LazyColumn, together with the list of items whose count and key parameters are set using our LazyPagingItems instance. And in each item, we simply access the corresponding Pokemon object using the given index and render a PokemonItem composable, whose implementation details are not given here for the sake of simplicity.</p><p>We also have a specific case where we need to show a loading indicator below these items. And that happens every time we are in the process of fetching more data, which is detectable through the “append” load state of LazyPagingItems. Therefore, if that’s the case, we append a progress indicator to the end of the list.</p><p>And finally, do not think we missed the <strong>LaunchedEffect</strong> part at the beginning. The LaunchedEffect composables are used to safely call suspend functions inside a composable. We need a coroutine scope to show a Snackbar in Jetpack Compose since SnackbarHostState.showSnackbar(…) is a suspend function. And here, we show a snackbar message in case of refresh errors, which basically corresponds to “initial load” errors in our case. However, as I mentioned earlier, here we’ve built an offline-first app, so if we have already data cached in Room, the user will see that, together with the error message.</p><p>I hope you could bear with me throughout this challenging journey of <strong>pagination</strong> and <strong>caching</strong> in Android Jetpack Compose. I tried to stick to the latest and recommended ways of doing things. Please feel free to point out mistakes or whatever can be done better. The entire project is already shared as a <a href="https://github.com/ugurcany/Pokemon-Pager"><strong>GitHub repository</strong></a>, so that you can download and play with it.</p><p>See you until the next article on another fuzzy topic from the Android universe.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a018f0b6cb2" width="1" height="1" alt=""><hr><p><a href="https://proandroiddev.com/paging-in-android-jetpack-compose-from-caching-data-with-room-to-displaying-in-lazycolumn-a018f0b6cb2">Paging in Android Jetpack Compose: From Caching Data with Room to Displaying in LazyColumn</a> was originally published in <a href="https://proandroiddev.com/">ProAndroidDev</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Lifecycle Automation of a Flutter Project With GitHub Actions]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://medium.com/better-programming/lifecycle-automation-of-a-flutter-project-with-github-actions-e26b8f106467?source=rss-f06f421b6c52------2"><img src="https://cdn-images-1.medium.com/max/1500/1*fjWYnmrgBYGDuitPfp6aqQ.png" width="1500"></a></p><p class="medium-feed-snippet">Building and distributing an APK</p><p class="medium-feed-link"><a href="https://medium.com/better-programming/lifecycle-automation-of-a-flutter-project-with-github-actions-e26b8f106467?source=rss-f06f421b6c52------2">Continue reading on Better Programming »</a></p></div>]]></description>
            <link>https://medium.com/better-programming/lifecycle-automation-of-a-flutter-project-with-github-actions-e26b8f106467?source=rss-f06f421b6c52------2</link>
            <guid isPermaLink="false">https://medium.com/p/e26b8f106467</guid>
            <category><![CDATA[github-actions]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[continuous-deployment]]></category>
            <category><![CDATA[automation]]></category>
            <category><![CDATA[flutter]]></category>
            <dc:creator><![CDATA[Ugurcan Yildirim]]></dc:creator>
            <pubDate>Mon, 31 Aug 2020 20:40:16 GMT</pubDate>
            <atom:updated>2020-08-31T20:40:16.730Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[Using Clean Architecture in Flutter]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://codeburst.io/using-clean-architecture-in-flutter-d0437d0c7f87?source=rss-f06f421b6c52------2"><img src="https://cdn-images-1.medium.com/max/1000/1*KMFfH606QaOzA73qNRD9dw.png" width="1000"></a></p><p class="medium-feed-snippet">It&#x2019;s time to learn why clean architecture is so important and how to use it in a Flutter app.</p><p class="medium-feed-link"><a href="https://codeburst.io/using-clean-architecture-in-flutter-d0437d0c7f87?source=rss-f06f421b6c52------2">Continue reading on codeburst »</a></p></div>]]></description>
            <link>https://codeburst.io/using-clean-architecture-in-flutter-d0437d0c7f87?source=rss-f06f421b6c52------2</link>
            <guid isPermaLink="false">https://medium.com/p/d0437d0c7f87</guid>
            <category><![CDATA[flutter]]></category>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[clean-architecture]]></category>
            <category><![CDATA[mobile-app-development]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Ugurcan Yildirim]]></dc:creator>
            <pubDate>Sat, 04 Jul 2020 21:39:14 GMT</pubDate>
            <atom:updated>2020-08-23T13:01:02.953Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[Implementing Firebase GitHub Authentication in Flutter]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://medium.com/flutter-community/implementing-firebase-github-authentication-in-flutter-1c49a172c648?source=rss-f06f421b6c52------2"><img src="https://cdn-images-1.medium.com/max/2000/1*A3r1H8numVM3MnqiPKastg.png" width="2000"></a></p><p class="medium-feed-snippet">In this article, I&#x2019;m going to show you how to implement Firebase GitHub authentication method properly in Flutter. As you might already&#x2026;</p><p class="medium-feed-link"><a href="https://medium.com/flutter-community/implementing-firebase-github-authentication-in-flutter-1c49a172c648?source=rss-f06f421b6c52------2">Continue reading on Flutter Community »</a></p></div>]]></description>
            <link>https://medium.com/flutter-community/implementing-firebase-github-authentication-in-flutter-1c49a172c648?source=rss-f06f421b6c52------2</link>
            <guid isPermaLink="false">https://medium.com/p/1c49a172c648</guid>
            <category><![CDATA[firebase]]></category>
            <category><![CDATA[authentication]]></category>
            <category><![CDATA[mobile-app-development]]></category>
            <category><![CDATA[flutter]]></category>
            <category><![CDATA[github]]></category>
            <dc:creator><![CDATA[Ugurcan Yildirim]]></dc:creator>
            <pubDate>Tue, 26 Mar 2019 17:02:45 GMT</pubDate>
            <atom:updated>2020-04-24T09:36:51.638Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[Google’s Flutter in 10 Questions & Answers]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://medium.com/hackernoon/googles-flutter-in-10-questions-answers-928e142ec725?source=rss-f06f421b6c52------2"><img src="https://cdn-images-1.medium.com/max/960/1*V_GASlbQGfZeTqp1AgfwCw.png" width="960"></a></p><p class="medium-feed-snippet">For the past couple of months, I&#x2019;ve had chance to research and practice what Flutter is capable of. I&#x2019;ve read many articles about it, as&#x2026;</p><p class="medium-feed-link"><a href="https://medium.com/hackernoon/googles-flutter-in-10-questions-answers-928e142ec725?source=rss-f06f421b6c52------2">Continue reading on HackerNoon.com »</a></p></div>]]></description>
            <link>https://medium.com/hackernoon/googles-flutter-in-10-questions-answers-928e142ec725?source=rss-f06f421b6c52------2</link>
            <guid isPermaLink="false">https://medium.com/p/928e142ec725</guid>
            <category><![CDATA[mobile-app-development]]></category>
            <category><![CDATA[ios-app-development]]></category>
            <category><![CDATA[android-app-development]]></category>
            <category><![CDATA[flutter]]></category>
            <category><![CDATA[programming]]></category>
            <dc:creator><![CDATA[Ugurcan Yildirim]]></dc:creator>
            <pubDate>Mon, 28 Jan 2019 18:38:33 GMT</pubDate>
            <atom:updated>2019-03-30T15:15:43.612Z</atom:updated>
        </item>
    </channel>
</rss>