Updating Retrofit interfaces and ViewModel (#43)

* Converting Retrofit interface functions to suspend functions. Converting AndroidViewModel to ViewModel.

* Refactoring DI (Retrofit), removing StringResProvider, refactoring message LiveData.

Author: IvanToplak

app/build.gradle

@@ -69,7 +69,6 @@ ext {
     timber_version = "4.7.1"
     moshi_version = "1.11.0"
     retrofit_version = "2.9.0"
-    coroutine_adapter_version = "0.9.2"
     leak_canary_version = "1.6.3"
     lifecycle_extensions = "2.2.0"
     lifecycle_version = "2.3.0"
@@ -106,7 +105,6 @@ dependencies {
     kapt "com.squareup.moshi:moshi-kotlin-codegen:$moshi_version"
     implementation "com.squareup.retrofit2:retrofit:$retrofit_version"
     implementation "com.squareup.retrofit2:converter-moshi:$retrofit_version"
-    implementation "com.jakewharton.retrofit:retrofit2-kotlin-coroutines-adapter:$coroutine_adapter_version"
 
     // Kotlin Coroutines
     implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:$coroutines_version"

app/src/main/java/com/rocketinsights/android/coroutines/DispatcherProvider.kt

@@ -0,0 +1,12 @@
+package com.rocketinsights.android.coroutines
+
+import kotlin.coroutines.CoroutineContext
+
+interface DispatcherProvider {
+
+    fun main(): CoroutineContext
+
+    fun io(): CoroutineContext
+
+    fun default(): CoroutineContext
+}

app/src/main/java/com/rocketinsights/android/coroutines/DispatcherProviderImpl.kt

@@ -0,0 +1,13 @@
+package com.rocketinsights.android.coroutines
+
+import kotlinx.coroutines.Dispatchers
+import kotlin.coroutines.CoroutineContext
+
+class DispatcherProviderImpl : DispatcherProvider {
+
+    override fun main(): CoroutineContext = Dispatchers.Main
+
+    override fun io(): CoroutineContext = Dispatchers.IO
+
+    override fun default(): CoroutineContext = Dispatchers.Default
+}

app/src/main/java/com/rocketinsights/android/di/KoinUtils.kt

@@ -1,13 +1,19 @@
 package com.rocketinsights.android.di
 
 import android.app.Application
+import com.rocketinsights.android.coroutines.DispatcherProvider
+import com.rocketinsights.android.coroutines.DispatcherProviderImpl
 import com.rocketinsights.android.network.ApiService
 import com.rocketinsights.android.repos.MessageRepository
 import com.rocketinsights.android.viewmodels.MainViewModel
 import org.koin.android.ext.koin.androidContext
 import org.koin.androidx.viewmodel.dsl.viewModel
 import org.koin.core.context.startKoin
 import org.koin.dsl.module
+import retrofit2.Retrofit
+import retrofit2.converter.moshi.MoshiConverterFactory
+
+private const val API_BASE_URL = "http://www.mocky.io/v2/"
 
 fun Application.initKoin() {
     startKoin {
@@ -17,13 +23,23 @@ fun Application.initKoin() {
 }
 
 private fun networkModule() = module {
-    single { ApiService.getApiService() }
+    single<Retrofit> {
+        Retrofit.Builder()
+            .baseUrl(API_BASE_URL)
+            .addConverterFactory(MoshiConverterFactory.create())
+            .build()
+    }
+
+    single<ApiService> {
+        get<Retrofit>().create(ApiService::class.java)
+    }
 }
 
 private fun repositoryModule() = module {
-    single { MessageRepository(get()) }
+    single<DispatcherProvider> { DispatcherProviderImpl() }
+    single { MessageRepository(get(), get()) }
 }
 
 private fun scopeModules() = module {
-    viewModel { MainViewModel(get(), get()) }
+    viewModel { MainViewModel(get()) }
 }

app/src/main/java/com/rocketinsights/android/extensions/ViewExt.kt

@@ -0,0 +1,31 @@
+package com.rocketinsights.android.extensions
+
+import android.view.View
+import android.view.View.VISIBLE
+import android.view.View.INVISIBLE
+import android.view.View.GONE
+
+fun View.show() {
+    if (visibility == VISIBLE) return
+    visibility = VISIBLE
+}
+
+fun View.hide() {
+    if (visibility == INVISIBLE) return
+    visibility = INVISIBLE
+}
+
+fun View.remove() {
+    if (visibility == GONE) return
+    visibility = GONE
+}
+
+fun View.enable() {
+    if (isEnabled) return
+    isEnabled = true
+}
+
+fun View.disable() {
+    if (!isEnabled) return
+    isEnabled = false
+}

app/src/main/java/com/rocketinsights/android/network/ApiService.kt

@@ -1,21 +1,9 @@
 package com.rocketinsights.android.network
 
-import com.jakewharton.retrofit2.adapter.kotlin.coroutines.CoroutineCallAdapterFactory
 import com.rocketinsights.android.models.Message
-import kotlinx.coroutines.Deferred
-import retrofit2.Retrofit
-import retrofit2.converter.moshi.MoshiConverterFactory
 import retrofit2.http.GET
 
 interface ApiService {
     @GET("5cd9d1383000004a20c01850")
-    fun getMessageAsync(): Deferred<Message>
-
-    companion object {
-        fun getApiService(): ApiService = Retrofit.Builder()
-                .baseUrl("http://www.mocky.io/v2/")
-                .addConverterFactory(MoshiConverterFactory.create())
-                .addCallAdapterFactory(CoroutineCallAdapterFactory())
-                .build().create(ApiService::class.java)
-    }
+    suspend fun getMessage(): Message
 }

app/src/main/java/com/rocketinsights/android/repos/MessageRepository.kt

@@ -1,7 +1,10 @@
 package com.rocketinsights.android.repos
 
+import com.rocketinsights.android.coroutines.DispatcherProvider
+import com.rocketinsights.android.models.Message
 import com.rocketinsights.android.network.ApiService
+import kotlinx.coroutines.withContext
 
-class MessageRepository(private val api: ApiService) {
-    fun getMessageAsync() = api.getMessageAsync()
+class MessageRepository(private val api: ApiService, private val dispatcher: DispatcherProvider) {
+    suspend fun getMessage(): Message = withContext(dispatcher.io()) { api.getMessage() }
 }

app/src/main/java/com/rocketinsights/android/ui/MainFragment.kt

@@ -8,9 +8,12 @@ import androidx.navigation.fragment.findNavController
 import com.bumptech.glide.Glide
 import com.rocketinsights.android.R
 import com.rocketinsights.android.databinding.FragmentMainBinding
+import com.rocketinsights.android.extensions.show
 import com.rocketinsights.android.extensions.viewBinding
+import com.rocketinsights.android.viewmodels.MainFragmentMessage
 import com.rocketinsights.android.viewmodels.MainViewModel
 import org.koin.androidx.viewmodel.ext.android.viewModel
+import retrofit2.HttpException
 
 class MainFragment : Fragment(R.layout.fragment_main) {
     private val mainViewModel: MainViewModel by viewModel()
@@ -34,8 +37,15 @@ class MainFragment : Fragment(R.layout.fragment_main) {
 
     private fun setupObservers() {
         mainViewModel.message.observe(viewLifecycleOwner, { data ->
-            binding.message.text = data?.text
-            binding.stockImage.visibility = View.VISIBLE
+            when (data) {
+                is MainFragmentMessage.Loading -> binding.message.text = getString(R.string.loading)
+                is MainFragmentMessage.Success -> binding.message.text = data.message.text
+                is MainFragmentMessage.Error -> binding.message.text =
+                    if (data.exception is HttpException) getString(R.string.http_error)
+                    else getString(R.string.unknown_error)
+            }
+
+            binding.stockImage.show()
 
             binding.message.setOnClickListener {
                 findNavController().navigate(MainFragmentDirections.actionSlideTransition())

app/src/main/java/com/rocketinsights/android/viewmodels/MainViewModel.kt

@@ -1,34 +1,40 @@
 package com.rocketinsights.android.viewmodels
 
-import android.app.Application
-import androidx.lifecycle.AndroidViewModel
+import androidx.lifecycle.LiveData
 import androidx.lifecycle.MutableLiveData
+import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
-import com.rocketinsights.android.R
 import com.rocketinsights.android.models.Message
 import com.rocketinsights.android.repos.MessageRepository
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.launch
-import retrofit2.HttpException
+import timber.log.Timber
+
+private const val ERROR_GET_MESSAGE = "Error getting messages from the remote API."
 
 class MainViewModel(
-    application: Application,
     private val repo: MessageRepository
-) : AndroidViewModel(application) {
-    val message = MutableLiveData<Message>()
+) : ViewModel() {
+
+    private val _message = MutableLiveData<MainFragmentMessage>(MainFragmentMessage.Loading)
+    val message: LiveData<MainFragmentMessage> = _message
 
     init {
-        message.postValue(Message(application.getString(R.string.loading)))
         viewModelScope.launch {
-            delay(2000)
+            delay(2000) // just to simulate 2 sec delay - remove from production code
             try {
-                val m = repo.getMessageAsync().await()
-                message.postValue(m)
-            } catch (e: HttpException) {
-                message.postValue(Message(application.getString(R.string.http_error)))
+                val m = repo.getMessage()
+                _message.value = MainFragmentMessage.Success(m)
             } catch (e: Throwable) {
-                message.postValue(Message(application.getString(R.string.unknown_error)))
+                _message.value = MainFragmentMessage.Error(e)
+                Timber.e(e, ERROR_GET_MESSAGE)
             }
         }
     }
+}
+
+sealed class MainFragmentMessage {
+    object Loading : MainFragmentMessage()
+    data class Success(val message: Message) : MainFragmentMessage()
+    data class Error(val exception: Throwable) : MainFragmentMessage()
 }

app/src/test/java/com/rocketinsights/android/ExampleUnitTest.kt

@@ -1,34 +1,46 @@
 package com.rocketinsights.android.repos
 
-import com.nhaarman.mockitokotlin2.doReturn
 import com.nhaarman.mockitokotlin2.mock
-import com.rocketinsights.android.ext.toDeferred
+import com.nhaarman.mockitokotlin2.verify
+import com.nhaarman.mockitokotlin2.whenever
+import com.rocketinsights.android.coroutines.DispatcherProvider
 import com.rocketinsights.android.models.Message
 import com.rocketinsights.android.network.ApiService
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.ExperimentalCoroutinesApi
-import kotlinx.coroutines.asCoroutineDispatcher
+import kotlinx.coroutines.test.TestCoroutineDispatcher
+import kotlinx.coroutines.test.TestCoroutineScope
+import kotlinx.coroutines.test.runBlockingTest
 import kotlinx.coroutines.test.setMain
-import org.junit.Assert
-import org.junit.Test
-
+import org.junit.Assert.assertEquals
 import org.junit.Before
-import java.util.concurrent.Executors
+import org.junit.Test
 
 @ExperimentalCoroutinesApi
 class MessageRepositoryTest {
-    private val api = mock<ApiService> {
-        on { getMessageAsync() } doReturn Message("Done!").toDeferred()
-    }
+
+    private val testDispatcher = TestCoroutineDispatcher()
+    private val testCoroutineScope = TestCoroutineScope(testDispatcher)
+    private val api = mock<ApiService>()
+    private val dispatcher = mock<DispatcherProvider>()
+    private val repo by lazy { MessageRepository(api, dispatcher) }
 
     @Before
     fun setUp() {
-        Dispatchers.setMain(Executors.newSingleThreadExecutor().asCoroutineDispatcher())
+        Dispatchers.setMain(testDispatcher)
     }
 
     @Test
-    fun getMessageAsync() {
-        val repo = MessageRepository(api)
-        Assert.assertEquals("Done!", repo.getMessageAsync().getCompleted().text)
+    fun getMessage() = testCoroutineScope.runBlockingTest {
+        // arrange
+        whenever(dispatcher.io()).thenReturn(testDispatcher)
+        whenever(api.getMessage()).thenReturn(Message("Done!"))
+
+        // act
+        val message = repo.getMessage()
+
+        // assert
+        verify(api).getMessage()
+        assertEquals("Done!", message.text)
     }
 }