Create cloud data source for location (#33)

core/build.gradle.kts

@@ -9,4 +9,5 @@ java {
 
 dependencies {
     implementation(libs.kotlinx.coroutines.core)
+    implementation(libs.retrofit)
 }

data/cloud/build.gradle.kts → core/data/build.gradle.kts

@@ -1,10 +1,11 @@
 plugins {
-    alias(libs.plugins.jetbrains.kotlin.android)
     alias(libs.plugins.android.library)
+    alias(libs.plugins.jetbrains.kotlin.android)
+    alias(libs.plugins.kotlin.serialization)
 }
 
 android {
-    namespace = "com.github.yuriisurzhykov.purs.data.cloud"
+    namespace = "com.github.yuriisurzhykov.purs.core.data"
     compileSdk = ProjectProperties.compileSdkVersion
 
     defaultConfig {
@@ -33,9 +34,9 @@ android {
 }
 
 dependencies {
-    implementation(libs.kotlinx.coroutines.core)
-    implementation(libs.kotlinx.serialization.json)
     implementation(libs.retrofit)
+    implementation(libs.okhttp)
+    implementation(libs.okhttp.logging.interceptor)
+    implementation(libs.kotlinx.serialization.json)
     implementation(libs.retrofit.converter.kotlinx.serialization)
-    implementation(libs.javax.inject)
 }

core/data/src/main/java/com/github/yuriisurzhykov/purs/core/data/CloudDataSource.kt

@@ -0,0 +1,18 @@
+package com.github.yuriisurzhykov.purs.core.data
+
+interface CloudDataSource {
+
+    suspend fun <T> handle(block: suspend () -> T): T
+
+    abstract class Abstract(
+        private val handleError: HandleError
+    ) : CloudDataSource {
+        override suspend fun <T> handle(block: suspend () -> T): T {
+            return try {
+                block.invoke()
+            } catch (error: Exception) {
+                throw handleError.handle(error)
+            }
+        }
+    }
+}

core/data/src/main/java/com/github/yuriisurzhykov/purs/core/data/HandleError.kt

@@ -0,0 +1,6 @@
+package com.github.yuriisurzhykov.purs.core.data
+
+interface HandleError {
+
+    fun handle(exception: Exception): Exception
+}

core/data/src/main/java/com/github/yuriisurzhykov/purs/core/data/ProvideConverterFactory.kt

@@ -0,0 +1,20 @@
+package com.github.yuriisurzhykov.purs.core.data
+
+import com.jakewharton.retrofit2.converter.kotlinx.serialization.asConverterFactory
+import kotlinx.serialization.json.Json
+import okhttp3.MediaType
+import okhttp3.MediaType.Companion.toMediaType
+import retrofit2.Converter
+
+interface ProvideConverterFactory {
+
+    fun converterFactory(): Converter.Factory
+
+    abstract class Abstract(
+        private val mediaType: MediaType = "application/json; charset=UTF8".toMediaType()
+    ) : ProvideConverterFactory {
+        override fun converterFactory(): Converter.Factory {
+            return Json.asConverterFactory(mediaType)
+        }
+    }
+}

core/data/src/main/java/com/github/yuriisurzhykov/purs/core/data/ProvideInterceptor.kt

@@ -0,0 +1,19 @@
+package com.github.yuriisurzhykov.purs.core.data
+
+import okhttp3.logging.HttpLoggingInterceptor
+
+interface ProvideInterceptor {
+
+    fun interceptor(): HttpLoggingInterceptor
+
+    abstract class Abstract(
+        private val loggingLevel: HttpLoggingInterceptor.Level
+    ) : ProvideInterceptor {
+        override fun interceptor() = HttpLoggingInterceptor().apply {
+            level = loggingLevel
+        }
+    }
+
+    class Debug : Abstract(HttpLoggingInterceptor.Level.BODY)
+    class Release : Abstract(HttpLoggingInterceptor.Level.NONE)
+}

core/data/src/main/java/com/github/yuriisurzhykov/purs/core/data/ProvideOkHttpClientBuilder.kt

@@ -0,0 +1,21 @@
+package com.github.yuriisurzhykov.purs.core.data
+
+import okhttp3.OkHttpClient
+import java.util.concurrent.TimeUnit
+
+interface ProvideOkHttpClientBuilder {
+
+    fun provideOkHttpClientBuilder(): OkHttpClient.Builder
+
+    abstract class Abstract(
+        private val provideInterceptor: ProvideInterceptor,
+        private val timeoutSeconds: Long = 60L
+    ) : ProvideOkHttpClientBuilder {
+        override fun provideOkHttpClientBuilder() = OkHttpClient.Builder()
+            .addInterceptor(provideInterceptor.interceptor())
+            .connectTimeout(timeoutSeconds, TimeUnit.SECONDS)
+            .readTimeout(timeoutSeconds, TimeUnit.SECONDS)
+    }
+
+    class Base(provideInterceptor: ProvideInterceptor) : Abstract(provideInterceptor)
+}

core/data/src/main/java/com/github/yuriisurzhykov/purs/core/data/ProvideRetrofitBuilder.kt

@@ -0,0 +1,17 @@
+package com.github.yuriisurzhykov.purs.core.data
+
+import retrofit2.Retrofit
+
+interface ProvideRetrofitBuilder {
+
+    fun provideRetrofitBuilder(): Retrofit.Builder
+
+    abstract class Abstract(
+        private val provideConverterFactory: ProvideConverterFactory,
+        private val httpClientBuilder: ProvideOkHttpClientBuilder
+    ) : ProvideRetrofitBuilder {
+        override fun provideRetrofitBuilder(): Retrofit.Builder = Retrofit.Builder()
+            .addConverterFactory(provideConverterFactory.converterFactory())
+            .client(httpClientBuilder.provideOkHttpClientBuilder().build())
+    }
+}

core/src/main/java/com/github/yuriisurzhykov/purs/core/MergeStrategy.kt

@@ -0,0 +1,93 @@
+package com.github.yuriisurzhykov.purs.core
+
+interface MergeStrategy<E> {
+    fun merge(right: E, left: E): E
+}
+
+internal class RequestResponseMergeStrategy<T : Any> : MergeStrategy<RequestResult<T>> {
+    override fun merge(
+        right: RequestResult<T>,
+        left: RequestResult<T>
+    ): RequestResult<T> {
+        return when {
+            right is RequestResult.InProgress && left is RequestResult.InProgress -> merge(
+                right,
+                left
+            )
+
+            right is RequestResult.Success && left is RequestResult.InProgress -> merge(right, left)
+            right is RequestResult.InProgress && left is RequestResult.Success -> merge(right, left)
+            right is RequestResult.Success && left is RequestResult.Success -> merge(right, left)
+            right is RequestResult.Success && left is RequestResult.Error -> merge(right, left)
+            right is RequestResult.InProgress && left is RequestResult.Error -> merge(right, left)
+            right is RequestResult.Error && left is RequestResult.InProgress -> merge(right, left)
+            right is RequestResult.Error && left is RequestResult.Success -> merge(right, left)
+
+            else -> error("Unimplemented branch right=$right & left=$left")
+        }
+    }
+
+    private fun merge(
+        cache: RequestResult.InProgress<T>,
+        server: RequestResult.InProgress<T>
+    ): RequestResult<T> {
+        return when {
+            server.data != null -> RequestResult.InProgress(server.data)
+            else -> RequestResult.InProgress(cache.data)
+        }
+    }
+
+    @Suppress("UNUSED_PARAMETER")
+    private fun merge(
+        cache: RequestResult.Success<T>,
+        server: RequestResult.InProgress<T>
+    ): RequestResult<T> {
+        return RequestResult.InProgress(cache.data)
+    }
+
+    @Suppress("UNUSED_PARAMETER")
+    private fun merge(
+        cache: RequestResult.InProgress<T>,
+        server: RequestResult.Success<T>
+    ): RequestResult<T> {
+        return RequestResult.InProgress(server.data)
+    }
+
+    private fun merge(
+        cache: RequestResult.Success<T>,
+        server: RequestResult.Error<T>
+    ): RequestResult<T> {
+        return RequestResult.Error(data = cache.data, error = server.error)
+    }
+
+    @Suppress("UNUSED_PARAMETER")
+    private fun merge(
+        cache: RequestResult.Success<T>,
+        server: RequestResult.Success<T>
+    ): RequestResult<T> {
+        return RequestResult.Success(data = server.data)
+    }
+
+    private fun merge(
+        cache: RequestResult.InProgress<T>,
+        server: RequestResult.Error<T>
+    ): RequestResult<T> {
+        return RequestResult.Error(data = server.data ?: cache.data, error = server.error)
+    }
+
+    @Suppress("UNUSED_PARAMETER")
+    private fun merge(
+        cache: RequestResult.Error<T>,
+        server: RequestResult.InProgress<T>
+    ): RequestResult<T> {
+        return server
+    }
+
+    @Suppress("UNUSED_PARAMETER")
+    private fun merge(
+        cache: RequestResult.Error<T>,
+        server: RequestResult.Success<T>
+    ): RequestResult<T> {
+        return server
+    }
+}

core/src/main/java/com/github/yuriisurzhykov/purs/core/RequestResult.kt

@@ -0,0 +1,26 @@
+package com.github.yuriisurzhykov.purs.core
+
+sealed class RequestResult<out E : Any>(open val data: E? = null) {
+    data class InProgress<E : Any>(override val data: E? = null) : RequestResult<E>(data)
+
+    data class Success<E : Any>(override val data: E) : RequestResult<E>(data)
+
+    data class Error<E : Any>(override val data: E? = null, val error: Throwable? = null) :
+        RequestResult<E>(data)
+}
+
+fun <I : Any, O : Any> RequestResult<I>.map(mapper: (I) -> O): RequestResult<O> {
+    return when (this) {
+        is RequestResult.Success -> RequestResult.Success(mapper(data))
+        is RequestResult.Error -> RequestResult.Error(data?.let(mapper))
+        is RequestResult.InProgress -> RequestResult.InProgress(data?.let(mapper))
+    }
+}
+
+internal fun <T : Any> Result<T>.toRequestResult(): RequestResult<T> {
+    return when {
+        isSuccess -> RequestResult.Success(getOrThrow())
+        isFailure -> RequestResult.Error(data = null, error = exceptionOrNull())
+        else -> error("Impossible branch")
+    }
+}