Task Otus-Android#3 completed

Author: PavelScherbakov

app/build.gradle

@@ -44,5 +44,6 @@ dependencies {
     implementation 'com.squareup.picasso:picasso:2.71828'
 
     implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.6.1'
+    implementation 'androidx.fragment:fragment-ktx:1.3.6'
 
 }

app/src/main/java/otus/homework/coroutines/CatViewModel.kt renamed to app/src/main/java/otus/homework/coroutines/CatsModel.kt

@@ -1,6 +1,6 @@
 package otus.homework.coroutines
 
-data class CatViewModel(
+data class CatsModel(
     val fact: String,
     val pictureUrl: String,
 )

app/src/main/java/otus/homework/coroutines/CatsPresenter.kt

@@ -5,6 +5,7 @@ import kotlinx.coroutines.*
 import java.net.SocketTimeoutException
 import kotlin.coroutines.CoroutineContext
 
+//Не используется
 class CatsPresenter(
     private val catsService: CatsService,
     private val catPictureService: CatPictureService,
@@ -40,7 +41,7 @@ class CatsPresenter(
                     Log.e("CatsPresenter", "requests success!!!")
                     val fact = responseFact.body() as Fact
                     val picture = responsePicture.body() as Picture
-                    _catsView?.populate(CatViewModel(fact.text, picture.url))
+                    _catsView?.populate(CatsModel(fact.text, picture.url))
                 } else {
                     throw Exception(
                         if (responseFact.body() == null || responsePicture.body() == null) {

app/src/main/java/otus/homework/coroutines/CatsView.kt

@@ -15,17 +15,17 @@ class CatsView @JvmOverloads constructor(
     defStyleAttr: Int = 0
 ) : ConstraintLayout(context, attrs, defStyleAttr), ICatsView {
 
-    var presenter :CatsPresenter? = null
+    var vm: CatsVm? = null
     private val picasso by lazy { Picasso.get() }
 
     override fun onFinishInflate() {
         super.onFinishInflate()
         findViewById<Button>(R.id.button).setOnClickListener {
-            presenter?.onInitComplete()
+            vm?.onInitComplete()
         }
     }
 
-    override fun populate(model: CatViewModel) {
+    override fun populate(model: CatsModel) {
         findViewById<TextView>(R.id.fact_textView).text = model.fact
         model.pictureUrl.let { url ->
             picasso
@@ -44,6 +44,6 @@ class CatsView @JvmOverloads constructor(
 }
 
 interface ICatsView {
-    fun populate(model: CatViewModel)
+    fun populate(model: CatsModel)
     fun showToast(text: String)
 }

app/src/main/java/otus/homework/coroutines/CatsVm.kt

@@ -0,0 +1,105 @@
+package otus.homework.coroutines
+
+import android.util.Log
+import androidx.lifecycle.*
+import kotlinx.coroutines.CoroutineExceptionHandler
+import kotlinx.coroutines.async
+import kotlinx.coroutines.launch
+import java.net.SocketTimeoutException
+
+class CatsVm(
+    private val catsService: CatsService,
+    private val catPictureService: CatPictureService,
+) : ViewModel() {
+
+    init {
+        onInitComplete()
+    }
+
+    private val _showToast: MutableLiveData<String> = MutableLiveData("")
+    val showToast: LiveData<String> = _showToast
+    fun resetToast() {
+        _showToast.postValue("")
+    }
+
+    private val _catsData: MutableLiveData<CatsModel?> = MutableLiveData()
+    val catsData: LiveData<CatsModel?> = _catsData
+
+
+    fun onInitComplete() {
+        viewModelScope.launch(CoroutineExceptionHandler { coroutineContext, throwable ->
+            //Обрабатываем непредвиденную ошибку
+            CrashMonitor.trackWarning(throwable)
+            changeUI(Error(throwable.message ?: throwable.toString()))
+        }
+        ) {
+            lateinit var result: Result
+
+            try {
+                //Запускаем запросы одновременно
+                val deferredFact = async { catsService.getCatFact() }
+                val deferredPicture = async { catPictureService.getCatPicture() }
+
+                //Ждём выполнение всех запросов
+                val responseFact = deferredFact.await()
+                val responsePicture = deferredPicture.await()
+
+                //Анализируем ответы
+                if (
+                    responseFact.isSuccessful
+                    && responseFact.body() != null
+
+                    && responsePicture.isSuccessful
+                    && responsePicture.body() != null
+                    && (responsePicture.body() as Picture).url.isNotEmpty()
+                ) {
+                    Log.e("CatsVm", "requests success!!!")
+                    val fact = responseFact.body() as Fact
+                    val picture = responsePicture.body() as Picture
+                    result = Success(CatsModel(fact.text, picture.url))
+                } else {
+                    throw Exception(
+                        if (responseFact.body() == null || responsePicture.body() == null) {
+                            "Incorrect data from server"
+                        }
+                        else {
+                            if (!responseFact.isSuccessful && responsePicture.isSuccessful) {
+                                responseFact.message()
+                            }
+                            else if (responseFact.isSuccessful && !responsePicture.isSuccessful) {
+                                responsePicture.message()
+                            }
+                            else {
+                                responseFact.message() + " " + responsePicture.message()
+                            }
+                        })
+                }
+            }
+            //Обрабатываем определённые ошибки
+            catch (e: SocketTimeoutException) {
+                Log.e("CatsVm", "Error: $e")
+                result = Error("Не удалось получить ответ от сервера")
+            }
+
+            changeUI(result)
+        }
+    }
+
+    private fun changeUI(result: Result) {
+        when (result) {
+            is Error -> {
+                _showToast.postValue(result.message)
+            }
+            is Success<*> -> {
+                when (result.data) {
+                    is CatsModel -> _catsData.postValue(result.data)
+                }
+            }
+        }
+    }
+
+    class CatsVmProviderFactory(private val diContainer: DiContainer): ViewModelProvider.Factory {
+        override fun <T : ViewModel> create(modelClass: Class<T>): T =
+            CatsVm(diContainer.service, diContainer.servicePicture) as T
+    }
+}

app/src/main/java/otus/homework/coroutines/MainActivity.kt

@@ -1,31 +1,36 @@
 package otus.homework.coroutines
 
-import androidx.appcompat.app.AppCompatActivity
 import android.os.Bundle
+import androidx.activity.viewModels
+import androidx.appcompat.app.AppCompatActivity
 
 class MainActivity : AppCompatActivity() {
 
-    lateinit var catsPresenter: CatsPresenter
-
     private val diContainer = DiContainer()
 
+    private val catsVM: CatsVm by viewModels {
+        CatsVm.CatsVmProviderFactory(diContainer)
+    }
+
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
 
         val view = layoutInflater.inflate(R.layout.activity_main, null) as CatsView
         setContentView(view)
 
-        catsPresenter = CatsPresenter(diContainer.service, diContainer.servicePicture)
-        view.presenter = catsPresenter
-        catsPresenter.attachView(view)
-        catsPresenter.onInitComplete()
-    }
+        view.vm = catsVM
+
+        catsVM.showToast.observe(this) { text ->
+            text.takeIf { it.isNotEmpty() }?.let {
+                view.showToast(it)
+                catsVM.resetToast()
+            }
+        }
 
-    override fun onStop() {
-        if (isFinishing) {
-            catsPresenter.detachView()
+        catsVM.catsData.observe(this) { catsModel ->
+            catsModel?.let {
+                view.populate(it)
+            }
         }
-        catsPresenter.cancelRequests()
-        super.onStop()
     }
 }

app/src/main/java/otus/homework/coroutines/Result.kt

@@ -0,0 +1,6 @@
+package otus.homework.coroutines
+
+sealed class Result
+data class Error(val message: String) : Result()
+data class Success<T>(val data: T): Result()
+