Kotlin Flow in Android with Example

package org.geeksforgeeks.demo

import com.google.gson.annotations.SerializedName

data class CommentModel(
    val postId: Int?=null,
    val id: Int?=null,
    val email: String?=null,
    val name:String?=null,

    @SerializedName("body")
    val comment: String?=null
)

package org.geeksforgeeks.demo

import retrofit2.http.GET
import retrofit2.http.Path

interface ApiService {
    // Get method to call the api ,passing id as a path
    @GET("/comments/{id}")
    suspend fun getComments(@Path("id") id: Int): CommentModel
}

package org.geeksforgeeks.demo

data class CommentApiState<out T> (
    val status: Status,
    val data: T?,
    val message: String?
) {
    companion object {
        // In case of Success,set status as
        // Success and data as the response
        fun <T> success(data: T?): CommentApiState<T> {
            return CommentApiState(Status.SUCCESS, data, null)
        }

        // In case of failure ,set state to Error ,
        // add the error message,set data to null
        fun <T> error(msg: String): CommentApiState<T> {
            return CommentApiState(Status.ERROR, null, msg)
        }

        // When the call is loading set the state
        // as Loading and rest as null
        fun <T> loading(): CommentApiState<T> {
            return CommentApiState(Status.LOADING, null, null)
        }
    }
}

// An enum to store the
// current state of api call
enum class Status {
    SUCCESS,
    ERROR,
    LOADING
}

package org.geeksforgeeks.demo

import com.google.gson.GsonBuilder
import retrofit2.Retrofit
import retrofit2.converter.gson.GsonConverterFactory

object RetrofitInstance {
    // Base url of the api
    private const val BASE_URL = "https://jsonplaceholder.typicode.com/"

    // create retrofit service
    fun apiService(): ApiService =
        Retrofit.Builder().baseUrl(BASE_URL)
            .addConverterFactory(GsonConverterFactory.create(GsonBuilder().create()))
            .build()
            .create(ApiService::class.java)
}

package org.geeksforgeeks.demo

import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.flow
import kotlinx.coroutines.flow.flowOn

class CommentsRepository(private val apiService: ApiService) {
    fun getComment(id: Int): Flow<CommentApiState<CommentModel>> {
        return flow {
            // get the comment Data from the api
            val comment= apiService.getComments(id)

            // Emit this data wrapped in
            // the helper class [CommentApiState]
            emit(CommentApiState.success(comment))
        }.flowOn(Dispatchers.IO)
    }
}

package org.geeksforgeeks.demo

import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.catch
import kotlinx.coroutines.launch

class CommentsViewModel : ViewModel() {
    // initialize the repo and pass the api service as parameter
    private val repository = CommentsRepository(
        RetrofitInstance.apiService()
    )

    // MutableStateFlow to store comment data
    val commentState = MutableStateFlow(
        CommentApiState(
            Status.LOADING,
            CommentModel(), ""
        )
    )

    init {
        // Initiate a starting search with comment Id 1
        getNewComment(1)
    }

    // Function to get new Comments
    fun getNewComment(id: Int) {
        // initialize state as loading
        commentState.value = CommentApiState.loading()

        // use coroutine scope to let the api call run asynchronously
        viewModelScope.launch {
            // Collecting the data emitted by the function in repository
            repository.getComment(id)
                // handle errors like 404 not found, invalid id etc
                .catch {
                    commentState.value =
                        CommentApiState.error(it.message.toString())
                }
                // on the success response, data is set to state for observing and updating
                .collect {
                    commentState.value = CommentApiState.success(it.data)
                }
        }
    }
}

package org.geeksforgeeks.demo

import android.os.Bundle
import android.widget.Toast
import androidx.appcompat.app.AppCompatActivity
import androidx.core.view.isVisible
import androidx.lifecycle.ViewModelProvider
import androidx.lifecycle.lifecycleScope
import kotlinx.coroutines.launch
import org.geeksforgeeks.demo.databinding.ActivityMainBinding

class MainActivity : AppCompatActivity() {
    // initiate the viewmodel
    private val viewModel: CommentsViewModel by lazy {
        ViewModelProvider(this)[CommentsViewModel::class.java]
    }
    // create a view binding variable
    private val binding: ActivityMainBinding by lazy {
        ActivityMainBinding.inflate(layoutInflater)
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(binding.root)

        // set on click listener for search button
        binding.button.setOnClickListener {
            val id = binding.searchEditText.text.toString().trim()
            // check to prevent api call with no parameters
            if (id.isEmpty() || id == "0") {
                Toast.makeText(this, "Id Can't be 0 or empty", Toast.LENGTH_SHORT).show()
            } else {
                // if id isn't empty, make the api call
                viewModel.getNewComment(id.toInt())
            }
        }

        // Since flow run asynchronously, start listening on background thread
        lifecycleScope.launch {
            viewModel.commentState.collect {
                // When state to check the state of received data
                when (it.status) {
                    // on loading, show the progress bar
                    Status.LOADING -> {
                        binding.progressBar.isVisible = true
                    }
                    // on success, update ui and make progress bar invisible
                    Status.SUCCESS -> {
                        binding.progressBar.isVisible = false
                        // handle null pointer exception
                        it.data?.let { comment ->
                            binding.commentIdTextview.text = comment.id.toString()
                            binding.nameTextview.text = comment.name
                            binding.emailTextview.text = comment.email
                            binding.commentTextview.text = comment.comment
                        }
                    }
                    // on error, show toast with error message
                    else -> {
                        binding.progressBar.isVisible = false
                        Toast.makeText(this@MainActivity, "${it.message}", Toast.LENGTH_SHORT).show()
                    }
                }
            }
        }
    }
}