HW-1: Coroutines

app/build.gradle

@@ -41,4 +41,7 @@ dependencies {
     implementation 'com.google.android.material:material:1.11.0'
     implementation 'androidx.constraintlayout:constraintlayout:2.1.4'
     implementation 'com.squareup.picasso:picasso:2.71828'
+    implementation 'androidx.lifecycle:lifecycle-viewmodel-ktx:2.8.7'
+    implementation "androidx.activity:activity-ktx:1.9.0"
+    implementation "com.jakewharton.retrofit:retrofit2-kotlin-coroutines-adapter:0.9.2"
 }

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

@@ -5,6 +5,7 @@ object CrashMonitor {
     /**
      * Pretend this is Crashlytics/AppCenter
      */
-    fun trackWarning() {
+    fun trackWarning(message: String) {
+        Utils.log { "[CrashMonitor]: $message" }
     }
 }

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

@@ -2,29 +2,63 @@ package otus.homework.coroutines
 
 import androidx.appcompat.app.AppCompatActivity
 import android.os.Bundle
+import android.widget.Button
+import android.widget.ImageView
+import android.widget.TextView
+import android.widget.Toast
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import androidx.lifecycle.ViewModelProvider
+import kotlinx.coroutines.Job
+import otus.homework.coroutines.presentation.CatsPresenter
+import otus.homework.coroutines.presentation.ViewModelFactory
+import kotlin.coroutines.CoroutineContext
 
 class MainActivity : AppCompatActivity() {
 
-    lateinit var catsPresenter: CatsPresenter
+    private lateinit var viewModel: CatsPresenter
 
-    private val diContainer = DiContainer()
+    private val job = Job()
+    private val coroutineContext: CoroutineContext
+        get() = job + Dispatchers.Main
+
+    private val scope = CoroutineScope(coroutineContext)
 
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
 
-        val view = layoutInflater.inflate(R.layout.activity_main, null) as CatsView
-        setContentView(view)
+        setContentView(R.layout.activity_main)
 
-        catsPresenter = CatsPresenter(diContainer.service)
-        view.presenter = catsPresenter
-        catsPresenter.attachView(view)
-        catsPresenter.onInitComplete()
-    }
+        viewModel = ViewModelProvider(this, ViewModelFactory())[CatsPresenter::class.java]
+
+        val imageView = findViewById<ImageView>(R.id.imageView)
+        val textView = findViewById<TextView>(R.id.fact_textView)
 
-    override fun onStop() {
-        if (isFinishing) {
-            catsPresenter.detachView()
+        viewModel.catFact.observe(this) { text ->
+            textView.text = text ?: getString(R.string.empty_dash)
+        }
+        viewModel.catImage.observe(this) { catImage ->
+            catImage?.into(imageView)
+        }
+        viewModel.errorHandle.observe(this) { message ->
+            message?.let { Toast.makeText(this, message, Toast.LENGTH_SHORT).show() }
         }
-        super.onStop()
+
+        findViewById<Button>(R.id.button).apply {
+            setOnClickListener {
+                scope.launch {
+                    viewModel.updateImage()
+                }
+                scope.launch {
+                    viewModel.updateFact()
+                }
+            }
+        }
+    }
+
+    override fun onDestroy() {
+        job.cancel()
+        super.onDestroy()
     }
 }

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

@@ -0,0 +1,7 @@
+package otus.homework.coroutines
+
+object Utils {
+    inline fun log(block: () -> String) {
+        println("[Thread: ${Thread.currentThread().name}]: " + block())
+    }
+}

app/src/main/java/otus/homework/coroutines/data/BaseRepositiory.kt

@@ -0,0 +1,74 @@
+package otus.homework.coroutines.data
+
+import com.google.gson.JsonSyntaxException
+import org.json.JSONObject
+import otus.homework.coroutines.CrashMonitor
+import otus.homework.coroutines.Utils
+import retrofit2.Response
+
+abstract class BaseRepository {
+
+    protected val network = NetworkService().createRetrofit
+
+    sealed class Result<out T : Any?> {
+        data class Success<out T : Any?>(val data: T) : Result<T>()
+        data class Error(val exception: Exception) : Result<Nothing>()
+    }
+
+    protected suspend fun <T : Any> handleApi(
+        block: suspend () -> Response<T>,
+    ): Result<T> {
+        try {
+            val response = block.invoke()
+            return when {
+                response.isSuccessful -> handleSuccess(response)
+                else -> handleError(response)
+            }
+        } catch (e: Exception) {
+            Utils.log { "[Repository]: handled error - ${e.message}" }
+            return Result.Error(e)
+        }
+    }
+
+    private fun <T : Any> handleSuccess(
+        response: Response<T>
+    ): Result<T> {
+        response.body()?.let {
+            Utils.log { "[Repository]: request is successful" }
+            return Result.Success(it)
+        }
+
+        CrashMonitor.trackWarning("[Repository]: request success - empty body")
+
+        return Result.Error(RuntimeException("Success with empty body"))
+    }
+
+    private fun <T : Any> handleError(
+        response: Response<T>
+    ): Result<T> {
+        response.errorBody()?.let { body ->
+            try {
+                val json = body.string()
+                val error = JSONObject(json)
+                val message =
+                    if (error.has("message"))
+                        error.getString("message")
+                    else
+                        "Error empty body"
+
+                CrashMonitor.trackWarning("[Repository]: request error - $message")
+
+                return Result.Error(
+                    RuntimeException(message)
+                )
+            } catch (ignored: JsonSyntaxException) {
+                Utils.log { "[Repository]: JsonSyntaxException" }
+                return Result.Error(RuntimeException("Internal json error"))
+            }
+        }
+
+        CrashMonitor.trackWarning("[Repository]: request failed - Unknown Error")
+
+        return Result.Error(RuntimeException("Unknown Error"))
+    }
+}

app/src/main/java/otus/homework/coroutines/data/CatFactResponse.kt

@@ -0,0 +1,10 @@
+package otus.homework.coroutines.data
+
+import com.google.gson.annotations.SerializedName
+
+data class CatFactResponse(
+	@SerializedName("fact")
+	val fact: String,
+	@SerializedName("length")
+	val length: Int
+)

app/src/main/java/otus/homework/coroutines/data/CatsApi.kt

@@ -0,0 +1,11 @@
+package otus.homework.coroutines.data
+
+import kotlinx.coroutines.Deferred
+import retrofit2.Response
+import retrofit2.http.GET
+
+interface CatsApi {
+
+    @GET("fact")
+    fun getCatFact(): Deferred<Response<CatFactResponse>>
+}

app/src/main/java/otus/homework/coroutines/data/CatsRepositoryImpl.kt

@@ -0,0 +1,22 @@
+package otus.homework.coroutines.data
+
+import com.squareup.picasso.Picasso
+import com.squareup.picasso.RequestCreator
+import otus.homework.coroutines.domain.CatsRepository
+
+class CatsRepositoryImpl : BaseRepository(), CatsRepository {
+
+    override suspend fun getCatFact(): String {
+        val result: Result<CatFactResponse> = handleApi {
+            network.getCatFact().await()
+        }
+        return when (result) {
+            is Result.Success -> result.data.fact
+            is Result.Error -> throw result.exception
+            }
+        }
+
+    override suspend fun getCatImage(): RequestCreator? {
+        return Picasso.get().load(NetworkService.SOURCE_CATS_IMAGES)
+    }
+}

app/src/main/java/otus/homework/coroutines/data/NetworkService.kt

@@ -0,0 +1,23 @@
+package otus.homework.coroutines.data
+
+import com.jakewharton.retrofit2.adapter.kotlin.coroutines.CoroutineCallAdapterFactory
+import retrofit2.Retrofit
+import retrofit2.converter.gson.GsonConverterFactory
+
+class NetworkService {
+
+    companion object {
+//        const val SOURCE_CATS_IMAGES = "https://cataas.com/cat"
+        const val SOURCE_CATS_IMAGES = "https://aws.random.cat/meow"
+    }
+
+    private val retrofit by lazy {
+        Retrofit.Builder()
+            .baseUrl("https://catfact.ninja/")
+            .addConverterFactory(GsonConverterFactory.create())
+            .addCallAdapterFactory(CoroutineCallAdapterFactory())
+            .build()
+    }
+
+    val createRetrofit : CatsApi by lazy { retrofit.create(CatsApi::class.java) }
+}

app/src/main/java/otus/homework/coroutines/domain/CatsInteractor.kt

@@ -0,0 +1,13 @@
+package otus.homework.coroutines.domain
+
+import com.squareup.picasso.RequestCreator
+
+class CatsInteractor(
+    private val catsRepository: CatsRepository
+) {
+    suspend fun getCatFact(): String =
+        catsRepository.getCatFact()
+
+    suspend fun getCatImage(): RequestCreator? =
+        catsRepository.getCatImage()
+}

app/src/main/java/otus/homework/coroutines/domain/CatsRepository.kt

@@ -0,0 +1,8 @@
+package otus.homework.coroutines.domain
+
+import com.squareup.picasso.RequestCreator
+
+interface CatsRepository {
+    suspend fun getCatFact(): String
+    suspend fun getCatImage(): RequestCreator?
+}