Feature/text core

coil/build.gradle

@@ -0,0 +1,59 @@
+apply plugin: 'com.android.library'
+apply plugin: 'kotlin-android'
+apply plugin: 'kotlin-android-extensions'
+apply plugin: 'maven-publish'
+
+group = 'com.github.Omega-R'
+
+android {
+    compileSdkVersion project.compile_sdk_version.toInteger()
+    buildToolsVersion project.build_tools_version
+
+
+    defaultConfig {
+        minSdkVersion project.min_sdk_version.toInteger()
+        targetSdkVersion project.target_sdk_version.toInteger()
+
+        testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
+
+    }
+
+    buildTypes {
+        release {
+            minifyEnabled false
+            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
+        }
+    }
+
+    kotlinOptions {
+        jvmTarget = "1.8"
+    }
+
+}
+
+gradle.projectsEvaluated {
+    publishPrebuiltPublicationToMavenLocal.dependsOn(tasks.getByName("assemble"))
+}
+
+publishing {
+    publications {
+        prebuilt(MavenPublication) {
+            artifact file("$buildDir/outputs/aar/coil-release.aar")
+        }
+    }
+}
+
+dependencies {
+    implementation fileTree(dir: 'libs', include: ['*.jar'])
+    implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:$kotlin_version"
+    api project(":core")
+    api("io.coil-kt:coil:0.9.5")
+    implementation "io.ktor:ktor-client-core:$ktor_version"
+    implementation "io.ktor:ktor-client-android:$ktor_version"
+}
+repositories {
+    mavenLocal()
+    mavenCentral()
+    jcenter()
+    google()
+}

coil/proguard-rules.pro

@@ -0,0 +1,21 @@
+# Add project specific ProGuard rules here.
+# You can control the set of applied configuration files using the
+# proguardFiles setting in build.gradle.
+#
+# For more details, see
+#   http://developer.android.com/guide/developing/tools/proguard.html
+
+# If your project uses WebView with JS, uncomment the following
+# and specify the fully qualified class name to the JavaScript interface
+# class:
+#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
+#   public *;
+#}
+
+# Uncomment this to preserve the line number information for
+# debugging stack traces.
+#-keepattributes SourceFile,LineNumberTable
+
+# If you keep the line number information, uncomment this to
+# hide the original source file name.
+#-renamesourcefileattribute SourceFile

coil/src/main/AndroidManifest.xml

@@ -0,0 +1 @@
+<manifest package="com.omega_r.entities.image.coil" />

coil/src/main/java/com/omega_r/entities/image/coil/OmegaCoilProcessorsHolder.kt

@@ -0,0 +1,192 @@
+package com.omega_r.entities.image.coil
+
+import android.content.Context
+import android.graphics.drawable.Drawable
+import android.view.View
+import android.widget.ImageView
+import android.widget.TextView
+import coil.Coil
+import coil.api.newGetBuilder
+import coil.api.newLoadBuilder
+import coil.request.GetRequestBuilder
+import coil.request.LoadRequestBuilder
+import coil.target.Target
+import com.omega_r.libs.entities.extensions.NO_PLACEHOLDER_RES
+import com.omega_r.libs.entities.extensions.toBitmapAndRecycle
+import com.omega_r.libs.entities.extensions.toInputStream
+import com.omega_r.libs.entities.images.*
+import com.omega_r.libs.entities.resources.OmegaResourceExtractor
+import io.ktor.utils.io.core.Input
+import io.ktor.utils.io.streams.asInput
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import okhttp3.HttpUrl
+import kotlin.coroutines.CoroutineContext
+import kotlin.reflect.KClass
+
+class OmegaCoilProcessorsHolder(
+    private val defaultHolder: OmegaImageProcessorsHolder = OmegaImageProcessorsHolder.Default,
+    private vararg val excludeImageClasses: KClass<out OmegaImage>
+) : OmegaImageProcessorsHolder {
+
+    companion object {
+
+        fun setAsCurrentImagesProcessor(
+            defaultHolder: OmegaImageProcessorsHolder = OmegaImageProcessorsHolder.current,
+            vararg excludeImageClasses: KClass<out OmegaImage>
+        ) {
+            OmegaImageProcessorsHolder.current = OmegaCoilProcessorsHolder(defaultHolder, *excludeImageClasses)
+        }
+
+    }
+
+    private val processor = Processor()
+
+    override fun getProcessor(entity: OmegaImage): OmegaImageProcessor<OmegaImage> {
+        return if (excludeImageClasses.contains(entity::class)) defaultHolder.getProcessor(entity) else processor
+    }
+
+    private fun createLoadRequestBuilder(context: Context, image: OmegaImage): LoadRequestBuilder? {
+        if (excludeImageClasses.contains(image::class)) return null
+
+        val requestBuilder = Coil.loader().newLoadBuilder(context)
+        return when (image) {
+            is OmegaUrlImage -> requestBuilder.data(HttpUrl.get(image.url))
+            is OmegaUriImage -> requestBuilder.data(image.uri)
+            is OmegaJavaFileImage -> requestBuilder.data(image.file)
+            is OmegaResourceImage -> requestBuilder.data(image.resource.id)
+            is OmegaDrawableImage -> requestBuilder.data(image.drawable)
+            is OmegaBitmapImage -> requestBuilder.data(image.bitmap)
+            is OmegaPlaceholderImage -> {
+                val finalImageRequestBuilder = createLoadRequestBuilder(context, image.finalImage)
+                when (val placeholderImage = image.placeholderImage) {
+                    is OmegaResourceImage -> {
+                        if (placeholderImage.resource.id != OmegaImage.NO_PLACEHOLDER_RES) {
+                            finalImageRequestBuilder?.placeholder(placeholderImage.resource.id)
+                        }
+                    }
+                    is OmegaDrawableImage -> finalImageRequestBuilder?.placeholder(placeholderImage.drawable)
+                }
+                finalImageRequestBuilder
+            }
+            else -> null
+        }
+    }
+
+    private fun createGetRequestBuilder(image: OmegaImage): GetRequestBuilder? {
+        if (excludeImageClasses.contains(image::class)) return null
+
+        val requestBuilder = Coil.loader().newGetBuilder()
+        return when (image) {
+            is OmegaUrlImage -> requestBuilder.data(HttpUrl.get(image.url))
+            is OmegaUriImage -> requestBuilder.data(image.uri)
+            is OmegaJavaFileImage -> requestBuilder.data(image.file)
+            is OmegaResourceImage -> requestBuilder.data(image.resource.id)
+            is OmegaDrawableImage -> requestBuilder.data(image.drawable)
+            is OmegaBitmapImage -> requestBuilder.data(image.bitmap)
+            is OmegaPlaceholderImage -> createGetRequestBuilder(image.finalImage)
+            else -> null
+        }
+    }
+
+    private inner class Processor : OmegaImageProcessor<OmegaImage>, CoroutineScope {
+
+        override val coroutineContext: CoroutineContext = Dispatchers.Default
+
+        override fun applyBackground(
+            image: OmegaImage,
+            view: View,
+            holder: OmegaImageProcessorsHolder,
+            extractor: OmegaResourceExtractor
+        ) {
+            createLoadRequestBuilder(view.context, image)
+                ?.target(object : Target {
+                    override fun onError(error: Drawable?) {
+                        error?.let { OmegaImageProcessor.applyBackground(view, it) }
+                    }
+
+                    override fun onStart(placeholder: Drawable?) {
+                        placeholder?.let { OmegaImageProcessor.applyBackground(view, it) }
+                    }
+
+                    override fun onSuccess(result: Drawable) {
+                        OmegaImageProcessor.applyBackground(view, result)
+                    }
+                })
+                ?.build()
+                ?.let {
+                    Coil.loader().load(it)
+                } ?: defaultHolder.getProcessor(image).applyBackground(image, view, holder, extractor)
+        }
+
+        override fun applyCompoundImage(
+            image: OmegaImage,
+            index: Int,
+            textView: TextView,
+            holder: OmegaImageProcessorsHolder,
+            extractor: OmegaResourceExtractor
+        ) {
+            createLoadRequestBuilder(textView.context, image)
+                ?.target(object : Target {
+                    override fun onError(error: Drawable?) {
+                        OmegaImageProcessor.applyCompoundDrawable(textView, error, index)
+                    }
+
+                    override fun onStart(placeholder: Drawable?) {
+                        OmegaImageProcessor.applyCompoundDrawable(textView, placeholder, index)
+                    }
+
+                    override fun onSuccess(result: Drawable) {
+                        OmegaImageProcessor.applyCompoundDrawable(textView, result, index)
+                    }
+                })
+                ?.build()
+                ?.let {
+                    Coil.loader().load(it)
+                } ?: defaultHolder.getProcessor(image).applyCompoundImage(image, index, textView, holder, extractor)
+        }
+
+        override fun applyImage(
+            image: OmegaImage,
+            imageView: ImageView,
+            holder: OmegaImageProcessorsHolder,
+            extractor: OmegaResourceExtractor
+        ) {
+            createLoadRequestBuilder(imageView.context, image)
+                ?.target(imageView)
+                ?.build()
+                ?.let {
+                    Coil.loader().load(it)
+                } ?: defaultHolder.getProcessor(image).applyImage(image, imageView, holder, extractor)
+        }
+
+        override suspend fun getInput(
+            image: OmegaImage,
+            extractor: OmegaResourceExtractor,
+            format: OmegaImage.Format,
+            quality: Int
+        ): Input? {
+            return extractor.context?.let { context ->
+                createGetRequestBuilder(image)?.let {
+                    Coil.loader()
+                        .get(it.build())
+                        .toBitmapAndRecycle {
+                            toInputStream(format = OmegaImage.Format.JPEG).asInput()
+                        }
+                } ?: defaultHolder.getProcessor(image).getInput(image, extractor, format, quality)
+            } ?: defaultHolder.getProcessor(image).getInput(image, extractor, format, quality)
+        }
+
+        override fun preload(image: OmegaImage, extractor: OmegaResourceExtractor) {
+            extractor.context?.let { context ->
+                createLoadRequestBuilder(context, image)
+                    ?.build()
+                    ?.let {
+                        Coil.loader().load(it)
+                    } ?: defaultHolder.getProcessor(image).preload(image, extractor)
+            } ?: defaultHolder.getProcessor(image).preload(image, extractor)
+        }
+
+    }
+
+}

core/build.gradle.kts

@@ -21,13 +21,11 @@ buildscript {
     dependencies {
         classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version")
         classpath("com.android.tools.build:gradle:$android_tools_version")
-        classpath("com.github.dcendents:android-maven-gradle-plugin:2.1")
     }
 }
 
 plugins {
     id("org.jetbrains.kotlin.multiplatform")
-    id("com.github.dcendents.android-maven")
     id("maven-publish")
 }
 
@@ -95,15 +93,14 @@ kotlin {
             dependencies {
                 implementation("org.jetbrains.kotlin:kotlin-stdlib")
                 implementation("io.ktor:ktor-client-android:$ktor_version")
-                compileOnly("org.robolectric:android-all:9-robolectric-4913185-2")
+                compileOnly("org.robolectric:android-all:10-robolectric-5803371")
             }
         }
 
         val androidTest by getting {
             dependencies {
                 implementation(kotlin("test"))
                 implementation(kotlin("test-junit"))
-                implementation("com.android.support.test:runner:1.0.2")
             }
         }
 

core/gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-5.5.1-all.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-5.6.4-all.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

core/src/androidMain/kotlin/com/omega_r/libs/entities/extensions/OmegaColorExtentions.kt

@@ -0,0 +1,9 @@
+package com.omega_r.libs.entities.extensions
+
+import android.annotation.ColorInt
+import com.omega_r.libs.entities.colors.OmegaColor
+import com.omega_r.libs.entities.resources.OmegaResource
+
+fun OmegaColor.Companion.fromResource(@ColorInt id: Int) = fromResource(OmegaResource.Color(id))
+
+fun Int.toOmegaColor(): OmegaColor = OmegaColor.fromResource(this)

core/src/androidMain/kotlin/com/omega_r/libs/entities/extensions/OmegaFileExtensions.kt

@@ -0,0 +1,16 @@
+package com.omega_r.libs.entities.extensions
+
+import android.net.Uri
+import com.omega_r.libs.entities.files.OmegaFile
+import com.omega_r.libs.entities.files.java_file.from
+import com.omega_r.libs.entities.files.uri.from
+import com.omega_r.libs.entities.files.url.from
+import java.io.File
+
+val Uri.file
+    get() = OmegaFile.from(this)
+
+fun File.toOmegaFile() = OmegaFile.from(this)
+
+val String.file
+    get() = OmegaFile.from(this)