Organization of simple architecture in an Android application with a bunch of ViewModel + LiveData, Retrofit + Coroutines

Without long introductions, I’ll tell you how to quickly and easily organize a convenient architecture for your application. The material will be useful to those who are not very familiar with the mvvm pattern and Kotlin coroutines.



So, we have a simple task: to receive and process a network request, to display the result in a view.



Our actions: from the activity (fragment), we call the desired method ViewModel -> ViewModel accesses the retrofit handle, executing the request through the coroutines -> the response is sent to the live data as an event -> in the activity receiving the event, we transfer the data to the view.

Project setup

Dependencies

//Retrofit implementation 'com.squareup.retrofit2:retrofit:2.6.2' implementation 'com.squareup.retrofit2:converter-gson:2.6.2' implementation 'com.squareup.okhttp3:logging-interceptor:4.2.1' //Coroutines implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-core:1.3.0' implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.3.0' //ViewModel lifecycle implementation 'androidx.lifecycle:lifecycle-extensions:2.1.0' implementation "androidx.lifecycle:lifecycle-viewmodel-ktx:2.2.0-rc01"
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

Manifesto

 <manifest ...> <uses-permission android:name="android.permission.INTERNET" /> </manifest>
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

Retrofit Setup

Create a Kotlinovsky NetworkService object. It will be our network client - singleton

UPD singleton is used for ease of understanding. The comments indicated that it is more appropriate to use control inversion, but this is a separate topic.

 object NetworkService { private const val BASE_URL = " http://www.mocky.io/v2/" // HttpLoggingInterceptor       private val loggingInterceptor = run { val httpLoggingInterceptor = HttpLoggingInterceptor() httpLoggingInterceptor.apply { httpLoggingInterceptor.level = HttpLoggingInterceptor.Level.BODY } } private val baseInterceptor: Interceptor = invoke { chain -> val newUrl = chain .request() .url .newBuilder() .build() val request = chain .request() .newBuilder() .url(newUrl) .build() return@invoke chain.proceed(request) } private val client: OkHttpClient = OkHttpClient .Builder() .addInterceptor(loggingInterceptor) .addInterceptor(baseInterceptor) .build() fun retrofitService(): Api { return Retrofit.Builder() .baseUrl(BASE_URL) .addConverterFactory(GsonConverterFactory.create()) .client(client) .build() .create(Api::class.java) } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

Api interface

We use locked requests to the fake service.



Pause the fun, here begins the magic of corutin.



We mark our functions with the keyword suspend fun ....



The retrofit learned to work with the Kotlin suspend functions from version 2.6.0, now it directly executes a network request and returns an object with data:

 interface Api { @GET("5dcc12d554000064009c20fc") suspend fun getUsers( @Query("page") page: Int ): ResponseWrapper<Users> @GET("5dcc147154000059009c2104") suspend fun getUsersError( @Query("page") page: Int ): ResponseWrapper<Users> }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

ResponseWrapper is a simple wrapper class for our network requests:

 class ResponseWrapper<T> : Serializable { @SerializedName("response") val data: T? = null @SerializedName("error") val error: Error? = null }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

Date class Users

 data class Users( @SerializedName("count") var count: Int?, @SerializedName("items") var items: List<Item?>? ) { data class Item( @SerializedName("first_name") var firstName: String?, @SerializedName("last_name") var lastName: String? ) }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

ViewModel

We create an abstract BaseViewModel class from which all our ViewModel will be inherited. Here we dwell in more detail:

 abstract class BaseViewModel : ViewModel() { var api: Api = NetworkService.retrofitService() //       requestWithLiveData  // requestWithCallback,       //           // .       suspend , //             //    .      fun <T> requestWithLiveData( liveData: MutableLiveData<Event<T>>, request: suspend () -> ResponseWrapper<T>) { //        liveData.postValue(Event.loading()) //     ViewModel,  viewModelScope. //        //    . //   IO     this.viewModelScope.launch(Dispatchers.IO) { try { val response = request.invoke() if (response.data != null) { //     postValue  IO  liveData.postValue(Event.success(response.data)) } else if (response.error != null) { liveData.postValue(Event.error(response.error)) } } catch (e: Exception) { e.printStackTrace() liveData.postValue(Event.error(null)) } } } fun <T> requestWithCallback( request: suspend () -> ResponseWrapper<T>, response: (Event<T>) -> Unit) { response(Event.loading()) this.viewModelScope.launch(Dispatchers.IO) { try { val res = request.invoke() //   ,    //       ,  //    //    //  context  launch(Dispatchers.Main) { if (res.data != null) { response(Event.success(res.data)) } else if (res.error != null) { response(Event.error(res.error)) } } } catch (e: Exception) { e.printStackTrace() // UPD (  )   catch     Main  launch(Dispatchers.Main) { response(Event.error(null)) } } } } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

Events

A cool solution from Google is to wrap date classes in an Event wrapper class in which we can have several states, usually LOADING, SUCCESS and ERROR.

 data class Event<out T>(val status: Status, val data: T?, val error: Error?) { companion object { fun <T> loading(): Event<T> { return Event(Status.LOADING, null, null) } fun <T> success(data: T?): Event<T> { return Event(Status.SUCCESS, data, null) } fun <T> error(error: Error?): Event<T> { return Event(Status.ERROR, null, error) } } } enum class Status { SUCCESS, ERROR, LOADING }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

Here's how it works. During a network request, we create an event with the status LOADING. We are waiting for a response from the server and then wrap the data with the event and send it with the specified status further. In the view, we check the type of event and, depending on the state, set different states for the view. About the same philosophy is based on the architectural pattern MVI

ActivityViewModel

 class ActivityViewModel : BaseViewModel() { //       val simpleLiveData = MutableLiveData<Event<Users>>() //  .    requestWithLiveData //  BaseViewModel     , //          //     api.getUsers //         //    fun getUsers(page: Int) { requestWithLiveData(simpleLiveData) { api.getUsers( page = page ) } } //  ,       // UPD           fun getUsersError(page: Int, callback: (data: Event<Users>) -> Unit) { requestWithCallback({ api.getUsersError( page = page ) }) { callback(it) } } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

And finally

Mainactivity

 class MainActivity : AppCompatActivity() { private lateinit var activityViewModel: ActivityViewModel override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) setContentView(R.layout.activity_main) activityViewModel = ViewModelProviders.of(this).get(ActivityViewModel::class.java) observeGetPosts() buttonOneClickListener() buttonTwoClickListener() } //     //         private fun observeGetPosts() { activityViewModel.simpleLiveData.observe(this, Observer { when (it.status) { Status.LOADING -> viewOneLoading() Status.SUCCESS -> viewOneSuccess(it.data) Status.ERROR -> viewOneError(it.error) } }) } private fun buttonOneClickListener() { btn_test_one.setOnClickListener { activityViewModel.getUsers(page = 1) } } //      ,   private fun buttonTwoClickListener() { btn_test_two.setOnClickListener { activityViewModel.getUsersError(page = 2) { when (it.status) { Status.LOADING -> viewTwoLoading() Status.SUCCESS -> viewTwoSuccess(it.data) Status.ERROR -> viewTwoError(it.error) } } } } private fun viewOneLoading() { //  ,    } private fun viewOneSuccess(data: Users?) { val usersList: MutableList<Users.Item>? = data?.items as MutableList<Users.Item>? usersList?.shuffle() usersList?.let { Toast.makeText(applicationContext, "${it}", Toast.LENGTH_SHORT).show() } } private fun viewOneError(error: Error?) { //   } private fun viewTwoLoading() {} private fun viewTwoSuccess(data: Users?) {} private fun viewTwoError(error: Error?) { error?.let { Toast.makeText(applicationContext, error.errorMsg, Toast.LENGTH_SHORT).show() } } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

Source